def createScalarBar(self): if self.scalarBarWidget == None: self.scalarBarWidget = vtk.vtkScalarBarWidget() actor = self.scalarBarWidget.GetScalarBarActor() actor.SetOrientationToVertical() actor.SetNumberOfLabels(11) actor.SetTitle("Egram") actor.SetLabelFormat(" %#8.3f") actor.SetPosition(0.1, 0.1) actor.SetWidth(0.1) actor.SetHeight(0.8) layout = slicer.app.layoutManager() view = layout.threeDWidget(0).threeDView() renderer = layout.activeThreeDRenderer() self.scalarBarWidget.SetInteractor( renderer.GetRenderWindow().GetInteractor()) colorTable = slicer.mrmlScene.GetNodeByID( 'vtkMRMLColorTableNodeFileColdToHotRainbow.txt') self.lookupTable = colorTable.GetLookupTable() self.lookupTable.SetRange(self.defaultEgramValueRange[0], self.defaultEgramValueRange[1]) self.scalarBarWidget.GetScalarBarActor().SetLookupTable( self.lookupTable)
def __init__(self, point_cloud): # set renderer renderer = vtk.vtkRenderer() renderer.AddActor(point_cloud.vtkActor) renderer.SetBackground(.1, .2, .4) renderer.ResetCamera() # set the window renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) # set interactor renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # create scalar bar scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(point_cloud.lut) scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(renderWindowInteractor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() # start interactor renderWindow.Render() renderWindow.SetWindowName("CrackVis:" + point_cloud.filename) renderWindowInteractor.Start()
def add_widgets(self): # axes axes = vtk.vtkAxesActor() self.marker_widget = vtk.vtkOrientationMarkerWidget() self.marker_widget.SetInteractor(self.iren) self.marker_widget.SetOrientationMarker(axes) self.marker_widget.SetViewport(0.0, 0.0, 0.25, 0.25) # scalar bar self.scalarbar_actor = vtk.vtkScalarBarActor() self.scalarbar_actor.SetLookupTable(self.lut) self.scalarbar_widget = vtk.vtkScalarBarWidget() self.scalarbar_widget.SetInteractor(self.iren) self.scalarbar_widget.SetScalarBarActor(self.scalarbar_actor) # contour slider self.slider_rep = vtk.vtkSliderRepresentation2D() self.slider_rep.SetTitleText("contour") self.slider_rep.GetPoint1Coordinate( ).SetCoordinateSystemToNormalizedViewport() self.slider_rep.GetPoint1Coordinate().SetValue(0.65, 0.1) self.slider_rep.GetPoint2Coordinate( ).SetCoordinateSystemToNormalizedViewport() self.slider_rep.GetPoint2Coordinate().SetValue(0.95, 0.1) self.slider_widget = vtk.vtkSliderWidget() self.slider_widget.SetInteractor(self.iren) self.slider_widget.SetRepresentation(self.slider_rep) self.slider_widget.SetAnimationModeToAnimate() self.slider_widget.AddObserver(vtk.vtkCommand.InteractionEvent, self.update_contour)
def main(): colors = vtk.vtkNamedColors() # colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0]) # The source file file_name = get_program_parameters() # Create a custom lut. The lut is used for both at the mapper and at the # scalar_bar lut = vtk.vtkLookupTable() lut.Build() # Read the source file. reader = vtk.vtkUnstructuredGridReader() reader.SetFileName(file_name) reader.Update() # Needed because of GetScalarRange output = reader.GetOutput() scalar_range = output.GetScalarRange() mapper = vtk.vtkDataSetMapper() mapper.SetInputData(output) mapper.SetScalarRange(scalar_range) mapper.SetLookupTable(lut) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d('MidnightBLue')) render_window = vtk.vtkRenderWindow() render_window.AddRenderer(renderer) render_window.SetSize(300, 300) render_window.SetWindowName("ScalarBarWidget") interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(render_window) # create the scalar_bar scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(lut) # create the scalar_bar_widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(interactor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() interactor.Initialize() render_window.Render() renderer.GetActiveCamera().SetPosition(-6.4, 10.3, 1.4) renderer.GetActiveCamera().SetFocalPoint(1.0, 0.5, 3.0) renderer.GetActiveCamera().SetViewUp(0.6, 0.4, -0.7) render_window.Render() interactor.Start()
def setScaleBar(self): # lookup table lut = vtk.vtkLookupTable() lut.SetHueRange(0.667, 0) lut.SetNumberOfColors(10) lut.Build() self.scalar_bar.SetLookupTable(lut) scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(self.vtkWindow) scalar_bar_widget.SetScalarBarActor(self.scalar_bar) scalar_bar_widget.On()
def draw_model(self): #clear all actors self.main_ren.RemoveAllViewProps() self.mesh_actor, _, self.mesh_mapper, self.mesh_lut, range = read_model_data(\ self.active_vtu, \ 'S11', None, False) #create scale bar scalar_bar_widget = vtk.vtkScalarBarWidget() scalarBarRep = scalar_bar_widget.GetRepresentation() scalarBarRep.GetPositionCoordinate().SetValue(0.01,0.01) scalarBarRep.GetPosition2Coordinate().SetValue(0.09,0.9) self.sb_actor=scalar_bar_widget.GetScalarBarActor() # self.sb_actor.SetNumberOfLabels(self.ui.num_contour.value()) self.sb_actor.SetLookupTable(self.mesh_lut) self.sb_actor.SetTitle('MPa') #attempt to change scalebar properties propT = vtk.vtkTextProperty() propL = vtk.vtkTextProperty() propT.SetColor(0,0,0) propL.SetColor(0,0,0) propT.SetFontFamilyToArial() # propT.ItalicOff() propT.BoldOn() propL.BoldOff() propL.SetFontSize(1) propT.SetFontSize(1) self.sb_actor.GetLabelTextProperty().SetColor(0,0,0) self.sb_actor.GetTitleTextProperty().SetColor(0,0,0) self.sb_actor.GetLabelTextProperty().SetFontSize(1) self.sb_actor.GetTitleTextProperty().SetFontSize(1) self.sb_actor.SetLabelFormat("%.1f") self.main_ren.AddActor(self.mesh_actor) self.sub_ren.AddActor(self.mesh_actor) self.main_ren.AddActor(self.sb_actor) self.axis_actor = generate_axis_actor(self.active_vtu,self.main_ren) self.main_ren.AddActor(self.axis_actor) scalar_bar_widget.SetInteractor(self.iren) scalar_bar_widget.On() self.main_ren.ResetCamera() self.ui.vtkWidget.update()
def AddDistance(renderer,renderWindowInteractor,distance,actor): # Create the color map minD=min(distance) print("Distance min : "+str(minD)) maxD=max(distance) print("Distance max : "+str(maxD)) colorLookupTable = vtk.vtkLookupTable() colorLookupTable.SetTableRange(minD, maxD) colorLookupTable.SetHueRange(0.667, 0.0) colorLookupTable.Build() # Get Points pointPolyData=actor.GetMapper().GetInput() # Generate colors for each points colors = vtk.vtkUnsignedCharArray() colors.SetNumberOfComponents(3) colors.SetName("Colors") for i in range (pointPolyData.GetNumberOfPoints()): p= 3*[0.0] pointPolyData.GetPoint(i,p) dcolor = 3*[0.0] colorLookupTable.GetColor(distance[i], dcolor) color=3*[0.0] for j in range(0,3): color[j] = int(255.0 * dcolor[j]) colors.InsertNextTypedTuple(color) pointPolyData.GetPointData().SetScalars(colors) # create the scalar_bar scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetMaximumWidthInPixels(50) scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(colorLookupTable) scalar_bar.SetTitle("Distance") # create the scalar_bar_widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(renderWindowInteractor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() # Add the actor to the scene renderWindowInteractor.Start() renderWindowInteractor.Disable() #start required or no bar actor show
def draw_model(self,component): #clear all actors self.ren.RemoveAllViewProps() result, self.output, mesh_lut, r = read_model_data(self.active_vtu, component, None, None) self.component = component #update active component #create scale bar scalar_bar_widget = vtk.vtkScalarBarWidget() scalarBarRep = scalar_bar_widget.GetRepresentation() scalarBarRep.GetPositionCoordinate().SetValue(0.01,0.01) scalarBarRep.GetPosition2Coordinate().SetValue(0.09,0.9) sb_actor=scalar_bar_widget.GetScalarBarActor() sb_actor.SetNumberOfLabels(13) sb_actor.SetLookupTable(mesh_lut) sb_actor.SetTitle('MPa') #attempt to change scalebar properties [ineffective] propT = vtk.vtkTextProperty() propL = vtk.vtkTextProperty() propT.SetColor(0,0,0) propL.SetColor(0,0,0) propT.SetFontFamilyToArial() # propT.ItalicOff() propT.BoldOn() propL.BoldOff() propL.SetFontSize(1) propT.SetFontSize(1) sb_actor.GetLabelTextProperty().SetColor(0,0,0) sb_actor.GetTitleTextProperty().SetColor(0,0,0) sb_actor.GetLabelTextProperty().SetFontSize(1) sb_actor.GetTitleTextProperty().SetFontSize(1) sb_actor.SetLabelFormat("%.1f") self.ren.AddActor(result) self.ren.AddActor(sb_actor) self.ren.AddActor(generate_axis_actor(self.output,self.ren)) scalar_bar_widget.SetInteractor(self.iren) scalar_bar_widget.On() self.ren.ResetCamera() self.ui.vtkWidget.update() QtWidgets.QApplication.processEvents()
def Main(): global ren filename = str(sys.argv[1]) with h5py.File(filename, 'r') as f: # List all groups idx = list(f.keys())[3] # Get the data data = list(f[idx]) #Take log of data to reduce rande data = np.array(data) + 1 data = np.log10(data) * 1 #Convert the data to vtk image dataImporter = vtk.vtkImageImport() data_string = data.tostring() dataImporter.CopyImportVoidPointer(data_string, len(data_string)) print(np.max(data), np.min(data)) dataImporter.SetDataScalarTypeToFloat() dataImporter.SetNumberOfScalarComponents(1) dataImporter.SetDataExtent(0, 319, 0, 319, 0, 319) dataImporter.SetWholeExtent(0, 319, 0, 319, 0, 319) # Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(0, 0.0) opacityTransferFunction.AddPoint(1, 0.0) opacityTransferFunction.AddPoint(1.01, 0.2) opacityTransferFunction.AddPoint(1.15, 0.2) opacityTransferFunction.AddPoint(1.16, 0.0) opacityTransferFunction.AddPoint(1.70, 0.0) opacityTransferFunction.AddPoint(1.71, 0.2) opacityTransferFunction.AddPoint(1.85, 0.2) opacityTransferFunction.AddPoint(1.86, 0.0) opacityTransferFunction.AddPoint(2, 0.0) opacityTransferFunction.AddPoint(2.01, 0.2) opacityTransferFunction.AddPoint(2.15, 0.2) opacityTransferFunction.AddPoint(2.16, 0.0) opacityTransferFunction.AddPoint(2.71, 0.0) opacityTransferFunction.AddPoint(2.71, 0.2) opacityTransferFunction.AddPoint(2.85, 0.2) opacityTransferFunction.AddPoint(2.86, 0.0) opacityTransferFunction.AddPoint(3, 0.0) opacityTransferFunction.AddPoint(3.01, 0.2) opacityTransferFunction.AddPoint(3.85, 0.2) opacityTransferFunction.AddPoint(3.86, 0.0) opacityTransferFunction.AddPoint(4, 0.0) opacityTransferFunction.AddPoint(4.01, 0.2) opacityTransferFunction.AddPoint(4.85, 0.2) opacityTransferFunction.AddPoint(4.86, 0.0) #Create color tranfer function colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0, 0, 0, 1) colorTransferFunction.AddRGBPoint(2, 1, 1, 0) colorTransferFunction.AddRGBPoint(4, 1, 0, 0) # The property describes how the data will look volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.SetScalarOpacityUnitDistance(10) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() # The mapper / ray cast function know how to render the data volumeMapper = vtk.vtkSmartVolumeMapper() volumeMapper.SetBlendModeToComposite() volumeMapper.SetInputConnection(dataImporter.GetOutputPort()) # The volume holds the mapper and the property and # can be used to position/orient the volume volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) # Create the standard renderer, render window and interactor ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.AddVolume(volume) ren.SetBackground(0, 0, 0) renWin.SetSize(1600, 900) # create the scalar_bar scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(colorTransferFunction) scalar_bar.SetMaximumWidthInPixels(100) # create the scalar_bar_widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(iren) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() iren.Initialize() renWin.Render() iren.Start()
def draw_model(self): ''' Main method which updates the display of the model. ''' #Logic which bypasses the initial call from the combobox on loading if self.ui.component_cb.currentText() != '': self.component = self.ui.component_cb.currentText() if self.ui.mesh_display.isChecked(): edges = False else: edges = True #clear all actors self.ren.RemoveAllViewProps() if hasattr(self,'active_vtu') and not hasattr(self,'vtu_output'): #read the model data self.vtu_output, components = read_model_data(self.active_vtu) #update the combobox with the components self.ui.component_cb.addItems(components) self.component = self.ui.component_cb.currentText() self.mesh_actor, self.mesh_mapper, self.mesh_lut, range = generate_ug_actor(self.vtu_output, self.component, edges) self.ui.extract_boundaries_button.setEnabled(True) self.ui.export_STL_button.setEnabled(True) self.ui.update_contours_button.setEnabled(True) self.ui.extract_button.setEnabled(True) self.ui.export_line_button.setEnabled(True) elif hasattr(self,'vtu_output'): #then operate on the existing vtu's contents self.mesh_actor, self.mesh_mapper, self.mesh_lut, range = generate_ug_actor(self.vtu_output, self.component, edges) else: return #update contour limits self.ui.min_contour.setValue(range[0]) self.ui.max_contour.setValue(range[1]) #create scale bar scalar_bar_widget = vtk.vtkScalarBarWidget() scalarBarRep = scalar_bar_widget.GetRepresentation() scalarBarRep.GetPositionCoordinate().SetValue(0.01,0.01) scalarBarRep.GetPosition2Coordinate().SetValue(0.09,0.9) self.sb_actor=scalar_bar_widget.GetScalarBarActor() self.sb_actor.SetNumberOfLabels(self.ui.num_contour.value()) self.sb_actor.SetLookupTable(self.mesh_lut) self.sb_actor.SetTitle('MPa') #attempt to change scalebar properties propT = vtk.vtkTextProperty() propL = vtk.vtkTextProperty() propT.SetColor(0,0,0) propL.SetColor(0,0,0) propT.SetFontFamilyToArial() # propT.ItalicOff() propT.BoldOn() propL.BoldOff() propL.SetFontSize(1) propT.SetFontSize(1) self.sb_actor.GetLabelTextProperty().SetColor(0,0,0) self.sb_actor.GetTitleTextProperty().SetColor(0,0,0) self.sb_actor.GetLabelTextProperty().SetFontSize(1) self.sb_actor.GetTitleTextProperty().SetFontSize(1) self.sb_actor.SetLabelFormat("%.1f") self.ren.AddActor(self.mesh_actor) self.ren.AddActor(self.sb_actor) self.axis_actor = generate_axis_actor(self.vtu_output,self.ren) self.ren.AddActor(self.axis_actor) scalar_bar_widget.SetInteractor(self.iren) scalar_bar_widget.On() self.ren.ResetCamera() self.ui.vtkWidget.update()
def view_points_and_vectors(self, point_show=True, point_size=7.5, point_color=[1., 0., 0.], point_opacity=1., point_colorByScalar=False, point_scalar=[], normal_show=True, normal_length=0.3, normal_tip_radius=0.1, normal_scaleByPointScalar=False, normal_scale=1, normal_color=[0., 0., 1.], normal_opacity=1., normal_reverse=False, normal_arrowAtPoint=False, normal_colorByPointScalar=False, mesh_show=True, mesh_color=[1., 1., 1.], mesh_opacity=1, mesh_colorByScalar=False, mesh_scalar=[], camera_pos=[50,50,50], save_png=False, interact=True): '''Function to view the mesh using the VTK library. Allows for visualization of mesh, points (centroids), and normal vectors, as well as scalar fields. prior to scaling Parameters: point_show : bool Boolean operator that determines if the points are shown. point_size : float Size of points point_color : list, float VTK color specification for points [r,g,b]. point_opacity : float VTK opacity for the points. Must be between 0. and 1. point_colorByScalar : bool Boolean operator that determines if the points are colored by a scalar field 'point_scalar' rather than by constant 'point_color' point_scalar : np.array scalar value at each point. normal_show : bool Boolean operator that determines if the normals are shown. normal_length : float length of the arrows (glyphs) prior to scaling normal_tip_radius: float Tip radius of the arrows (glyphs) prior to scaling normal_scaleByPointScalar : bool Boolean operator that determines if the normal vectors are scaled by the scalar field 'point_scalar' normal_scale : float Value to scale the size of the normal glyphs by normal_color : list, float VTK color specification for the normals [r,g,b]. normal_opacity : float VTK opacity for the normals. Must be between 0. and 1. normal_reverse : bool Boolean operator that determines if the direction of the normal vectors is reversed normal_arrowAtPoint: bool Boolean operator that determines if the arrow is at the point or at the opposite edge of the glyph normal_colorByPointScalar : bool Boolean operator that determines if the normals are colored by a scalar field 'point_scalar' rather than by constant 'normal_color' mesh_show : bool Boolean operator that determines if the points are shown. mesh_color : list, float VTK color specification for the mesh [r,g,b]. mesh_opacity : float VTK opacity for the mesh. Must be between 0. and 1. mesh_colorByScalar : bool Boolean operator that determines if the mesh is colored by a scalar field 'mesh_scalar' rather than by a constant 'mesh_color' mesh_scalar : np.array scalar value at each mesh cell. camera_pos : list, floats Position of camera [X Y Z]. save_png : bool Boolean operater that determines if a .png image of the mesh is saved. interact : bool, optional Boolean operater that determines if the user can interact with the geometry (e.g. zoom and rotate) after it is displayed Examples: This example assumes that a mesh has been read by bemio and mesh data is contained in a `PanelMesh` object called `mesh` >>> mesh.view_points_and_vectors() The mesh view window must be closed in order to return command to the Python shell ''' if self.VTK_installed is False: raise VTK_Exception('VTK must be installed to use the view function') # Centroid centroid_points = vtk.vtkPoints() vertices = vtk.vtkCellArray() for ip in range(len(self.centroid)): id = centroid_points.InsertNextPoint(list(self.centroid[ip])) vertices.InsertNextCell(1) vertices.InsertCellPoint(id) centroid = vtk.vtkPolyData() centroid.SetPoints(centroid_points) centroid.SetVerts(vertices) n=np.array(list(self.normals.values())) nv = vtk.util.numpy_support.numpy_to_vtk(n) pv =centroid.GetPointData() _ = pv.SetNormals(nv) if point_colorByScalar or normal_colorByPointScalar: point_scalar = point_scalar.astype('double') vpoint_scalar = vtk.util.numpy_support.numpy_to_vtk(np.ascontiguousarray(point_scalar)) _ = pv.SetScalars(vpoint_scalar) point_scalarRange = centroid.GetScalarRange() centroid.Modified() centroidMapper=vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION >= 6: centroidMapper.SetInputData(centroid) else: centroidMapper.SetInput(centroid) if point_colorByScalar: centroidMapper.SetScalarModeToUsePointData centroidMapper.SetColorModeToMapScalars() centroidMapper.SetScalarRange(point_scalarRange) else: centroidMapper.SetColorModeToDefault() centroidMapper.SetScalarVisibility(0) centroidActor = vtk.vtkActor() centroidActor.SetMapper(centroidMapper) centroidActor.GetProperty().SetPointSize(point_size) centroidActor.GetProperty().SetOpacity(point_opacity) if not point_colorByScalar: centroidActor.GetProperty().SetColor(point_color) # Normals def MakeGlyphs(src, normal_reverse, normal_arrowAtPoint): reverse = vtk.vtkReverseSense() maskPts = vtk.vtkMaskPoints() maskPts.SetOnRatio(1) if normal_reverse: reverse.SetInputData(src) reverse.ReverseCellsOn() reverse.ReverseNormalsOn() maskPts.SetInputConnection(reverse.GetOutputPort()) else: maskPts.SetInputData(src) arrow = vtk.vtkArrowSource() if normal_arrowAtPoint: arrow.SetInvert(1) else: arrow.SetInvert(0) arrow.SetTipResolution(16) arrow.SetTipLength(normal_length) arrow.SetTipRadius(normal_tip_radius) glyph = vtk.vtkGlyph3D() glyph.SetSourceConnection(arrow.GetOutputPort()) glyph.SetInputConnection(maskPts.GetOutputPort()) glyph.SetVectorModeToUseNormal() glyph.SetScaleFactor(normal_scale) if normal_scaleByPointScalar: glyph.SetScaleModeToScaleByScalar() else: glyph.SetScaleModeToScaleByVector() glyph.SetColorModeToColorByScalar() glyph.OrientOn() return glyph glyph = MakeGlyphs(centroid,normal_reverse,normal_arrowAtPoint) glyphMapper = vtk.vtkPolyDataMapper() glyphMapper.SetInputConnection(glyph.GetOutputPort()) glyphActor = vtk.vtkActor() glyphActor.SetMapper(glyphMapper) glyphActor.GetProperty().SetOpacity(normal_opacity) if not normal_colorByPointScalar: glyphActor.GetProperty().SetColor(normal_color) if normal_colorByPointScalar: glyphMapper.SetScalarModeToUsePointData() glyphMapper.SetScalarVisibility(1) glyphMapper.SetColorModeToMapScalars() normal_scalarRange = centroid.GetScalarRange() glyphMapper.SetScalarRange(normal_scalarRange) else: glyphMapper.SetScalarVisibility(0) glyphMapper.SetColorModeToDefault() # Mesh if mesh_colorByScalar: cv = self.vtp_mesh.GetCellData() mesh_scalar = mesh_scalar.astype('double') vmesh_scalar = vtk.util.numpy_support.numpy_to_vtk(np.ascontiguousarray(mesh_scalar)) _ = cv.SetScalars(vmesh_scalar) meshMapper=vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION >= 6: meshMapper.SetInputData(self.vtp_mesh) else: meshMapper.SetInput(self.vtp_mesh) if mesh_colorByScalar: meshMapper.SetScalarModeToUseCellData meshMapper.SetColorModeToMapScalars() mesh_scalarRange = self.vtp_mesh.GetScalarRange() meshMapper.SetScalarRange(mesh_scalarRange) else: meshMapper.SetScalarVisibility(0) meshActor=vtk.vtkActor() meshActor.SetMapper(meshMapper) meshActor.GetProperty().EdgeVisibilityOn() meshActor.GetProperty().SetOpacity(mesh_opacity) if not mesh_colorByScalar: meshActor.GetProperty().SetColor(mesh_color) # bars if point_colorByScalar or normal_colorByPointScalar: lut = centroidMapper.GetLookupTable() lut.SetNumberOfTableValues(256) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.SetColorSpaceToDiverging() colorTransferFunction.AddRGBPoint(0,0.231373,0.298039,0.752941) colorTransferFunction.AddRGBPoint(0.5,0.865003,0.865003,0.865003) colorTransferFunction.AddRGBPoint(1.0,0.705882,0.0156863,0.14902) for ii,ss in enumerate([float(xx)/float(256) for xx in range(256)]): cc = colorTransferFunction.GetColor(ss) lut.SetTableValue(ii,cc[0],cc[1],cc[2],1.0) lut.Build() centroidMapper.SetLookupTable(lut) glyphMapper.SetLookupTable(lut) point_bar = vtk.vtkScalarBarActor() point_bar.SetLookupTable(lut) point_bar.SetTitle('Point Scalar') if mesh_colorByScalar: mesh_lut = meshMapper.GetLookupTable() mesh_lut.SetNumberOfTableValues(256) mesh_colorTransferFunction = vtk.vtkColorTransferFunction() mesh_colorTransferFunction.SetColorSpaceToDiverging() mesh_colorTransferFunction.AddRGBPoint(0,0.231373,0.298039,0.752941) mesh_colorTransferFunction.AddRGBPoint(0.5,0.865003,0.865003,0.865003) mesh_colorTransferFunction.AddRGBPoint(1.0,0.705882,0.0156863,0.14902) for ii,ss in enumerate([float(xx)/float(256) for xx in range(256)]): mesh_cc = mesh_colorTransferFunction.GetColor(ss) mesh_lut.SetTableValue(ii,mesh_cc[0],mesh_cc[1],mesh_cc[2],1.0) mesh_lut.Build() meshMapper.SetLookupTable(mesh_lut) mesh_bar = vtk.vtkScalarBarActor() mesh_bar.SetLookupTable(mesh_lut) mesh_bar.SetTitle('Mesh Scalar') # Camera camera = vtk.vtkCamera(); camera.SetPosition(camera_pos) camera.SetFocalPoint(0, 0, 0) # Add axes axes = vtk.vtkAxesActor() # Render the data ren = vtk.vtkRenderer() if mesh_show: ren.AddActor(meshActor) if point_show: ren.AddActor(centroidActor) if normal_show: ren.AddActor(glyphActor) ren.AddActor(axes) ren.SetActiveCamera(camera) ren.SetBackground(0,0,0) # Create a render window renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(800, 800) # Create interactive renderer iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Start the bar widgets if point_colorByScalar or normal_colorByPointScalar: point_bar_widget = vtk.vtkScalarBarWidget() point_bar_widget.SetInteractor(iren) point_bar_widget.SetScalarBarActor(point_bar) point_bar_widget.On() if mesh_colorByScalar: mesh_bar_widget = vtk.vtkScalarBarWidget() mesh_bar_widget.SetInteractor(iren) mesh_bar_widget.SetScalarBarActor(mesh_bar) mesh_bar_widget.On() # Render renWin.Render() vtk.vtkPolyDataMapper().SetResolveCoincidentTopologyToPolygonOffset() # Save image if save_png is True: w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(renWin) w2if.Update() writer = vtk.vtkPNGWriter() writer.SetFileName(self.files['png']) writer.SetInputDataObject(w2if.GetOutput()) writer.Write() print('Wrote mesh image to: ' + self.files['png']) # Set interaction mode if interact is True: iren.Start()
def draw_vtk(nodes, elements, values=None, colors_count=256, contours_count=10, use_gray=False, title=None, background=(0.95, 0.95, 0.95), show_mesh=False, mesh_color=(0.25, 0.25, 0.25), use_cell_data=False, show_labels=False, show_axes=False): """ Function draws planar unstructured mesh using vtk :param show_axes: if it equals true than axes is drawn :param use_cell_data: if it equals true than cell data is used to colorize zones :param show_labels: if it equals true than labels are shown :param show_mesh: if it equals true than mesh lines are shown :param mesh_color: color of mesh lines (polygons edges) :param contours_count: Contour lines count :param title: Title of the scalar bar :param background: Background RGB-color value :param use_gray: if it equals true than gray-scale colormap is used :param colors_count: Colors count for values visualization :param nodes: nodes array [nodes_count; 2] :param elements: elements array [elements_count; element_nodes] :param values: values array (coloring rule) :return: nothing """ import vtk points = vtk.vtkPoints() for n in nodes: points.InsertNextPoint([n[0], n[1], 0.0]) cells_array = vtk.vtkCellArray() for el in elements: polygon = vtk.vtkPolygon() polygon.GetPointIds().SetNumberOfIds(len(el)) for i in range(len(el)): polygon.GetPointIds().SetId(i, el[i]) cells_array.InsertNextCell(polygon) lut = vtk.vtkLookupTable() lut.SetNumberOfTableValues(colors_count) lut.SetHueRange(0.66667, 0.0) if use_gray: lut.SetValueRange(1.0, 0.0) lut.SetSaturationRange(0.0, 0.0) # no color saturation lut.SetRampToLinear() lut.Build() renderer = vtk.vtkRenderer() renderer.SetBackground(background) render_window = vtk.vtkRenderWindow() render_window.AddRenderer(renderer) render_window_interactor = vtk.vtkRenderWindowInteractor() render_window_interactor.SetRenderWindow(render_window) bcf_actor = vtk.vtkActor() bcf_mapper = vtk.vtkPolyDataMapper() poly_data = vtk.vtkPolyData() poly_data.SetPoints(points) poly_data.SetPolys(cells_array) if values is not None: scalars = vtk.vtkFloatArray() for v in values: scalars.InsertNextValue(v) poly_data.GetPointData().SetScalars(scalars) bcf = vtk.vtkBandedPolyDataContourFilter() if vtk.VTK_MAJOR_VERSION <= 5: bcf.SetInput(poly_data) else: bcf.SetInputData(poly_data) bcf.SetNumberOfContours(contours_count) bcf.GenerateValues(contours_count, [values.min(), values.max()]) bcf.SetNumberOfContours(contours_count + 1) bcf.SetScalarModeToValue() bcf.GenerateContourEdgesOn() bcf.Update() bcf_mapper.ImmediateModeRenderingOn() if vtk.VTK_MAJOR_VERSION <= 5: bcf_mapper.SetInput(bcf.GetOutput()) else: bcf_mapper.SetInputData(bcf.GetOutput()) bcf_mapper.SetScalarRange(values.min(), values.max()) bcf_mapper.SetLookupTable(lut) bcf_mapper.ScalarVisibilityOn() if use_cell_data: bcf_mapper.SetScalarModeToUseCellData() bcf_actor.SetMapper(bcf_mapper) renderer.AddActor(bcf_actor) edge_mapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: edge_mapper.SetInput(bcf.GetContourEdgesOutput()) else: edge_mapper.SetInputData(bcf.GetContourEdgesOutput()) edge_mapper.SetResolveCoincidentTopologyToPolygonOffset() edge_actor = vtk.vtkActor() edge_actor.SetMapper(edge_mapper) if use_gray: edge_actor.GetProperty().SetColor(0.0, 1.0, 0.0) else: edge_actor.GetProperty().SetColor(0.0, 0.0, 0.0) renderer.AddActor(edge_actor) if show_labels: mask = vtk.vtkMaskPoints() if vtk.VTK_MAJOR_VERSION <= 5: mask.SetInput(bcf.GetOutput()) else: mask.SetInputData(bcf.GetOutput()) mask.SetOnRatio(bcf.GetOutput().GetNumberOfPoints() / 20) mask.SetMaximumNumberOfPoints(20) # Create labels for points - only show visible points visible_points = vtk.vtkSelectVisiblePoints() visible_points.SetInputConnection(mask.GetOutputPort()) visible_points.SetRenderer(renderer) ldm = vtk.vtkLabeledDataMapper() ldm.SetInputConnection(mask.GetOutputPort()) ldm.SetLabelFormat("%.2E") ldm.SetLabelModeToLabelScalars() text_property = ldm.GetLabelTextProperty() text_property.SetFontFamilyToArial() text_property.SetFontSize(10) if use_gray: text_property.SetColor(0.0, 1.0, 0.0) else: text_property.SetColor(0.0, 0.0, 0.0) text_property.ShadowOff() text_property.BoldOff() contour_labels = vtk.vtkActor2D() contour_labels.SetMapper(ldm) renderer.AddActor(contour_labels) scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(lut) if title is not None: scalar_bar.SetTitle(title) scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(render_window_interactor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() else: if vtk.VTK_MAJOR_VERSION <= 5: bcf_mapper.SetInput(poly_data) else: bcf_mapper.SetInputData(poly_data) bcf_actor.GetProperty().SetColor(0.0, 1.0, 0.0) if show_mesh: bcf_actor.GetProperty().EdgeVisibilityOn() bcf_actor.GetProperty().SetEdgeColor(mesh_color) bcf_actor.SetMapper(bcf_mapper) renderer.AddActor(bcf_actor) if show_axes: axes = vtk.vtkAxesActor() renderer.AddActor(axes) render_window.Render() render_window_interactor.Start()
def AddASD_actors(self, ren, renWin, mode, viz_type, iren): ASDMomActors.timer_count = 0 ASDMomActors.camera_pos = np.zeros(3, dtype=np.float32) ASDMomActors.camera_focal = np.zeros(3, dtype=np.float32) ASDMomActors.camera_yaw = 0.0 ASDMomActors.camera_roll = 0.0 ASDMomActors.camera_pitch = 0.0 ASDMomActors.camera_azimuth = 0.0 ASDMomActors.camera_elevation = 0.0 ASD_data = ASDVTKReading.ASDReading() # Add the data structures with regards to reading the data ASD_data.ReadingWrapper(mode=mode, viz_type=viz_type) ASDMomActors.kmc_disp = ASD_data.kmc_flag ASDMomActors.cluster_disp = ASD_data.cluster_flag ######################################################################## # Data structures for the generation of the smooth grid ######################################################################## ASDMomActors.glob_flag_2D = ASD_data.flag_2D ASDMomActors.glob_color_x = ASD_data.selected_colors_x ASDMomActors.glob_color_y = ASD_data.selected_colors_y ASDMomActors.glob_color_z = ASD_data.selected_colors_z ######################################################################## # Look up tables for colors ######################################################################## # This is a diverging RWB color mapping based on the work of Kenneth # Moreland and with the vtk examples provided by Andrew Maclean if ASDMomActors.glob_flag_2D: self.lut = vtk.vtkLookupTable() num_colors = 256 self.lut.SetNumberOfTableValues(num_colors) self.transfer_func = vtk.vtkColorTransferFunction() self.transfer_func.SetColorSpaceToDiverging() self.transfer_func.AddRGBPoint(0, 0.230, 0.299, 0.754) self.transfer_func.AddRGBPoint(1, 0.706, 0.016, 0.150) for ii, ss in enumerate( [float(xx) / float(num_colors) for xx in range(num_colors)]): cc = self.transfer_func.GetColor(ss) self.lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0) self.lut.Build() else: self.lut = vtk.vtkLookupTable() num_colors = 256 self.lut.SetNumberOfTableValues(num_colors) self.transfer_func = vtk.vtkColorTransferFunction() self.transfer_func.SetColorSpaceToDiverging() self.transfer_func.AddRGBPoint(-0, 0.230, 0.299, 0.754) self.transfer_func.AddRGBPoint(1, 0.706, 0.016, 0.150) for ii, ss in enumerate( [float(xx) / float(num_colors) for xx in range(num_colors)]): cc = self.transfer_func.GetColor(ss) self.lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0) self.lut.Build() ######################################################################## # Data structures for the generation of the smooth grid ######################################################################## # Passing the data from the full system to the PolyData ASDMomActors.src = vtk.vtkPolyData() ASDMomActors.src.SetPoints(ASD_data.selected_points) ASDMomActors.src.GetPointData().SetScalars(ASD_data.selected_colors_z) ASDMomActors.src.GetPointData().SetVectors(ASD_data.selected_vectors) scalar_range = ASDMomActors.src.GetScalarRange() ######################################################################## # Finding useful geometrical information of the sample ######################################################################## # Finding the middle of the sample # Also making sure that if the sample is 2D one has no problem with boudings # this is mostly useful if splatters are used (ASDMomActors.xmin, ASDMomActors.xmax, ASDMomActors.ymin, ASDMomActors.ymax, ASDMomActors.zmin, ASDMomActors.zmax) = ASDMomActors.src.GetBounds() if ASDMomActors.xmin == ASDMomActors.xmax: ASDMomActors.xmin = 0.0 ASDMomActors.xmax = 1.0 if ASDMomActors.ymin == ASDMomActors.ymax: ASDMomActors.ymin = 0.0 ASDMomActors.ymax = 1.0 if ASDMomActors.zmin == ASDMomActors.zmax: ASDMomActors.zmin = 0.0 ASDMomActors.zmax = 1.0 ASDMomActors.xmid = (ASDMomActors.xmin + ASDMomActors.xmax) * 0.5 ASDMomActors.ymid = (ASDMomActors.ymin + ASDMomActors.ymax) * 0.5 ASDMomActors.zmid = (ASDMomActors.zmin + ASDMomActors.zmax) * 0.5 ASDMomActors.height = max(ASDMomActors.xmax, ASDMomActors.ymax, ASDMomActors.zmax) * 1.75 self.dist_x = np.absolute(ASDMomActors.xmax - ASDMomActors.xmin) self.dist_y = np.absolute(ASDMomActors.ymax - ASDMomActors.ymin) self.dist_z = np.absolute(ASDMomActors.zmax - ASDMomActors.zmin) ASDMomActors.camera_pos[0] = ASDMomActors.xmid ASDMomActors.camera_pos[1] = ASDMomActors.ymid ASDMomActors.camera_pos[2] = ASDMomActors.height ASDMomActors.camera_focal[0] = ASDMomActors.xmid ASDMomActors.camera_focal[1] = ASDMomActors.ymid ASDMomActors.camera_focal[2] = ASDMomActors.zmid # The delaunay tesellation seems to be the best way to transform the point cloud # to a surface for volume rendering, the problem is that it is too slow for large # data sets, meaning that the best option is first to prune out the data to ensure # that one has a manageable number of data points over which to do the construction # surface reconstruction and splatter techniques also can be used to generate something # akin to the kind of surfaces we want. The issue is that they transform the data to a # regular mesh by default. And thus it is a problem for most kind of systems if ASDMomActors.glob_flag_2D: # Passing the data to generate a triangulation of the data MagDensMethod = vtk.vtkDelaunay2D() MagDensMethod.SetInputData(ASDMomActors.src) MagDensMethod.BoundingTriangulationOff() MagDensMethod.SetTolerance(0.005) # Time the execution of the delaunay tessellation SM_timer = vtk.vtkExecutionTimer() SM_timer.SetFilter(MagDensMethod) MagDensMethod.Update() SM = SM_timer.GetElapsedWallClockTime() print("2D Delaunay:", SM) # Creating the mapper for the smooth surfaces ASDMomActors.MagDensMap = vtk.vtkDataSetMapper() ASDMomActors.MagDensMap.SetScalarRange(scalar_range) ASDMomActors.MagDensMap.SetInputConnection( MagDensMethod.GetOutputPort()) ASDMomActors.MagDensMap.SetLookupTable(self.lut) ASDMomActors.MagDensMap.SetColorModeToMapScalars() ASDMomActors.MagDensMap.Update() # Creating the actor for the smooth surfaces ASDMomActors.MagDensActor = vtk.vtkLODActor() ASDMomActors.MagDensActor.SetMapper(ASDMomActors.MagDensMap) ASDMomActors.MagDensActor.GetProperty().SetOpacity(0.75) ASDMomActors.MagDensActor.GetProperty().EdgeVisibilityOff() else: #################################################################### # Setting the parameters for the visualization of 3D structures with # splatters #################################################################### MagDensMethod = vtk.vtkShepardMethod() MagDensMethod.SetInputData(ASDMomActors.src) MagDensMethod.SetModelBounds(ASDMomActors.xmin, ASDMomActors.xmax, ASDMomActors.ymin, ASDMomActors.ymax, ASDMomActors.zmin, ASDMomActors.zmax) # This should get rid of the problems when trying to map very thin structures in 2D if self.dist_x == min(self.dist_x, self.dist_y, self.dist_z): MagDensMethod.SetSampleDimensions(3, int(ASDMomActors.ymax), int(ASDMomActors.zmax)) elif self.dist_y == min(self.dist_x, self.dist_y, self.dist_z): MagDensMethod.SetSampleDimensions(int(ASDMomActors.xmax), 3, int(ASDMomActors.zmax)) elif self.dist_z == min(self.dist_x, self.dist_y, self.dist_z): MagDensMethod.SetSampleDimensions(int(ASDMomActors.xmax), int(ASDMomActors.ymax), 3) # This parameter determines how far in the sample (normalized to 1) the # method will look to interpolate, greatly affects performance MagDensMethod.SetMaximumDistance(0.1) # Time the execution of the checkerboard splatter SP_timer = vtk.vtkExecutionTimer() SP_timer.SetFilter(MagDensMethod) MagDensMethod.Update() SP = SP_timer.GetElapsedWallClockTime() print("3D Shepard Method:", SP) # Mapper for the image obtained from the 3D reconstruction method ASDMomActors.MagDensMap = vtk.vtkSmartVolumeMapper() ASDMomActors.MagDensMap.SetBlendModeToComposite() ASDMomActors.MagDensMap.SetInputConnection( MagDensMethod.GetOutputPort()) # Function for the opacity gradient volumeGradientOpacity = vtk.vtkPiecewiseFunction() volumeGradientOpacity.AddPoint(-1, 0.25) volumeGradientOpacity.AddPoint(0.5, 0.75) volumeGradientOpacity.AddPoint(1.0, 1.0) # Properties of the volume to be rendered ASDMomActors.volumeProperty = vtk.vtkVolumeProperty() ASDMomActors.volumeProperty.SetInterpolationType(1) ASDMomActors.volumeProperty.SetColor(self.transfer_func) ASDMomActors.volumeProperty.SetAmbient(0.6) ASDMomActors.volumeProperty.SetDiffuse(0.6) ASDMomActors.volumeProperty.SetSpecular(0.1) ASDMomActors.volumeProperty.SetGradientOpacity( volumeGradientOpacity) #volumeProperty.ShadeOn() # Volume actor, this works in a different way than LOD actors ASDMomActors.MagDensActor = vtk.vtkVolume() ASDMomActors.MagDensActor.SetMapper(ASDMomActors.MagDensMap) ASDMomActors.MagDensActor.SetProperty(self.volumeProperty) #################################################################### # Alternative rendering methods #################################################################### # The checkerboard splatter method, much faster than the Shepard method # however, it seems to change the values of the scalars embeded in the # point data which results in incorrect diplay of the magnetization #cbdSplatter = vtk.vtkCheckerboardSplatter() #cbdSplatter.ScalarWarpingOff() #cbdSplatter.SetFootprint(2) #cbdSplatter.SetExponentFactor(-5) #cbdSplatter.SetParallelSplatCrossover(2) #cbdSplatter.SetOutputScalarTypeToDouble() #cbdSplatter.CappingOn() #cbdSplatter.ScalarWarpingOn() #cbdSplatter.SetRadius(1) # 3D delaunay method, the far superior as it conserves the shape of the # sample, however it is extremely slow, with a rendering of a 3D image # taking several minutes #smooth_loop = vtk.vtkDelaunay3D() #smooth_loop.SetInputData(self.src) #smooth_loop.SetTolerance(0.01) #smooth_loop.SetAlpha(2) #smooth_loop.AlphaTrisOff() #smooth_loop.Update() ######################################################################## # Data structures for the spins ######################################################################## # Passing the data from the full system to the PolyData ASDMomActors.src_spins = vtk.vtkPolyData() ASDMomActors.src_spins.SetPoints(ASD_data.selected_points) ASDMomActors.src_spins.GetPointData().SetScalars( ASD_data.selected_colors_z) ASDMomActors.src_spins.GetPointData().SetVectors( ASD_data.selected_vectors) scalar_range_spins = ASDMomActors.src_spins.GetScalarRange() ######################################################################## # Data structures for the contours ######################################################################## # Define the contour filters contours = vtk.vtkContourFilter() contours.SetInputConnection(MagDensMethod.GetOutputPort()) # This generates the contours, it will do 5 between the -1 and 0.5 range cont_num = 5 range_cont = (-1, 0.5) contours.GenerateValues(cont_num, range_cont) # Map the contours to graphical primitives contMapper = vtk.vtkPolyDataMapper() contMapper.SetInputConnection(contours.GetOutputPort()) contMapper.SetScalarVisibility(False) # colored contours contMapper.SetScalarRange(scalar_range) # Create an actor for the contours ASDMomActors.contActor = vtk.vtkLODActor() ASDMomActors.contActor.SetMapper(contMapper) ASDMomActors.contActor.GetProperty().SetColor(0, 0, 0) ASDMomActors.contActor.GetProperty().SetLineWidth(1.0) ASDMomActors.contActor.VisibilityOff() ######################################################################## # Data structures for the impurity cluster ######################################################################## if ASD_data.cluster_flag: # Passing the data from the cluster to the PolyData src_clus = vtk.vtkPolyData() src_clus.SetPoints(ASD_data.coord_c) src_clus.GetPointData().SetScalars(ASD_data.colors_clus) # Passing the data from the selected impurities src_imp = vtk.vtkPolyData() src_imp.SetPoints(ASD_data.points_clus_imp) src_imp.GetPointData().SetScalars(ASD_data.colors_imp) src_imp.Modified() atomSource = vtk.vtkDelaunay2D() atomSource.SetInputData(src_clus) atomSource.BoundingTriangulationOff() atomSource.SetTolerance(0.05) atomSource.Update() smoothFilter = vtk.vtkSmoothPolyDataFilter() smoothFilter.SetInputConnection(atomSource.GetOutputPort()) smoothFilter.SetNumberOfIterations(5) smoothFilter.SetRelaxationFactor(0.1) smoothFilter.FeatureEdgeSmoothingOff() smoothFilter.BoundarySmoothingOn() smoothFilter.Update() # Creating the mapper for the smooth surfaces atomMapper = vtk.vtkDataSetMapper() atomMapper.SetScalarRange(scalar_range) atomMapper.SetInputConnection(smoothFilter.GetOutputPort()) atomMapper.SetColorMode(2) atomMapper.Update() # Creating the actor for the smooth surfaces ASDMomActors.atom = vtk.vtkLODActor() ASDMomActors.atom.SetMapper(atomMapper) ASDMomActors.atom.GetProperty().EdgeVisibilityOff() ASDMomActors.atom.GetProperty().SetSpecularPower(30) ASDMomActors.atom.GetProperty().SetAmbient(0.2) ASDMomActors.atom.GetProperty().SetDiffuse(0.8) ASDMomActors.atom.GetProperty().SetOpacity(0.50) # Set up imp sources atomSource_imp = vtk.vtkSphereSource() atomSource_imp.SetRadius(2.5) atomSource_imp.SetThetaResolution(20) atomSource_imp.SetPhiResolution(20) # Mapping the spheres to the actual points on the selected impurities atomMapper_imp = vtk.vtkGlyph3DMapper() atomMapper_imp.SetInputData(src_imp) atomMapper_imp.SetSourceConnection(atomSource_imp.GetOutputPort()) atomMapper_imp.SetScaleFactor(0.2) atomMapper_imp.SetScaleModeToNoDataScaling() atomMapper_imp.Update() # Creating the selected impurity actors ASDMomActors.atom_imp = vtk.vtkLODActor() ASDMomActors.atom_imp.SetMapper(atomMapper_imp) ASDMomActors.atom_imp.GetProperty().SetSpecular(0.3) ASDMomActors.atom_imp.GetProperty().SetSpecularPower(30) ASDMomActors.atom_imp.GetProperty().SetAmbient(0.2) ASDMomActors.atom_imp.GetProperty().SetDiffuse(0.8) ######################################################################## # Setting information of the directions ######################################################################## # Create vectors arrow = vtk.vtkArrowSource() arrow.SetTipRadius(0.20) arrow.SetShaftRadius(0.10) arrow.SetTipResolution(20) arrow.SetShaftResolution(20) # Create the mapper for the spins arrowMapper = vtk.vtkGlyph3DMapper() arrowMapper.SetSourceConnection(arrow.GetOutputPort()) arrowMapper.SetInputData(ASDMomActors.src) arrowMapper.SetScaleFactor(0.50) arrowMapper.SetScalarVisibility(False) arrowMapper.SetScaleModeToNoDataScaling() arrowMapper.Update() # Define the vector actor for the spins ASDMomActors.vector = vtk.vtkLODActor() ASDMomActors.vector.SetMapper(arrowMapper) ASDMomActors.vector.GetProperty().SetSpecular(0.3) ASDMomActors.vector.GetProperty().SetSpecularPower(60) ASDMomActors.vector.GetProperty().SetAmbient(0.2) ASDMomActors.vector.GetProperty().SetDiffuse(0.8) ASDMomActors.vector.GetProperty().SetColor(0, 0, 0) ASDMomActors.vector.VisibilityOff() ######################################################################## # Setting information of the spins ######################################################################## # Create vectors ASDMomActors.spinarrow = vtk.vtkArrowSource() ASDMomActors.spinarrow.SetTipRadius(0.20) ASDMomActors.spinarrow.SetShaftRadius(0.10) ASDMomActors.spinarrow.SetTipResolution(20) ASDMomActors.spinarrow.SetShaftResolution(20) # Create the mapper for the spins ASDMomActors.SpinMapper = vtk.vtkGlyph3DMapper() ASDMomActors.SpinMapper.SetSourceConnection( ASDMomActors.spinarrow.GetOutputPort()) ASDMomActors.SpinMapper.SetInputData(ASDMomActors.src_spins) ASDMomActors.SpinMapper.SetScalarRange(scalar_range_spins) ASDMomActors.SpinMapper.SetScaleFactor(0.50) ASDMomActors.SpinMapper.SetScaleModeToNoDataScaling() ASDMomActors.SpinMapper.SetLookupTable(self.lut) ASDMomActors.SpinMapper.SetColorModeToMapScalars() ASDMomActors.SpinMapper.Update() # Define the vector actor for the spins ASDMomActors.Spins = vtk.vtkLODActor() ASDMomActors.Spins.SetMapper(ASDMomActors.SpinMapper) ASDMomActors.Spins.GetProperty().SetSpecular(0.3) ASDMomActors.Spins.GetProperty().SetSpecularPower(60) ASDMomActors.Spins.GetProperty().SetAmbient(0.2) ASDMomActors.Spins.GetProperty().SetDiffuse(0.8) ASDMomActors.Spins.VisibilityOff() ######################################################################## # Creation of the data structures for the data clipping ######################################################################## # Right now this only can clip polydata, which is fine for 2D structures # however, for the 3d delaunay tesellation, the output is an unstructured # grid, which means that annother type of clipper is required ASDMomActors.plane = vtk.vtkPlane() ASDMomActors.plane.SetOrigin(ASDMomActors.xmin, ASDMomActors.ymid, 0) ASDMomActors.plane.SetNormal(1, 0, 0) if ASDMomActors.glob_flag_2D: self.clipper = vtk.vtkClipPolyData() self.clipper.SetInputConnection(MagDensMethod.GetOutputPort()) self.clipper.SetClipFunction(ASDMomActors.plane) self.clipper.InsideOutOn() ASDMomActors.clipperMapper = vtk.vtkPolyDataMapper() ASDMomActors.clipperMapper.SetInputConnection( self.clipper.GetOutputPort()) ASDMomActors.clipperMapper.SetLookupTable(self.lut) ASDMomActors.clipperActor = vtk.vtkLODActor() ASDMomActors.clipperActor.SetMapper(ASDMomActors.clipperMapper) ASDMomActors.clipperActor.VisibilityOff() else: self.clipper = vtk.vtkClipVolume() self.clipper.SetInputConnection(MagDensMethod.GetOutputPort()) self.clipper.SetClipFunction(ASDMomActors.plane) self.clipper.InsideOutOn() ASDMomActors.clipperMapper = vtk.vtkDataSetMapper() ASDMomActors.clipperMapper.SetInputConnection( self.clipper.GetOutputPort()) ASDMomActors.clipperMapper.SetLookupTable(self.transfer_func) ASDMomActors.clipperActor = vtk.vtkActor() ASDMomActors.clipperActor.SetMapper(ASDMomActors.clipperMapper) ASDMomActors.clipperActor.GetProperty().SetOpacity(1.00) if (ASD_data.kmc_flag): ######################################################################## # Setting data structures for the KMC particle visualization ######################################################################## ASDMomActors.KMC_src = vtk.vtkPolyData() ASDMomActors.KMC_src.SetPoints(ASD_data.coord_KMC) # Atom sphere KMC_part = vtk.vtkSphereSource() KMC_part.SetRadius(1.75) KMC_part.SetThetaResolution(40) KMC_part.SetPhiResolution(40) # Atom glyph KMC_part_mapper = vtk.vtkGlyph3DMapper() KMC_part_mapper.SetInputData(ASDMomActors.KMC_src) KMC_part_mapper.SetSourceConnection(KMC_part.GetOutputPort()) KMC_part_mapper.SetScaleFactor(0.5) KMC_part_mapper.ClampingOn() KMC_part_mapper.SetScaleModeToNoDataScaling() KMC_part_mapper.SetColorModeToMapScalars() KMC_part_mapper.Update() # Atoms actors ASDMomActors.KMC_part_actor = vtk.vtkLODActor() ASDMomActors.KMC_part_actor.SetMapper(KMC_part_mapper) ASDMomActors.KMC_part_actor.GetProperty().SetOpacity(0.9) ASDMomActors.KMC_part_actor.GetProperty().SetColor(0.0, 0.0, 1.0) ASDMomActors.KMC_part_actor.GetProperty().EdgeVisibilityOn() ASDMomActors.KMC_part_actor.GetProperty().SetEdgeColor(0, 0, 0) ######################################################################## # Setting the information for the axes widget ######################################################################## # Create the axes actor axes = vtk.vtkAxesActor() axes.SetShaftTypeToCylinder() axes.SetCylinderRadius(0.05) axes.SetNormalizedShaftLength(0.9, 0.9, 0.9) axes.SetNormalizedTipLength(0.40, 0.40, 0.40) # The properties of the text can be controlled independently axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetColor( 0.0, 0.0, 0.0) axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetColor( 0.0, 0.0, 0.0) axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetColor( 0.0, 0.0, 0.0) axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff() axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff() axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff() # The axes actor is then used as an orientation marker widget, the advantage # of setting it up as a widget is that it is interactive and one can move it # and that it moves as the zoom changes # Must make sure that the widget is part of the main class so that it can # be actually rendered and no segfaults occurr ASDMomActors.OrientMarker = vtk.vtkOrientationMarkerWidget() ASDMomActors.OrientMarker.SetOutlineColor(0.9300, 0.5700, 0.1300) ASDMomActors.OrientMarker.SetOrientationMarker(axes) ASDMomActors.OrientMarker.SetViewport(0.0, 0.0, 0.3, 0.3) ######################################################################## # Setting the information for the scalar bar widget ######################################################################## # Create the scalar bar actor ASDMomActors.scalar_bar = vtk.vtkScalarBarActor() if ASDMomActors.glob_flag_2D: ASDMomActors.scalar_bar.SetLookupTable( ASDMomActors.MagDensMap.GetLookupTable()) else: ASDMomActors.scalar_bar.SetLookupTable(self.transfer_func) ASDMomActors.scalar_bar.GetLabelTextProperty().SetColor(0.0, 0.0, 0.0) ASDMomActors.scalar_bar.SetNumberOfLabels(5) ASDMomActors.scalar_bar.GetLabelTextProperty().ShadowOff() ASDMomActors.scalar_bar.GetLabelTextProperty().BoldOff() ASDMomActors.scalar_bar.GetLabelTextProperty().ItalicOff() ASDMomActors.scalar_bar.SetLabelFormat("%-#6.1f") ASDMomActors.scalar_bar.SetBarRatio(0.5) # Create the scalar_bar_widget ASDMomActors.scalar_bar_widget = vtk.vtkScalarBarWidget() ASDMomActors.scalar_bar_widget.SetScalarBarActor( ASDMomActors.scalar_bar) # Representation to actually control where the scalar bar is scalarBarRep = ASDMomActors.scalar_bar_widget.GetRepresentation() scalarBarRep.SetOrientation(0) # 0 = Horizontal, 1 = Vertical scalarBarRep.GetPositionCoordinate().SetValue(0.30, 0.05) scalarBarRep.GetPosition2Coordinate().SetValue(0.50, 0.05) ######################################################################## # Setting information of the renderer ######################################################################## # Define the renderer # Add the actors to the scene if ASDMomActors.glob_flag_2D: ren.AddActor(ASDMomActors.MagDensActor) else: ren.AddViewProp(ASDMomActors.MagDensActor) ren.AddActor(ASDMomActors.Spins) ren.AddActor(ASDMomActors.vector) ren.AddActor(ASDMomActors.contActor) ren.AddActor(self.clipperActor) # If there is information about the cluster add the needed actors if ASD_data.cluster_flag: ren.AddActor(ASDMomActors.atom) ren.AddActor(ASDMomActors.atom_imp) #If the KMC particles are present add them to the renderer if ASD_data.kmc_flag: ren.AddActor(ASDMomActors.KMC_part_actor) # Defining the camera directions ren.GetActiveCamera().Azimuth(ASDMomActors.camera_azimuth) ren.GetActiveCamera().Elevation(ASDMomActors.camera_elevation) ren.GetActiveCamera().Yaw(ASDMomActors.camera_yaw) ren.GetActiveCamera().Roll(ASDMomActors.camera_roll) ren.GetActiveCamera().Pitch(ASDMomActors.camera_pitch) ren.GetActiveCamera().SetFocalPoint(self.camera_focal) ren.GetActiveCamera().SetPosition(self.camera_pos) ren.GetActiveCamera().SetViewUp(0, 1, 0) # Must make sure the widgets is called before the renderer is called # Scalar bar ASDMomActors.scalar_bar_widget.SetInteractor(iren) ASDMomActors.scalar_bar_widget.On() # Orient marker ASDMomActors.OrientMarker.SetInteractor(iren) ASDMomActors.OrientMarker.SetEnabled(1) ######################################################################## # Start the renderer ######################################################################## iren.Start() renWin.Render() return
def load_vtk_XML_file(self,file,field): """ Loads the vtk mesh and displays the scalar data in a color map. Allows further postprocessing to be done, such as grayscale and contour plots. """ if hasattr(self, "mesh_actor"): self.ren.RemoveActor(self.mesh_actor) self.ren.RemoveActor(self.sbActor) if file is None: file,_ = get_file("*.vtu") self.ui.statLabel.setText("Reading %s for mesh . . ."%file) mesh_source = vtk.vtkXMLUnstructuredGridReader() mesh_source.SetFileName(file) # read scalar to vtk mesh_source.Update() self.mesh_reader_output = mesh_source.GetOutput() self.mesh_reader_output.GetPointData().SetActiveScalars(field) # bounds for axis bounds = self.mesh_reader_output.GetBounds() # show element edges edges = vtk.vtkExtractEdges() edges.SetInputConnection(mesh_source.GetOutputPort()) edges.Update() # lookup table and scalar range for a vtk file self.mesh_lookup_table = vtk.vtkLookupTable() # make scalar red = max; blue = min self.ui.statLabel.setText("Building lookup table . . .") self.mesh_lookup_table.SetHueRange(0.667, 0) self.mesh_lookup_table.Build() scalar_range = self.mesh_reader_output.GetScalarRange() # mesh data set self.mesh_mapper = vtk.vtkDataSetMapper() self.mesh_mapper.SetInputData(self.mesh_reader_output) self.mesh_mapper.SetScalarRange(scalar_range) self.mesh_mapper.SetLookupTable(self.mesh_lookup_table) #define mesh actor self.mesh_actor = vtk.vtkActor() # #the scalar bar widget is associated with the qt interactor box scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(self.iren) scalar_bar_widget.SetEnabled(True) scalar_bar_widget.RepositionableOn() scalar_bar_widget.On() # define scalar bar actor self.sbActor=scalar_bar_widget.GetScalarBarActor() # self.sbActor.SetOrientationToVertical() self.sbActor.SetLookupTable(self.mesh_lookup_table) self.sbActor.SetTitle(field) #adjust scale bar position scalarBarRep = scalar_bar_widget.GetRepresentation() scalarBarRep.GetPositionCoordinate().SetValue(0.01,0.01) scalarBarRep.GetPosition2Coordinate().SetValue(0.09,0.9) #attempt to change scalebar properties [ineffective] propT = vtk.vtkTextProperty() propL = vtk.vtkTextProperty() propT.SetFontFamilyToArial() # propT.ItalicOff() propT.BoldOn() propL.BoldOff() propL.SetFontSize(1) propT.SetFontSize(2) self.sbActor.SetTitleTextProperty(propT); self.sbActor.SetLabelTextProperty(propL); self.sbActor.GetLabelTextProperty().SetFontSize(7) self.sbActor.GetTitleTextProperty().SetFontSize(7) self.sbActor.SetLabelFormat("%.1f") #define the mesh actor properties self.mesh_actor.SetMapper(self.mesh_mapper) self.mesh_actor.GetProperty().SetLineWidth(1) self.mesh_actor.GetProperty().EdgeVisibilityOn() #display the actors self.ren.AddActor(self.mesh_actor) self.ren.AddActor(self.sbActor) #get boundary of mesh self.limits = self.mesh_reader_output.GetBounds() self.ui.vtkWidget.setFocus() self.AddAxis(self.limits,1) xyview_post(self.ren, self.ren.GetActiveCamera(),self.cp,self.fp) #sorts out the camera issue self.ui.vtkWidget.update() self.ui.statLabel.setText("Loaded results. Idle.") self.ui.inp_min_stress.setText("%4.1f"%self.mesh_mapper.GetScalarRange()[0]) self.ui.inp_max_stress.setText("%4.1f"%self.mesh_mapper.GetScalarRange()[1]) #set extract button green self.ui.extract_button.setStyleSheet("background-color :rgb(77, 209, 97);") QtWidgets.QApplication.processEvents()
def __init__(self,dti): self.print_counter=11 ren = vtk.vtkRenderer() self.dti_reader = vtk.vtkStructuredPointsReader() self.dti_reader.SetFileName(dti) self.geo_Mapper=vtk.vtkPolyDataMapper() self.geo_Mapper.SetInputConnection(self.dti_reader.GetOutputPort()) #glyph actor #geo_actor = vtk.vtkActor() #geo_actor.SetMapper(geo_Mapper) #ren.AddActor(geo_actor) self.arrowColor = vtk.vtkColorTransferFunction() self.update_look_up_table() self.plane1=None for i in range(0,3): if i==0: x=126.0 y=0.0 z=0.0 if i==1: x=126.0 y=126.0 z=0.0 if i==2: x=0.0 y=0.0 z=69.0 plane_mapper=self.create_cut_acto_plane(x,y,z,i) ren.AddActor(self.create_glyph(plane_mapper)) #this is done #Add renderer to renderwindow and render self.renWin = vtk.vtkRenderWindow() self.renWin.AddRenderer(ren) self.renWin.SetSize(1920, 1080) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(self.renWin) iren.AddObserver('RightButtonPressEvent', self.capture_image, 1.0) """ #Slider 1 sliderRep1=vtk.vtkSliderWidget() sliderRep1.SetInteractor(iren) sliderRep1.SetRepresentation(self.create_color_slider("X-Position",0.02,0.15,0,220,65)) sliderRep1.SetEnabled(True) sliderRep1.AddObserver("InteractionEvent", self.change_iso) """ # Scalar Bar actor scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(self.arrowColor) scalar_bar.SetTitle("Color map") scalar_bar.SetLabelFormat("%5.2f") scalar_bar.SetMaximumHeightInPixels(300) scalar_bar.SetMaximumWidthInPixels(100) # Scalar Bar Widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(iren) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() ren.SetBackground(0,0,0) self.renWin.Render() iren.Start()
def createImage(file_name, rendered_image, angleX, angleY, angleZ, scaleX, scaleY, scaleZ, vtkType, arrayName): colors = vtk.vtkNamedColors() # Read in data if vtkType == "vtStructuredGrid": reader = vtk.vtkXMLPStructuredGridReader() else: reader = vtk.vtkXMLPUnstructuredGridReader() reader.SetFileName(file_name) reader.Update() output = reader.GetOutput() scalar_range = output.GetScalarRange() # Get the number or arrays for each number_of_point_arrays = output.GetPointData().GetNumberOfArrays() number_of_cell_arrays = output.GetCellData().GetNumberOfArrays() number_of_field_arrays = output.GetFieldData().GetNumberOfArrays() number_of_total_arrays = number_of_point_arrays + number_of_cell_arrays + number_of_field_arrays print("number_of_field_arrays ", number_of_field_arrays) print("number_of_cell_arrays ", number_of_cell_arrays) print("number_of_point_arrays ", number_of_point_arrays) # Find the field we are rendering data_array_name = [] for i in range(number_of_point_arrays): data_array_name.append(output.GetPointData().GetArrayName(i)) for i in range(number_of_cell_arrays): data_array_name.append(output.GetCellData().GetArrayName(i)) for i in range(number_of_field_arrays): data_array_name.append(output.GetFieldData().GetArrayName(i)) array_index = 0 for i in range(number_of_total_arrays): if arrayName == data_array_name[i]: array_index = i tableSize = 0 if array_index < number_of_point_arrays: tableSize = output.GetPointData().GetArray( data_array_name[array_index]).GetNumberOfTuples() scalar_range = output.GetPointData().GetArray( data_array_name[array_index]).GetRange() colorData = output.GetPointData().GetArray( data_array_name[array_index]) output.GetPointData().SetScalars(colorData) elif array_index < number_of_cell_arrays: tableSize = output.GetCellData().GetArray( data_array_name[array_index]).GetNumberOfTuples() scalar_range = output.GetCellData().GetArray( data_array_name[array_index]).GetRange() colorData = output.GetCellData().GetArray(data_array_name[array_index]) output.GetCellData().SetScalars(colorData) else: tableSize = output.GetFieldData().GetArray( data_array_name[array_index]).GetNumberOfTuples() scalar_range = output.GetFieldData().GetArray( data_array_name[array_index]).GetRange() colorData = output.GetFieldData().GetArray( data_array_name[array_index]) output.GetFieldData().SelectColorArray(data_array_name[array_index]) lut1 = MakeLUTFromCTF(tableSize) # Create the mapper that corresponds the objects of the vtk.vtk file # into graphics elements mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(reader.GetOutputPort()) mapper.SetScalarRange(scalar_range) if array_index < number_of_point_arrays: mapper.SetScalarModeToUsePointData() elif array_index < number_of_cell_arrays: mapper.SetScalarModeToUseCellData() else: mapper.SetScalarModeToUseFieldData() mapper.SetLookupTable(lut1) mapper.Update() # Create the Actor actor = vtk.vtkActor() actor.SetMapper(mapper) actor.RotateX(angleX) actor.RotateY(angleY) actor.RotateZ(angleZ) actor.SetScale(scaleX, scaleY, scaleZ) actor.GetProperty().EdgeVisibilityOn() actor.GetProperty().SetLineWidth(2.0) backface = vtk.vtkProperty() backface.SetColor(colors.GetColor3d("tomato")) actor.SetBackfaceProperty(backface) # Create the Renderer renderer = vtk.vtkRenderer() renderer.AddActor(actor) renderer.SetBackground(1, 1, 1) # Set background to white # Create the RendererWindow renderer_window = vtk.vtkRenderWindow() renderer_window.AddRenderer(renderer) renderer_window.SetOffScreenRendering(1) renderer_window.SetSize(750, 750) # create array_index renderwindowinteractor interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderer_window) # create the scalar_bar scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetLookupTable(lut1) # create the scalar_bar_widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(interactor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() #interactor.Initialize() renderer_window.Render() # screenshot code: w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(renderer_window) w2if.Update() writer = vtk.vtkPNGWriter() writer.SetFileName(rendered_image) writer.SetInputConnection(w2if.GetOutputPort()) writer.Write() # Return the rendered image encoded_image = base64.b64encode(open(rendered_image, 'rb').read()) return encoded_image
view.GetRenderer().AddActor(edgeActor) view.GetRenderer().AddActor(graphActor) view.GetRenderer().AddActor(vertexActor) view.GetRenderer().AddActor(labelActor) view.GetRenderer().AddActor(msEdgeActor) view.GetRenderer().AddActor(msVertActor) # ---------- # General interactor isty = vtk.vtkInteractorStyleRubberBand2D() # RubberBand2D assumes/needs parallel projection ON view.GetRenderer().GetActiveCamera().ParallelProjectionOn() iren = view.GetRenderWindow().GetInteractor() iren.SetInteractorStyle(isty) vertexScalarBar = vtk.vtkScalarBarWidget() vertexScalarBar.SetInteractor(iren) vertexScalarBar.SetDefaultRenderer(view.GetRenderer()) vertexScalarBar.SetCurrentRenderer(view.GetRenderer()) vertexScalarBar.SetEnabled(True) sbActor = vertexScalarBar.GetScalarBarActor() sbActor.SetLookupTable(vertMapper.GetLookupTable()) sbActor.SetTitle(vertMapper.GetArrayName()) sbActor.SetNumberOfLabels(3) scalarBarRep = vertexScalarBar.GetRepresentation() scalarBarRep.SetOrientation(1) # 0 = Horizontal, 1 = Vertical scalarBarRep.GetPositionCoordinate().SetValue(0.05,0.05) scalarBarRep.GetPosition2Coordinate().SetValue(0.15,0.25) view.ResetCamera() view.Render()
def loadGraph(): # ---------- # Load and construct whole graph and multi-resolution data from Matlab structure dataDir = '/Users/emonson/Programming/Matlab/EMonson/Fodava/DocumentAnalysis/Analysis/' filename = dataDir + 'X20_042709b.mat' # filename = '/Users/emonson/Programming/Python/VTK/X20_040609b.mat' X = scipy.io.loadmat(filename) # Get graph structure G out of matlab variables G = X['G'] # ---------- # Set multi-resolution level bounds in GUI sliders levelMax = G.Tree.shape[0]-1 ui_window.hSlider_level.setMinimum(1) ui_window.hSlider_level.setMaximum(levelMax) ui_window.spinBox_level.setMinimum(1) ui_window.spinBox_level.setMaximum(levelMax) # Start setting up basis function for display as subgraph ExtBasis = GTree[level,0]['ExtBasis'][0][0][0] basisMax = ExtBasis.shape[1]-1 # zero-based indices # Set particular level basis function bounds in GUI sliders ui_window.hSlider_basisIndex.setMinimum(0) ui_window.hSlider_basisIndex.setMaximum(basisMax) ui_window.spinBox_basisIndex.setMinimum(0) ui_window.spinBox_basisIndex.setMaximum(basisMax) # Build table which will become graph table = vtk.vtkTable() col0 = vtk.vtkIntArray() col0.SetName('index1') col1 = vtk.vtkIntArray() col1.SetName('index2') val = vtk.vtkDoubleArray() val.SetName('weight') Tmat = G.T # Tmat = G.W for ii in range(Tmat.nzmax): col0.InsertNextValue(Tmat.rowcol(ii)[0]) col1.InsertNextValue(Tmat.rowcol(ii)[1]) val.InsertNextValue(abs(Tmat.getdata(ii))) table.AddColumn(col0) table.AddColumn(col1) table.AddColumn(val) # Vertex links need to be done with index2 first or indexing won't be right... # TODO: Make this foolproof so that graph always ends up with correct ordering of indices... tgraph = vtk.vtkTableToGraph() tgraph.SetInput(table) tgraph.AddLinkVertex('index2', 'stuff', False) tgraph.AddLinkVertex('index1', 'stuff', False) tgraph.AddLinkEdge('index2', 'index1') rawGraph = tgraph.GetOutput() rawGraph.Update() # print graph # Load and assign whole graph pre-layout coordinates ptsFile = os.path.splitext(filename)[0] + '_pts.vtp' if os.path.exists(ptsFile): polyreader = vtk.vtkXMLPolyDataReader() polyreader.SetFileName(ptsFile) polyreader.Update() pts = polyreader.GetOutput().GetPoints() rawGraph.SetPoints(pts) # print pts strategy = vtk.vtkPassThroughLayoutStrategy() layout = vtk.vtkGraphLayout() layout.SetInput(rawGraph) layout.SetLayoutStrategy(strategy) edgeLayout = vtk.vtkEdgeLayout() edgeStrategy = vtk.vtkArcParallelEdgeStrategy() edgeStrategy.SetNumberOfSubdivisions(50) edgeLayout.SetInputConnection(layout.GetOutputPort()) edgeLayout.SetLayoutStrategy(edgeStrategy) graph = edgeLayout.GetOutput() graph.Update() # -------- # Add ExtBasis to graph data & Select particular basis function # print 'ExtBasis shape: ' + str(ExtBasis[:,basisNum].data.shape) + ' (level,basis) (' + str(level) + ',' + str(basisNum) + ')' # Indexing of ExtBasis is backwards from graph, so need to reverse with [::-1] # and array not "contiguous" if don't do .copy() Esub = ExtBasis[:,basisNum].data[::-1].copy() EsubSq = Esub**2 # Esub = N.random.random(ExtBasis[:,basisNum].data.shape[0]) # SubIdxs = (Esub > 0.001).nonzero() # SubIdxs = (Esub**2 > 0.8).nonzero() # Set ExtBasis vertex data from numpy array basisFunc = VN.numpy_to_vtk(Esub) basisFunc.SetName('ExtBasis') basisFuncSq = VN.numpy_to_vtk(EsubSq) basisFuncSq.SetName('ExtBasisSq') vertexData = graph.GetVertexData() vertexData.AddArray(basisFunc) vertexData.AddArray(basisFuncSq) selection = vtk.vtkSelectionSource() selection.SetContentType(7) # vtkSelection::THRESHOLDS # selection.SetContentType(2) # vtkSelection::PEDIGREE_IDS selection.SetFieldType(3) # vtkSelection::VERTEX selection.SetArrayName("ExtBasisSq") selection.AddThreshold(basisCutoff, 10) # TODO: There was something wrong with the indexing in the PEDIGREE_IDS selection... # for ii in SubIdxs[0]: # selection.AddID(0,ii) minmax = "(%3.2e, %3.2e)" % (EsubSq.min(), EsubSq.max()) ui_window.label_basisCutoff_minmax.setText(minmax) selection.Update() # ---------- # Back to pipeline degree = vtk.vtkVertexDegree() degree.SetInput(graph) subgraph = vtk.vtkExtractSelectedGraph() subgraph.SetRemoveIsolatedVertices(False) subgraph.SetInputConnection(degree.GetOutputPort()) subgraph.SetSelectionConnection(selection.GetOutputPort()) # +++++++++++++ graphToPoly = vtk.vtkGraphToPolyData() graphToPoly.SetInputConnection(subgraph.GetOutputPort()) edgeMapper = vtk.vtkPolyDataMapper() edgeMapper.SetInputConnection(graphToPoly.GetOutputPort()) edgeMapper.SetScalarModeToUseCellData() edgeMapper.SetScalarVisibility(False) edgeMapper.SetImmediateModeRendering(True) edgeActor = vtk.vtkActor() edgeActor.SetMapper(edgeMapper) edgeActor.SetPosition(0, 0, -0.003); lut = vtk.vtkLookupTable() lutNum = 256 lut.SetNumberOfTableValues(lutNum) ctf = vtk.vtkColorTransferFunction() ctf.SetColorSpaceToDiverging() ctf.AddRGBPoint(0.0, 0, 0, 1.0) ctf.AddRGBPoint(1.0, 1.0, 0, 0) for ii,ss in enumerate([float(xx)/float(lutNum) for xx in range(lutNum)]): cc = ctf.GetColor(ss) lut.SetTableValue(ii,cc[0],cc[1],cc[2],1.0) vertGlyph = vtk.vtkVertexGlyphFilter() vertGlyph.SetInputConnection(subgraph.GetOutputPort()) vertMapper = vtk.vtkPolyDataMapper() vertMapper.SetInputConnection(vertGlyph.GetOutputPort()) vertMapper.SetImmediateModeRendering(True) vertMapper.SetScalarModeToUsePointFieldData() vertMapper.SetLookupTable(lut) vertMapper.SelectColorArray('ExtBasis') vertMapper.Update() vertRange = vertMapper.GetInput().GetPointData().GetArray(vertMapper.GetArrayName()).GetRange() vertMapper.SetScalarRange(-1.0*vertRange[1], vertRange[1]) vertActor = vtk.vtkActor() vertActor.SetMapper(vertMapper) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetScalarVisibility(False) outlineMapper.SetImmediateModeRendering(True) outlineMapper.SetInputConnection(vertGlyph.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.PickableOff() outlineActor.SetPosition(0, 0, -0.001) outlineActor.GetProperty().SetRepresentationToWireframe() outlineActor.SetMapper(outlineMapper) # Create an Actor Collection for applying visibility to group basisActorCollection = vtk.vtkActorCollection() basisActorCollection.AddItem(vertActor) # basisActorCollection.AddItem(edgeActor) basisActorCollection.AddItem(outlineActor) # Apply a theme to the views theme = vtk.vtkViewTheme.CreateMellowTheme() theme.SetLineWidth(3) theme.SetPointSize(5) theme.SetSelectedCellColor(1,1,1) theme.SetSelectedPointColor(1,1,1) theme.SetOutlineColor(0.8, 0.8, 0.8) # theme.SetPointColor(0.9, 0.7, 0.3) theme.SetCellColor(0.9, 0.7, 0.3) # theme.SetPointOpacity(0.5) # theme.SetPointHueRange(0.0, 0.15) # theme.SetPointSaturationRange(0.6, 0.8) # theme.SetPointValueRange(0.4,0.8) # theme.SetPointAlphaRange(0.2,0.8) # theme.SetPointAlphaRange(1.0,1.0) # Apply theme # vertActor.GetProperty().SetColor(theme.GetPointColor()) # vertActor.GetProperty().SetOpacity(theme.GetPointOpacity()) vertActor.GetProperty().SetPointSize(theme.GetPointSize()) outlineActor.GetProperty().SetPointSize(vertActor.GetProperty().GetPointSize()+2) outlineActor.GetProperty().SetColor(theme.GetOutlineColor()) outlineActor.GetProperty().SetOpacity(theme.GetPointOpacity()) edgeActor.GetProperty().SetColor(theme.GetCellColor()) edgeActor.GetProperty().SetOpacity(theme.GetCellOpacity()) edgeActor.GetProperty().SetLineWidth(theme.GetLineWidth()) # ---------- # Background graph skeleton graphMapper = vtk.vtkGraphMapper() graphMapper.SetInputConnection(0, degree.GetOutputPort(0)) # Apply a theme to the background graph gtheme = vtk.vtkViewTheme() gtheme.SetLineWidth(1) gtheme.SetPointSize(0) gtheme.SetCellColor(0.8, 0.8, 0.8) gtheme.SetCellOpacity(0.2) gtheme.SetOutlineColor(0.8, 0.8, 0.8) gtheme.SetPointColor(0.8, 0.8, 0.8) gtheme.SetPointOpacity(0.0) graphMapper.ApplyViewTheme(gtheme) graphActor = vtk.vtkActor() graphActor.SetMapper(graphMapper) graphActor.SetPosition(0,0,-0.005) # ---------- # Background vertices graphPoly = vtk.vtkGraphToPolyData() graphPoly.SetInputConnection(0, tgraph.GetOutputPort(0)) vertGlyph = vtk.vtkGlyph3D() vertGlyph.SetInputConnection(0, graphPoly.GetOutputPort()) glyphSource = vtk.vtkGlyphSource2D() glyphSource.SetGlyphTypeToVertex() # glyphSource.SetGlyphTypeToCircle() # glyphSource.SetScale(0.025) vertGlyph.SetInputConnection(1, glyphSource.GetOutputPort()) vertexMapper = vtk.vtkPolyDataMapper() vertexMapper.SetInputConnection(vertGlyph.GetOutputPort()) vertexActor = vtk.vtkActor() vertexActor.SetMapper(vertexMapper) vertexActor.GetProperty().SetPointSize(4) vertexActor.GetProperty().SetOpacity(0.5) vertexActor.GetProperty().SetColor(0.6, 0.6, 0.6) vertexActor.SetPosition(0, 0, -0.004) # ---------- # Vertex index labels labelMapper = vtk.vtkDynamic2DLabelMapper() labelMapper.SetInputConnection(0, graphPoly.GetOutputPort(0)) labelMapper.SetLabelModeToLabelFieldData() labelMapper.SetFieldDataName("label") labelMapper.SetLabelFormat("%s") labelMapper.GetLabelTextProperty().SetColor(0.0, 0.0, 0.0) labelActor = vtk.vtkActor2D() labelActor.SetMapper(labelMapper) # ---------- # MultiScale Graph msGraph = buildSubGraph(level) msMapper = vtk.vtkGraphMapper() msMapper.SetInput(msGraph) msMapper.SetColorEdges(True) msMapper.SetEdgeColorArrayName('weight') # Apply a theme to the background graph mtheme = vtk.vtkViewTheme() mtheme.SetLineWidth(3) mtheme.SetPointSize(11) # mtheme.SetCellColor(0.5, 0.5, 0.7) # mtheme.SetCellOpacity(0.5) mtheme.SetOutlineColor(0.8, 0.8, 0.8) mtheme.SetPointColor(0.3, 0.3, 0.6) mtheme.SetPointOpacity(1.0) mtheme.SetCellHueRange(0.67, 0.67) mtheme.SetCellSaturationRange(0.6, 0.1) mtheme.SetCellValueRange(0.5,1.0) mtheme.SetCellAlphaRange(0.2,0.8) msMapper.ApplyViewTheme(mtheme) msActor = vtk.vtkActor() msActor.SetMapper(msMapper) msActor.SetPosition(0,0,-0.002) # ---------- # Set up window and add actors view.SetLayoutStrategyToPassThrough() # view.ApplyViewTheme(theme) # view.SetupRenderWindow(win) view.GetRenderer().SetBackground(theme.GetBackgroundColor()) view.GetRenderer().SetBackground2(theme.GetBackgroundColor2()) view.GetRenderer().SetGradientBackground(True) view.GetRenderer().AddActor(vertActor) view.GetRenderer().AddActor(outlineActor) view.GetRenderer().AddActor(edgeActor) view.GetRenderer().AddActor(graphActor) view.GetRenderer().AddActor(vertexActor) view.GetRenderer().AddActor(labelActor) view.GetRenderer().AddActor(msActor) # ---------- # General interactor isty = vtk.vtkInteractorStyleRubberBand2D() # RubberBand2D assumes/needs parallel projection ON view.GetRenderer().GetActiveCamera().ParallelProjectionOn() iren = view.GetRenderWindow().GetInteractor() iren.SetInteractorStyle(isty) # Interactor style must be set before scalar bar can be shown # view.SetVertexScalarBarVisibility(True) sbActor = vtk.vtkScalarBarActor() sbActor.SetLookupTable(vertMapper.GetLookupTable()) sbActor.SetTitle(vertMapper.GetArrayName()) sbActor.SetNumberOfLabels(3) vertexScalarBar = vtk.vtkScalarBarWidget() vertexScalarBar.SetScalarBarActor(sbActor) vertexScalarBar.SetInteractor(iren) vertexScalarBar.SetDefaultRenderer(view.GetRenderer()) vertexScalarBar.SetCurrentRenderer(view.GetRenderer()) vertexScalarBar.SetEnabled(True) scalarBarRep = vertexScalarBar.GetRepresentation() scalarBarRep.SetOrientation(1) # 0 = Horizontal, 1 = Vertical scalarBarRep.GetPositionCoordinate().SetValue(0.05,0.05) scalarBarRep.GetPosition2Coordinate().SetValue(0.15,0.25) # Adding it this way gets it to show up, but it's not interactive view.GetRenderer().AddActor(sbActor) view.ResetCamera() view.Render() # ---------- # Add Actors to QListWidget to allow check and uncheck for visibility listItem0 = QtGui.QListWidgetItem() listItem0.setText('Index Labels') listItem0.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable) labelActor.SetVisibility(0) listItem0.setCheckState(QtCore.Qt.Unchecked) # Put actor it in as data in the list widget item listItem0.setData(QtCore.Qt.UserRole, QtCore.QVariant(labelActor)) ui_window.listWidget.insertItem(0,listItem0) # Test retrieval of actor from list widget item # tmpItem = ui_window.listWidget.item(0) # tmpQtActor = tmpItem.data(QtCore.Qt.UserRole) # tmpActor = tmpQtActor.toPyObject() # tmpActor.SetVisibility(0) # Shorter way to add item to list widget listItem1 = QtGui.QListWidgetItem('Vertices (background)', ui_window.listWidget) listItem1.setData(QtCore.Qt.UserRole, QtCore.QVariant(vertexActor)) listItem1.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable) listItem1.setCheckState(QtCore.Qt.Checked) listItem2 = QtGui.QListWidgetItem('Graph (background)', ui_window.listWidget) listItem2.setData(QtCore.Qt.UserRole, QtCore.QVariant(graphActor)) listItem2.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable) listItem2.setCheckState(QtCore.Qt.Checked) listItem3 = QtGui.QListWidgetItem() listItem3.setText('Basis Function Vertices') listItem3.setData(QtCore.Qt.UserRole, QtCore.QVariant(basisActorCollection)) listItem3.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable) listItem3.setCheckState(QtCore.Qt.Checked) ui_window.listWidget.insertItem(1,listItem3) listItem6 = QtGui.QListWidgetItem() listItem6.setText('Basis Function Edges') listItem6.setData(QtCore.Qt.UserRole, QtCore.QVariant(edgeActor)) listItem6.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable) listItem6.setCheckState(QtCore.Qt.Checked) ui_window.listWidget.insertItem(2,listItem6) listItem4 = QtGui.QListWidgetItem() listItem4.setText('MultiScale Graph') listItem4.setData(QtCore.Qt.UserRole, QtCore.QVariant(msActor)) listItem4.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable) listItem4.setCheckState(QtCore.Qt.Checked) ui_window.listWidget.insertItem(3,listItem4) listItem5 = QtGui.QListWidgetItem() listItem5.setText('Basis Function Scale Bar') listItem5.setData(QtCore.Qt.UserRole, QtCore.QVariant(sbActor)) listItem5.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable) listItem5.setCheckState(QtCore.Qt.Checked) ui_window.listWidget.insertItem(3,listItem5) iren.Initialize() iren.Start()
def vtk_figure(output_filename, geometry, scalar=None, contours=None, width=400, height=230, scalar_colorbar=True): import vtk import math # bounding box bounds = geometry.GetBounds() cx = (bounds[0] + bounds[1]) / 2.0 cy = (bounds[2] + bounds[3]) / 2.0 scale = max(math.fabs(bounds[0] - cx), math.fabs(bounds[1] - cx), math.fabs(bounds[2] - cy), math.fabs(bounds[3] - cy)) # renderer renderer = vtk.vtkRenderer() renderer.SetBackground(1, 1, 1) # scalar if (scalar != None): renderer.AddActor(scalar) # contours if (contours != None): renderer.AddActor(contours) # geometry renderer.AddActor(geometry) # camera camera = renderer.GetActiveCamera() camera.ParallelProjectionOn() camera.SetParallelScale(scale) camera.SetPosition(cx, cy, 1) camera.SetFocalPoint(cx, cy, 0) # render window render_window = vtk.vtkRenderWindow() render_window.SetOffScreenRendering(1) render_window.SetSize(width, height) render_window.AddRenderer(renderer) render_window.Render() # scalar colorbar if (scalar != None): if (scalar_colorbar): interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(render_window) scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetNumberOfLabels(8) scalar_bar.SetLabelFormat("%+#6.2e") scalar_bar.SetLookupTable(scalar.GetMapper().GetLookupTable()) scalar_bar.GetLabelTextProperty().SetFontFamilyToCourier() scalar_bar.GetLabelTextProperty().SetJustificationToRight() scalar_bar.GetLabelTextProperty( ).SetVerticalJustificationToCentered() scalar_bar.GetLabelTextProperty().BoldOff() scalar_bar.GetLabelTextProperty().ItalicOff() scalar_bar.GetLabelTextProperty().ShadowOff() scalar_bar.GetLabelTextProperty().SetColor(0, 0, 0) # create the scalar bar widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(interactor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() window_to_image_filter = vtk.vtkWindowToImageFilter() window_to_image_filter.SetInput(render_window) window_to_image_filter.Update() writer = vtk.vtkPNGWriter() writer.SetFileName(output_filename) writer.SetInputConnection(window_to_image_filter.GetOutputPort()) writer.Write()
def _createIPW(self): # we have to do this to get the correct log range self._histogram.GetOutput().Update() # this means we have newly valid input and should setup an ipw self._ipw = vtk.vtkImagePlaneWidget() self._histogram.GetOutput().Update() self._ipw.SetInput(self._histogram.GetOutput()) self._ipw.SetInteractor(self._viewFrame.rwi) # normal to the Z-axis self._ipw.SetPlaneOrientation(2) self._ipw.SetSliceIndex(0) # setup specific lut srange = self._histogram.GetOutput().GetScalarRange() lut = vtk.vtkLookupTable() lut.SetScaleToLog10() lut.SetTableRange(srange) lut.SetSaturationRange(1.0,1.0) lut.SetValueRange(1.0, 1.0) lut.SetHueRange(0.1, 1.0) lut.Build() self._ipw.SetUserControlledLookupTable(1) self._ipw.SetLookupTable(lut) self._ipw.SetDisplayText(1) # if we use ContinousCursor, we get OffImage when zoomed # on Linux (really irritating) but not on Windows. A VTK # recompile might help, we'll see. self._ipw.SetUseContinuousCursor(1) # make sure the user can't twist the plane out of sight self._ipw.SetMiddleButtonAction(0) self._ipw.SetRightButtonAction(0) # add an observer self._ipw.AddObserver('StartInteractionEvent', self._observerIPWInteraction) self._ipw.AddObserver('InteractionEvent', self._observerIPWInteraction) self._ipw.AddObserver('EndInteractionEvent', self._observerIPWInteraction) self._ipw.On() self._axes = vtk.vtkCubeAxesActor2D() self._axes.SetFlyModeToOuterEdges() # NOBODY will ever know why we have to switch off the Y axis when # we actually want the Z-axis to go away. self._axes.YAxisVisibilityOff() self._axes.SetBounds(self._ipw.GetResliceOutput().GetBounds()) self._renderer.AddActor(self._axes) self._axes.SetCamera(self._renderer.GetActiveCamera()) self._axes.PickableOff() if 0: # now add a scalarbar self._scalarBarWidget = vtk.vtkScalarBarWidget() self._scalarBarWidget.SetInteractor(self._viewFrame.rwi) self._scalarBarWidget.GetScalarBarActor().SetTitle('Frequency') self._scalarBarWidget.GetScalarBarActor().SetLookupTable( lut) # and activate self._scalarBarWidget.On() self._resetCamera() self._render()
def main(): # Initialize argument and constant variables parser = ArgumentParser("Create isosurfacing of object") parser.add_argument("density") parser.add_argument("climate") parser.add_argument("sat") parser.add_argument("--camera", type=str, help="Optional camera settings file") args = parser.parse_args() # Create reader for ct scan density_reader = vtk.vtkTIFFReader() density_reader.SetFileName(args.density) density_reader.Update() print(density_reader.GetOutput().GetScalarRange()[1]) density_log = vtk.vtkImageLogarithmicScale() density_log.SetInputConnection(density_reader.GetOutputPort()) density_log.SetConstant(0.435) density_log.Update() density_range = density_log.GetOutput().GetScalarRange() climate_reader = vtk.vtkTIFFReader() climate_reader.SetFileName(args.climate + "-" + str(initial_date.month.real).zfill(2) + ".tif") climate_reader.Update() climate_range = climate_reader.GetOutput().GetScalarRange() sat_reader = vtk.vtkJPEGReader() sat_reader.SetFileName(args.sat) max_val = 100 color_count = 1000 density_ctf = vtk.vtkColorTransferFunction() density_ctf.AddRGBPoint(0, 0, 0, 0) density_ctf.AddRGBPoint(10, 0, 0, 1) density_ctf.AddRGBPoint(30, 0, 1, 1) density_ctf.AddRGBPoint(50, 1, 1, 0) density_ctf.AddRGBPoint(65, 1, 0.5, 0) density_ctf.AddRGBPoint(80, 1, 0, 0) density_lut = vtk.vtkLookupTable() density_lut.SetNumberOfTableValues(color_count) density_lut.Build() rgb = list(density_ctf.GetColor(0)) + [0] density_lut.SetTableValue(0, rgb) for i in range(1, color_count): rgb = list(density_ctf.GetColor( max_val * float(i) / color_count)) + [1] density_lut.SetTableValue(i, rgb) climate_ctf = vtk.vtkColorTransferFunction() climate_ctf.AddRGBPoint(5, 0, 0, 1) climate_ctf.AddRGBPoint(35, 0, 1, 1) climate_ctf.AddRGBPoint(65, 1, 1, 0) climate_ctf.AddRGBPoint(95, 1, 0, 0) climate_lut = vtk.vtkLookupTable() climate_lut.SetNumberOfTableValues(color_count) climate_lut.Build() for i in range(0, color_count): rgb = list(climate_ctf.GetColor( max_val * float(i) / color_count)) + [1] climate_lut.SetTableValue(i, rgb) density_mapper = vtk.vtkDataSetMapper() density_mapper.SetInputConnection(density_log.GetOutputPort()) density_mapper.SetLookupTable(density_lut) density_mapper.SetScalarRange([0, density_range[1]]) density_mapper.Update() climate_mapper = vtk.vtkDataSetMapper() climate_mapper.SetInputConnection(climate_reader.GetOutputPort()) climate_mapper.SetLookupTable(climate_lut) climate_mapper.SetScalarRange(climate_range) climate_mapper.Update() sat_mapper = vtk.vtkDataSetMapper() sat_mapper.SetInputConnection(sat_reader.GetOutputPort()) density_actor = vtk.vtkActor() density_actor.SetMapper(density_mapper) density_actor.GetProperty().SetOpacity(0.99) density_actor.VisibilityOn() climate_actor = vtk.vtkActor() climate_actor.SetMapper(climate_mapper) climate_actor.GetProperty().SetOpacity(0.6) climate_actor.VisibilityOff() sat_actor = vtk.vtkActor() sat_actor.SetMapper(sat_mapper) sat_actor.GetProperty().SetOpacity(0.7) # Make satellite image same size as contour map crange = sat_actor.GetXRange()[0] - sat_actor.GetXRange()[1] mrange = density_actor.GetXRange()[0] - density_actor.GetXRange()[1] density_actor.SetScale(crange / mrange) crange = sat_actor.GetXRange()[0] - sat_actor.GetXRange()[1] mrange = climate_actor.GetXRange()[0] - climate_actor.GetXRange()[1] climate_actor.SetScale(crange / mrange) # Initialize renderer and place actors ren = vtk.vtkRenderer() ren.AddActor(density_actor) ren.AddActor(climate_actor) ren.AddActor(sat_actor) ren.ResetCamera() ren.SetBackground(0, 0, 0) # Initialize camera settings cam1 = ren.GetActiveCamera() cam1.Azimuth(0) cam1.Elevation(0) cam1.Roll(360) cam1.Zoom(1) ren.ResetCameraClippingRange() if args.camera: reader = open(args.camera, "r") line = reader.readline().split(",") cam1.SetPosition(float(line[0]), float(line[1]), float(line[2])) line = reader.readline().split(",") cam1.SetFocalPoint(float(line[0]), float(line[1]), float(line[2])) line = reader.readline().split(",") cam1.SetViewUp(float(line[0]), float(line[1]), float(line[2])) line = reader.readline().split(",") cam1.SetClippingRange(float(line[0]), float(line[1])) line = reader.readline().split(",") cam1.SetViewAngle(float(line[0])) line = reader.readline().split(",") cam1.SetParallelScale(float(line[0])) # Initialize PyQT5 UI and link to renderer app = QApplication([]) window = QMainWindow() ui = Ui_MainWindow() ui.setupUi(window) ui.vtkWidget.GetRenderWindow().AddRenderer(ren) ui.vtkWidget.GetRenderWindow().SetSize(1280, 720) ui.vtkWidget.GetRenderWindow().AddRenderer(ren) ui.vtkWidget.GetRenderWindow().SetAlphaBitPlanes(True) ui.vtkWidget.GetRenderWindow().SetMultiSamples(False) iren = ui.vtkWidget.GetRenderWindow().GetInteractor() # create the scalar_bar density_scalar_bar = vtk.vtkScalarBarActor() density_scalar_bar.SetOrientationToHorizontal() density_scalar_bar.SetMaximumNumberOfColors(color_count) density_scalar_bar.SetLookupTable(density_lut) density_scalar_bar.SetTitle("Density (Log 10)") # create the scalar_bar_widget density_scalar_bar_widget = vtk.vtkScalarBarWidget() density_scalar_bar_widget.SetInteractor(iren) density_scalar_bar_widget.SetScalarBarActor(density_scalar_bar) density_scalar_bar_widget.On() # create the scalar_bar climate_scalar_bar = vtk.vtkScalarBarActor() climate_scalar_bar.SetOrientationToHorizontal() climate_scalar_bar.SetMaximumNumberOfColors(color_count) climate_scalar_bar.SetLookupTable(climate_lut) climate_scalar_bar.SetTitle("Temparature (Celsius)") # create the scalar_bar_widget climate_scalar_bar_widget = vtk.vtkScalarBarWidget() climate_scalar_bar_widget.SetInteractor(iren) climate_scalar_bar_widget.SetScalarBarActor(climate_scalar_bar) climate_scalar_bar_widget.Off() # Function to initialize slider settings def slider_setup(slider, val, bounds, interv): slider.setOrientation(QtCore.Qt.Horizontal) slider.setValue(float(val)) slider.setSliderPosition(val) slider.setTracking(False) slider.setTickInterval(interv) slider.setTickPosition(QSlider.TicksAbove) slider.setRange(bounds[0], bounds[1]) slider_setup(ui.time_slider, 0, [0, (curr_date - initial_date).days], 1) window.show() window.setWindowState(Qt.WindowMaximized) iren.Initialize() def time_slider_callback(val): new_date = initial_date + timedelta(val) if new_date.month.real != ui.curr_month: ui.curr_month = new_date.month.real climate_reader.SetFileName(args.climate + "-" + str(ui.curr_month).zfill(2) + ".tif") climate_reader.Update() new_range = climate_reader.GetOutput().GetScalarRange() climate_mapper.SetScalarRange(new_range) ui.date_label.setText("Date (" + new_date.strftime('%m/%d/%Y') + "):") def density_callback(): isOn = density_actor.GetVisibility() if isOn: density_actor.VisibilityOff() density_scalar_bar_widget.Off() ui.vtkWidget.GetRenderWindow().Render() ui.push_density.setText('Enable Density') else: density_actor.VisibilityOn() density_scalar_bar_widget.On() ui.vtkWidget.GetRenderWindow().Render() ui.push_density.setText('Disable Density') def climate_callback(): isOn = climate_actor.GetVisibility() if isOn: climate_actor.VisibilityOff() climate_scalar_bar_widget.Off() ui.vtkWidget.GetRenderWindow().Render() ui.push_climate.setText('Enable Temperature') else: climate_actor.VisibilityOn() climate_scalar_bar_widget.On() ui.vtkWidget.GetRenderWindow().Render() ui.push_climate.setText('Disable Temperature') # Handle screenshot button event def screenshot_callback(): save_frame(ren.GetActiveCamera(), ui.vtkWidget.GetRenderWindow(), ui.log) # Handle show camera settings button event def camera_callback(): print_camera_settings(ren.GetActiveCamera(), ui.camera_info, ui.log) # Handle quit button event def quit_callback(): sys.exit() # Register callbacks to UI ui.time_slider.valueChanged.connect(time_slider_callback) ui.push_screenshot.clicked.connect(screenshot_callback) ui.push_camera.clicked.connect(camera_callback) ui.push_quit.clicked.connect(quit_callback) ui.push_density.clicked.connect(density_callback) ui.push_climate.clicked.connect(climate_callback) # Terminate setup for PyQT5 interface sys.exit(app.exec_())
def _createIPW(self): # we have to do this to get the correct log range self._histogram.GetOutput().Update() # this means we have newly valid input and should setup an ipw self._ipw = vtk.vtkImagePlaneWidget() self._histogram.GetOutput().Update() self._ipw.SetInput(self._histogram.GetOutput()) self._ipw.SetInteractor(self._viewFrame.rwi) # normal to the Z-axis self._ipw.SetPlaneOrientation(2) self._ipw.SetSliceIndex(0) # setup specific lut srange = self._histogram.GetOutput().GetScalarRange() lut = vtk.vtkLookupTable() lut.SetScaleToLog10() lut.SetTableRange(srange) lut.SetSaturationRange(1.0, 1.0) lut.SetValueRange(1.0, 1.0) lut.SetHueRange(0.1, 1.0) lut.Build() self._ipw.SetUserControlledLookupTable(1) self._ipw.SetLookupTable(lut) self._ipw.SetDisplayText(1) # if we use ContinousCursor, we get OffImage when zoomed # on Linux (really irritating) but not on Windows. A VTK # recompile might help, we'll see. self._ipw.SetUseContinuousCursor(1) # make sure the user can't twist the plane out of sight self._ipw.SetMiddleButtonAction(0) self._ipw.SetRightButtonAction(0) # add an observer self._ipw.AddObserver("StartInteractionEvent", self._observerIPWInteraction) self._ipw.AddObserver("InteractionEvent", self._observerIPWInteraction) self._ipw.AddObserver("EndInteractionEvent", self._observerIPWInteraction) self._ipw.On() self._axes = vtk.vtkCubeAxesActor2D() self._axes.SetFlyModeToOuterEdges() # NOBODY will ever know why we have to switch off the Y axis when # we actually want the Z-axis to go away. self._axes.YAxisVisibilityOff() self._axes.SetBounds(self._ipw.GetResliceOutput().GetBounds()) self._renderer.AddActor(self._axes) self._axes.SetCamera(self._renderer.GetActiveCamera()) self._axes.PickableOff() if 0: # now add a scalarbar self._scalarBarWidget = vtk.vtkScalarBarWidget() self._scalarBarWidget.SetInteractor(self._viewFrame.rwi) self._scalarBarWidget.GetScalarBarActor().SetTitle("Frequency") self._scalarBarWidget.GetScalarBarActor().SetLookupTable(lut) # and activate self._scalarBarWidget.On() self._resetCamera() self._render()
def vtk_figure(output_filename, geometry, scalar=None, contours=None, width=400, height=230, scalar_colorbar=True): import vtk import math # bounding box bounds = geometry.GetBounds() cx = (bounds[0] + bounds[1]) / 2.0 cy = (bounds[2] + bounds[3]) / 2.0 scale = max( math.fabs(bounds[0] - cx), math.fabs(bounds[1] - cx), math.fabs(bounds[2] - cy), math.fabs(bounds[3] - cy) ) # renderer renderer = vtk.vtkRenderer() renderer.SetBackground(1, 1, 1) # scalar if scalar != None: renderer.AddActor(scalar) # contours if contours != None: renderer.AddActor(contours) # geometry renderer.AddActor(geometry) # camera camera = renderer.GetActiveCamera() camera.ParallelProjectionOn() camera.SetParallelScale(scale) camera.SetPosition(cx, cy, 1) camera.SetFocalPoint(cx, cy, 0) # render window render_window = vtk.vtkRenderWindow() render_window.SetOffScreenRendering(1) render_window.SetSize(width, height) render_window.AddRenderer(renderer) render_window.Render() # scalar colorbar if scalar != None: if scalar_colorbar: interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(render_window) scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetNumberOfLabels(8) scalar_bar.SetLabelFormat("%+#6.2e") scalar_bar.SetLookupTable(scalar.GetMapper().GetLookupTable()) scalar_bar.GetLabelTextProperty().SetFontFamilyToCourier() scalar_bar.GetLabelTextProperty().SetJustificationToRight() scalar_bar.GetLabelTextProperty().SetVerticalJustificationToCentered() scalar_bar.GetLabelTextProperty().BoldOff() scalar_bar.GetLabelTextProperty().ItalicOff() scalar_bar.GetLabelTextProperty().ShadowOff() scalar_bar.GetLabelTextProperty().SetColor(0, 0, 0) # create the scalar bar widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(interactor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() window_to_image_filter = vtk.vtkWindowToImageFilter() window_to_image_filter.SetInput(render_window) window_to_image_filter.Update() writer = vtk.vtkPNGWriter() writer.SetFileName(output_filename) writer.SetInputConnection(window_to_image_filter.GetOutputPort()) writer.Write()
def colormap(): colors = vtk.vtkNamedColors() # colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0]) # The source file file_name = get_program_parameters() #the name of data array which is used in this example daryName = 'v02' #'tev' 'v03' 'prs' # Read the source file. reader = vtk.vtkXMLImageDataReader() reader.SetFileName(file_name) reader.Update() # Needed because of GetScalarRange print(reader) output = reader.GetOutput() scalar_range = output.GetScalarRange() # specify the data array in the file to process reader.GetOutput().GetPointData().SetActiveAttribute(daryName, 0) # convert the data array to numpy array and get the min and maximum valule dary = VN.vtk_to_numpy( reader.GetOutput().GetPointData().GetScalars(daryName)) dMax = np.amax(dary) dMin = np.amin(dary) dRange = dMax - dMin print("Data array max: ", np.amax(dary)) print("Data array min: ", np.amin(dary)) # Create a custom lut. The lut is used both at the mapper and at the # scalar_bar lut = vtk.vtkLookupTable() lut.SetTableRange(dMin, dMax) lut.Build() mapper = vtk.vtkDataSetMapper() mapper.SetInputData(output) mapper.SetScalarRange(scalar_range) mapper.SetLookupTable(lut) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d('bkg')) render_window = vtk.vtkRenderWindow() render_window.AddRenderer(renderer) render_window.SetSize(300, 300) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(render_window) # create the scalar_bar scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(lut) # create the scalar_bar_widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(interactor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() interactor.Initialize() render_window.Render() renderer.GetActiveCamera().SetPosition(-6.4, 10.3, 1.4) renderer.GetActiveCamera().SetFocalPoint(1.0, 0.5, 3.0) renderer.GetActiveCamera().SetViewUp(0.6, 0.4, -0.7) render_window.Render() interactor.Start() # if __name__ == '__main__': # colormap()
renderer.SetBackground(0.1, 0.2, 0.4) render_window = vtk.vtkRenderWindow() render_window.AddRenderer(renderer) render_window.SetSize(300, 300) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(render_window) # create the scalar_bar scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(lut) # create the scalar_bar_widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(interactor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() # # Create a renderer and add the actors to it renderer = vtk.vtkRenderer() renderer.SetBackground(0.2, 0.2, 0.2) # renderer.AddActor(...) # Create a render window render_window = vtk.vtkRenderWindow() render_window.SetWindowName("Air currents") render_window.SetSize(800, 600)
def main(): # One render window, multiple viewports # renderWindowInteractor_list = [] renderWindow = vtk.vtkRenderWindow() renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # renderWindowInteractor.SetInteractorStyle( # vtk.vtkInteractorStyleTrackballCamera()) # Define viewport ranges xmins = [0.01, 0.51, 0.01, 0.51] xmaxs = [0.49, 0.99, 0.49, 0.99] ymins = [0.01, 0.01, 0.51, 0.51] ymaxs = [0.49, 0.49, 0.99, 0.99] for i in range(4): renderer = vtk.vtkRenderer() renderer.SetBackground(1, 1, 1) # renderer.SetBackgroundTexture(texture) # renderer.SetTexturedBackground(True) renderWindow.AddRenderer(renderer) renderer.SetViewport(xmins[i], ymins[i], xmaxs[i], ymaxs[i]) # renderer.AddActor(actorSTL) # renderer.AddActor(actorP) # renderer.AddActor(actorWSTL) renderer.AddActor(clipActorP) renderer.AddActor(clipActorSTL) renderer.AddActor(clipActorWSTL) renderer.AddActor(planeActor) # stPos = renderer.GetActiveCamera().GetPosition() # focPoint = renderer.GetActiveCamera().GetFocalPoint() # print("Pos", stPos) # print ("Foc point", focPoint) # default renderer.ResetCamera() if (i == 0): # from back (3rd quarter) renderer.GetActiveCamera().SetFocalPoint(stlPos) renderer.GetActiveCamera().SetPosition(stlPos[0] + 10.0, stlPos[1], stlPos[2]) renderer.GetActiveCamera().SetViewUp(0.0, 0.0, 1.0) renderer.ResetCamera() if (i == 1): # from bottom (4rd quarter) renderer.GetActiveCamera().SetFocalPoint(stlPos) renderer.GetActiveCamera().SetPosition(stlPos[0], stlPos[1], stlPos[2] - 10.0) renderer.GetActiveCamera().SetViewUp(0.0, 1.0, 0.0) renderer.ResetCamera() if (i == 2): # from front (2nd quarter) renderer.GetActiveCamera().SetFocalPoint(stlPos) renderer.GetActiveCamera().SetPosition(stlPos[0] - 10.0, stlPos[1], stlPos[2]) renderer.GetActiveCamera().SetViewUp(0.0, 0.0, 1.0) renderer.ResetCamera() scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() # scalar_bar.SetWidth(0.05) # scalar_bar.SetHeight(0.5) scalar_bar.SetTitle("Density") scalar_bar.GetTitleTextProperty().SetColor(0, 0, 0) scalar_bar.SetNumberOfLabels(5) scalar_bar.SetLabelFormat('%.1f') # ("%+#6.2e") scalar_bar.SetLookupTable(clipActorP.GetMapper().GetLookupTable()) # scalar_bar.SetLookupTable(actorP.GetMapper().GetLookupTable()) scalar_bar.GetLabelTextProperty().SetFontFamilyToCourier() scalar_bar.GetLabelTextProperty().SetJustificationToRight() scalar_bar.GetLabelTextProperty().SetVerticalJustificationToCentered() scalar_bar.GetLabelTextProperty().BoldOn() scalar_bar.GetLabelTextProperty().ItalicOff() scalar_bar.GetLabelTextProperty().ShadowOff() scalar_bar.GetLabelTextProperty().SetColor(0, 0, 0) # create the scalar bar widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(renderWindowInteractor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() renderWindow.SetSize(1870, 900) renderWindow.Render() renderWindow.SetWindowName('Lifeboat visualization') renderWindowInteractor.Start()
def main(): # setup the dataset filepath #filename = "yC31/pv_insitu_300x300x300_07678.vti" #filename = "yC31/pv_insitu_300x300x300_08415.vti" # the name of data array which is used in this example daryName = "v03" #'v03' 'prs' 'tev' # for accessomg build-in color access colors = vtk.vtkNamedColors() # Create the renderer, the render window, and the interactor. # The renderer draws into the render window. # The interactor enables mouse and keyboard-based interaction # with the data within the render windows. aRenderer = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(aRenderer) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Set a background color for the renderer # and set the size of the render window. aRenderer.SetBackground(colors.GetColor3d("Silver")) renWin.SetSize(600, 600) # data reader reader = vtk.vtkXMLImageDataReader() reader.SetFileName(filename) reader.Update() # specify the data array in the file to process reader.GetOutput().GetPointData().SetActiveAttribute(daryName, 0) # convert the data array to numpy array and get the min and maximum value dary = VN.vtk_to_numpy( reader.GetOutput().GetPointData().GetScalars(daryName)) dary = dary[dary != 0] dMax = np.amax(dary) dMin = np.amin(dary) dRange = dMax - dMin dMean = np.mean(dary) dMedian = np.median(dary) print("Data array max: ", dMax) print("Data array min: ", dMin) print("Data array range: ", dRange) print("Data array mean: ", dMean) print("Data array median: ", dMedian) ############ setup color map ######### # This creates a black to white lut. hueLut = vtk.vtkLookupTable() # This creates a red to blue lut. hueLut.SetHueRange(0.0, 0.667) hueLut.Build() # An outline provides context around the data. outlineData = vtk.vtkOutlineFilter() outlineData.SetInputConnection(reader.GetOutputPort()) outlineData.Update() mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outlineData.GetOutputPort()) outline = vtk.vtkActor() outline.SetMapper(mapOutline) outline.GetProperty().SetColor(colors.GetColor3d("Black")) ################## create volume rendering ################################ # Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(dMin, 0.0) opacityTransferFunction.AddPoint(dMax, 0.1) # int AddRGBPoint (double x, double r, double g, double b) # int AddHSVPoint (double x, double h, double s, double v) # Create transfer mapping scalar value to color. colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(dMin, 1.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(0.25, 1.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(0.5, 0.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(0.75, 0.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(dMax, 0.0, 0.0, 1.0) # The property describes how the data will look. volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.SetScalarOpacityUnitDistance(1000) #volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() # The mapper / ray cast function know how to render the data. volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(reader.GetOutputPort()) # The volume holds the mapper and the property and # can be used to position/orient the volume. volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) ######################## create a text ##################### # create a text actor txt = vtk.vtkTextActor() txt.SetInput("Scalar Value (v03)") txtprop = txt.GetTextProperty() txtprop.SetFontFamilyToArial() txtprop.SetFontSize(24) txtprop.SetColor(0, 0, 0) txt.SetDisplayPosition(380, 550) ############################################################ txt2 = vtk.vtkTextActor() txt_str2 = "timestep = " + filename[27:32] txt2.SetInput(txt_str2) txtprop2 = txt2.GetTextProperty() txtprop2.SetFontFamilyToArial() txtprop2.SetFontSize(24) txtprop2.SetColor(0, 0, 0) txt2.SetDisplayPosition(100, 550) ############################ create a color bar ########################### # create the scalar_bar scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(hueLut) # create the scalar_bar_widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(iren) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() aCamera = vtk.vtkCamera() aCamera.SetViewUp(0, 0, 1) aCamera.SetPosition(0, -1, 0) aCamera.SetFocalPoint(0, 0, 0) aCamera.ComputeViewPlaneNormal() aCamera.Azimuth(45.0) aCamera.Elevation(45.0) # Actors are added to the renderer. aRenderer.AddActor(outline) aRenderer.AddVolume(volume) aRenderer.AddActor(txt) aRenderer.AddActor(txt2) # An initial camera view is created. The Dolly() method moves # the camera towards the FocalPoint, thereby enlarging the image. aRenderer.SetActiveCamera(aCamera) # Calling Render() directly on a vtkRenderer is strictly forbidden. # Only calling Render() on the vtkRenderWindow is a valid call. renWin.Render() aRenderer.ResetCamera() aCamera.Dolly(-2.0) # Note that when camera movement occurs (as it does in the Dolly() method), # the clipping planes often need adjusting. # Clipping planes consist of two planes: # near and far along the view direction. # The near plane clips out objects in front of the plane; # the far plane clips out objects behind the plane. # This way only what is drawn between the planes is actually rendered. aRenderer.ResetCameraClippingRange() # Interact with the data. renWin.Render() iren.Initialize() iren.Start()
def create_colorbars(self, time_step, update_data=True, update_position=True): n_vol = len(self.volume_list) if n_vol > 0: min_x = 0.05 max_x = 0.95 min_y = 0.9 max_y = 0.95 pos1 = (min_x, min_y) pos2 = (max_x - min_x, max_y - min_y) sep = 0.025 tot_height = max_y - min_y tot_width = max_x - min_x max_an = 10 min_an = 3 # test colorbar n_bar = len(self.scalar_bar_widgets_list) an = int(min_an + (max_an - min_an) / (2 * n_vol)) for i in np.arange(n_vol): if update_data: # Get lookup table and set annotations lut = self.volume_list[i].get_color_transfer_function() lut.ResetAnnotations() fld_n, fld_r = self.volume_list[ i].get_norm_and_real_field_range(time_step, an) m = np.max(np.abs(fld_r)) # get order of magnitude ord = int(np.log10(m)) fld_r = fld_r / 10**ord for j in np.arange(an): lut.SetAnnotation(fld_n[j], format(fld_r[j], '.2f')) if ord != 0: order_str = "10^" + str(ord) + " " else: order_str = "" # Create colorbars if i > n_bar - 1: scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(lut) scalar_bar.SetTitle( self.volume_list[i].get_field_name() + " [" + order_str + self.volume_list[i].get_field_units() + "]") scalar_bar.SetTextPositionToPrecedeScalarBar() scalar_bar.DrawTickLabelsOff() scalar_bar.AnnotationTextScalingOn() scalar_bar.GetAnnotationTextProperty().SetFontSize(8) scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(self.interactor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() self.scalar_bar_widgets_list.append(scalar_bar_widget) # Resize and position colorbars if update_position: wid_w = (tot_width - (n_vol - 1) * sep) / n_vol y_1 = min_y x_1 = min_x + i * (wid_w + sep) y_2 = tot_height x_2 = wid_w self.scalar_bar_widgets_list[i].GetRepresentation( ).SetOrientation(0) self.scalar_bar_widgets_list[i].GetRepresentation( ).GetPositionCoordinate().SetValue(x_1, y_1) self.scalar_bar_widgets_list[i].GetRepresentation( ).GetPosition2Coordinate().SetValue(x_2, y_2) self.update_cbars = False
def myMain(controller,args): fname=args.fname controller=args.controller myid = controller.GetLocalProcessId(); numProcs = controller.GetNumberOfProcesses(); pts=np.loadtxt(fname) sf=100 paint=rgbPainter() r,t,z = rec2cyl(pts[:,0],pts[:,1],pts[:,2]) #im=np.abs(getGeomImperfection(r,z,np.mean(r))) if pts.shape[1] == 4: im=pts[:,3] else: im=getGeomImperfection(r,z,np.mean(r)) rid=r-im xx,yy,zz=cyl2rec(rid+im*sf,t,z) math = vtk.vtkMath() points = vtk.vtkPoints() colors =vtk.vtkUnsignedCharArray() colors.SetNumberOfComponents(3); colors.SetName("Colors"); for i in range(0,pts.shape[0]): #points.InsertPoint(i,pts[i][0],pts[i][1],pts[i][2] ) points.InsertPoint(i,xx[i],yy[i],zz[i] ) polydata = vtk.vtkPolyData() polydata.SetPoints(points) polydata.GetPointData().SetScalars(colors) polydata.Update() surf =vtk.vtkSurfaceReconstructionFilter() surf.SetInput(polydata) surf.SetNeighborhoodSize(40) #surf.SetSampleSpacing(6.0) if (myid != 0): controller.AddRMI(surf.Update,'',200) controller.ProcessRMIs(); else: contourFilter = vtk.vtkContourFilter() contourFilter.SetInputConnection(surf.GetOutputPort()) reverse = vtk.vtkReverseSense() reverse.SetInputConnection(contourFilter.GetOutputPort()) reverse.ReverseCellsOn() reverse.ReverseNormalsOn() reverse.Update() outputPolyData=reverse.GetOutput() #for i in range(0,pts.shape[0]): # dcolor=np.zeros(3) # colorLookupTable.GetColor(im[i],dcolor) # cc=dcolor*255.0 # colors.InsertNextTupleValue(cc) #outputPolyData.GetPointData().SetScalars(polydata.GetPointData().GetScalars() ); newSurf = transform_back( points, reverse.GetOutput()); pts2=np.zeros((newSurf.GetNumberOfPoints(),3)) for i in range(0,newSurf.GetNumberOfPoints()): pts2[i,:]=newSurf.GetPoint(i) r2,t2,z2 = rec2cyl(pts2[:,0],pts2[:,1],pts2[:,2]) im2=getGeomImperfection(r2,z2,np.mean(r2)) #im2-=np.min(im2) #im2=np.abs(im2) paint.setValue(np.min(im2)) paint.setValue(np.max(im2)) for i in range(0,newSurf.GetNumberOfPoints()): colors.InsertNextTupleValue(paint.getRGB(im2[i])) newSurf.GetPointData().SetScalars(colors ); mapper = vtk.vtkPolyDataMapper(); mapper.InterpolateScalarsBeforeMappingOn() #mapper.SetInputConnection(outputPolyData.GetProducerPort()) mapper.SetInputConnection(newSurf.GetProducerPort()) mapper.SetScalarModeToUsePointData() mapper.ScalarVisibilityOn(); surfaceActor = vtk.vtkActor(); surfaceActor.SetMapper(mapper); ren = vtk.vtkRenderer(); renWin = vtk.vtkRenderWindow(); renWin.AddRenderer(ren); iren = vtk.vtkRenderWindowInteractor(); iren.SetRenderWindow(renWin); style = vtk.vtkInteractorStyleTrackballCamera() iren.SetInteractorStyle(style) ren.AddActor(surfaceActor); ren.SetBackground(1, 1, 1); renWin.SetSize(800, 600); prn=1000. pc=-prn plXY = vtk.vtkPlaneSource() plXY.SetPoint1(prn,-prn,0) plXY.SetPoint2(-prn,prn,0) plXY.SetOrigin(pc,pc,0) plXY.SetCenter(0,0,0) plXYmap = vtk.vtkPolyDataMapper() plXYmap.SetInput(plXY.GetOutput()) plXYact = vtk.vtkActor() plXYact.SetMapper(plXYmap) plXYact.GetProperty().SetOpacity(0.1) plYZ = vtk.vtkPlaneSource() plYZ.SetCenter(0,pc,pc) plYZ.SetPoint1(0,prn,-prn) plYZ.SetPoint2(0,-prn,prn) plYZmap = vtk.vtkPolyDataMapper() plYZmap.SetInput(plYZ.GetOutput()) plYZact = vtk.vtkActor() plYZact.SetMapper(plYZmap) plYZact.GetProperty().SetOpacity(0.1) plZX = vtk.vtkPlaneSource() plZX.SetCenter(pc,0,pc) plZX.SetPoint1(prn,0,-prn) plZX.SetPoint2(-prn,0,prn) plZXmap = vtk.vtkPolyDataMapper() plZXmap.SetInput(plZX.GetOutput()) plZXact = vtk.vtkActor() plZXact.SetMapper(plZXmap) plZXact.GetProperty().SetOpacity(0.1) ren.AddActor(plXYact) ren.AddActor(plYZact) ren.AddActor(plZXact) ax=vtk.vtkAxesActor() ax.GetXAxisCaptionActor2D().GetProperty().SetColor(0,0,0) ax.GetYAxisCaptionActor2D().GetProperty().SetColor(0,0,0) ax.GetZAxisCaptionActor2D().GetProperty().SetColor(0,0,0) ow=vtk.vtkOrientationMarkerWidget() ow.SetOrientationMarker(ax) ow.SetInteractor(iren) ow.SetViewport( 0.0, 0.0, 0.4, 0.4 ) ow.SetEnabled( 1 ) ow.InteractiveOn() lut=vtk.vtkLookupTable() lut.SetHueRange( 0.66667, 0.0 ) lut.SetSaturationRange (1.0, 1.0) lut.SetNumberOfColors(50)# len(self.plotables)) lut.SetTableRange(paint.getMinValue(),paint.getMaxValue()) lut.Build() scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(lut) scalar_bar.SetTitle("Imperfection value"); scalar_bar.SetNumberOfLabels(11) scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(iren) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() iren.Initialize(); renWin.Render(); iren.Start();
def addWidgets(self): prn=1000. pc=-prn plXY = vtk.vtkPlaneSource() plXY.SetPoint1(prn,-prn,0) plXY.SetPoint2(-prn,prn,0) plXY.SetOrigin(pc,pc,0) plXY.SetCenter(0,0,0) plXYmap = vtk.vtkPolyDataMapper() plXYmap.SetInput(plXY.GetOutput()) plXYact = vtk.vtkActor() plXYact.SetMapper(plXYmap) plXYact.GetProperty().SetOpacity(0.1) plYZ = vtk.vtkPlaneSource() plYZ.SetCenter(0,pc,pc) plYZ.SetPoint1(0,prn,-prn) plYZ.SetPoint2(0,-prn,prn) plYZmap = vtk.vtkPolyDataMapper() plYZmap.SetInput(plYZ.GetOutput()) plYZact = vtk.vtkActor() plYZact.SetMapper(plYZmap) plYZact.GetProperty().SetOpacity(0.1) plZX = vtk.vtkPlaneSource() plZX.SetCenter(pc,0,pc) plZX.SetPoint1(prn,0,-prn) plZX.SetPoint2(-prn,0,prn) plZXmap = vtk.vtkPolyDataMapper() plZXmap.SetInput(plZX.GetOutput()) plZXact = vtk.vtkActor() plZXact.SetMapper(plZXmap) plZXact.GetProperty().SetOpacity(0.1) ax=vtk.vtkAxesActor() ax.GetXAxisCaptionActor2D().GetProperty().SetColor(0,0,0) ax.GetYAxisCaptionActor2D().GetProperty().SetColor(0,0,0) ax.GetZAxisCaptionActor2D().GetProperty().SetColor(0,0,0) lut=vtk.vtkLookupTable() lut.SetHueRange( 0.66667, 0.0 ) lut.SetSaturationRange (1.0, 1.0) lut.SetNumberOfColors(20)# len(self.plotables)) lut.SetTableRange(self.paint.getMinValue(),self.paint.getMaxValue()) lut.Build() self.ow=vtk.vtkOrientationMarkerWidget() self.scalar_bar = vtk.vtkScalarBarActor() self.scalar_bar.SetOrientationToHorizontal() self.scalar_bar.SetLookupTable(lut) self.scalar_bar.SetTitle("Imperfection value"); self.scalar_bar.SetNumberOfLabels(11) self.scalar_bar_widget = vtk.vtkScalarBarWidget() textActor = vtk.vtkTextActor() textActor.GetTextProperty().SetFontSize ( 22 ) textActor.SetPosition2( 100, 100 ) textActor.SetInput(r'DESICOS VIEWER: '+r'Scaling: '+str(self.scalingFactor)+r' File:'+str(self.caption)) textActor.GetTextProperty().SetColor ( 0.0,0.0,0.0 ) if self.showXYPlane: self.ren.AddActor(plXYact) if self.showYZPlane: self.ren.AddActor(plYZact) if self.showZXPlane: self.ren.AddActor(plZXact) if self.showCaption: self.ren.AddActor2D( textActor ) if self.showScalarBar: self.scalar_bar_widget.SetInteractor(self.iren) self.scalar_bar_widget.SetScalarBarActor(self.scalar_bar) self.scalar_bar_widget.On() if self.showAxes: self.ow.SetOrientationMarker(ax) self.ow.SetInteractor(self.iren) # self.ow.SetViewport( 0.0, 0.0, 0.4, 0.4 ) self.ow.SetEnabled( 1 ) self.ow.InteractiveOn()
def Add_GenActors(self,iren,renWin,method,lut,ren,window,current_Actors,flag2D): import vtk # Create the TextActor ASDGenActors.time_label = vtk.vtkTextActor() ASDGenActors.time_label.SetInput(str('{: 4.2f}'.format(0.00)+' ns')) ASDGenActors.time_label.GetTextProperty().SetColor((0, 0, 0)) # Create the text representation. Used for positioning the text_actor ASDGenActors.time_label_rep = vtk.vtkTextRepresentation() ASDGenActors.time_label_rep.GetPositionCoordinate().SetValue(0.80, 0.90) ASDGenActors.time_label_rep.GetPosition2Coordinate().SetValue(0.10, 0.10) ######################################################################## # Creating the actual widget ######################################################################## ASDGenActors.time_label_widget = vtk.vtkTextWidget() ASDGenActors.time_label_widget.SetRepresentation(ASDGenActors.time_label_rep) ASDGenActors.time_label_widget.SetInteractor(iren) ASDGenActors.time_label_widget.SetTextActor(ASDGenActors.time_label) ASDGenActors.time_label_widget.SelectableOff() ASDGenActors.time_label_widget.Off() ######################################################################## # Creation of the data structures for the data clipping ######################################################################## # Right now this only can clip polydata, which is fine for 2D structures # however, for the 3d Delaunay tessellation, the output is an unstructured # grid, which means that annother type of clipper is required ######################################################################## ASDGenActors.plane = vtk.vtkPlane() ASDGenActors.plane.SetOrigin(current_Actors.xmin, current_Actors.ymid, current_Actors.zmid) ASDGenActors.plane.SetNormal(1, 0, 0) ######################################################################## # Check which kind of clipper must be used, as 2D and 3D data must be # treated differently ######################################################################## if flag2D: ASDGenActors.clipper = vtk.vtkClipPolyData() else: ASDGenActors.clipper = vtk.vtkClipVolume() # Set the common variables for the clipper mapper ASDGenActors.clipper.SetInputConnection(method.GetOutputPort()) ASDGenActors.clipper.SetClipFunction(ASDGenActors.plane) ASDGenActors.clipper.InsideOutOn() # Mapper of the clipper ASDGenActors.clipperMapper = vtk.vtkDataSetMapper() ASDGenActors.clipperMapper.SetScalarRange(method.GetInput().GetScalarRange()) ASDGenActors.clipperMapper.SetInputConnection(ASDGenActors.clipper.GetOutputPort()) ASDGenActors.clipperMapper.SetLookupTable(lut) # Creating the actor ASDGenActors.clipperActor = vtk.vtkLODActor() ASDGenActors.clipperActor.SetMapper(ASDGenActors.clipperMapper) ASDGenActors.clipperActor.VisibilityOff() # Adding the actor to the scene ren.AddActor(ASDGenActors.clipperActor) ######################################################################## # Setting the information for the scalar bar widget ######################################################################## # Create the scalar bar actor ASDGenActors.scalar_bar = vtk.vtkScalarBarActor() ASDGenActors.scalar_bar.SetLookupTable(lut) ASDGenActors.scalar_bar.GetLabelTextProperty().SetColor(0.0,0.0,0.0) ASDGenActors.scalar_bar.SetNumberOfLabels(5) ASDGenActors.scalar_bar.GetLabelTextProperty().ShadowOff() ASDGenActors.scalar_bar.GetLabelTextProperty().BoldOn() ASDGenActors.scalar_bar.GetLabelTextProperty().ItalicOff() ASDGenActors.scalar_bar.GetLabelTextProperty().SetFontSize(8) ASDGenActors.scalar_bar.SetLabelFormat("%-#6.1E") ASDGenActors.scalar_bar.SetBarRatio(0.5) ASDGenActors.scalar_bar.DrawBackgroundOn() ASDGenActors.scalar_bar.DrawTickLabelsOn() # Create the scalar bar widget ASDGenActors.scalar_bar_widget = vtk.vtkScalarBarWidget() ASDGenActors.scalar_bar_widget.SetScalarBarActor(ASDGenActors.scalar_bar) # Representation to actually control where the scalar bar is ASDGenActors.scalarBarRep = ASDGenActors.scalar_bar_widget.GetRepresentation() ASDGenActors.scalarBarRep.SetOrientation(0) # 0 = Horizontal, 1 = Vertical ASDGenActors.scalarBarRep.GetPositionCoordinate().SetValue(0.30,0.05) ASDGenActors.scalarBarRep.GetPosition2Coordinate().SetValue(0.50,0.05) ASDGenActors.scalar_bar_widget.SetInteractor(iren) ASDGenActors.scalar_bar_widget.On() ######################################################################## # Setting the information for the axes widget ######################################################################## # Create the axes actor try: ASDGenActors.axes except: ASDGenActors.axes = vtk.vtkAxesActor() ASDGenActors.axes.SetShaftTypeToCylinder() ASDGenActors.axes.SetCylinderRadius(0.05) ASDGenActors.axes.SetNormalizedShaftLength(0.85,0.85,0.85) ASDGenActors.axes.SetNormalizedTipLength(0.40,0.40,0.40) ASDGenActors.axes.SetConeResolution(40) ASDGenActors.axes.SetCylinderResolution(40) # The properties of the text can be controlled independently ASDGenActors.axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetColor(0.0,0.0,0.0) ASDGenActors.axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetColor(0.0,0.0,0.0) ASDGenActors.axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetColor(0.0,0.0,0.0) ASDGenActors.axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff() ASDGenActors.axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff() ASDGenActors.axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff() else: pass ######################################################################## # The axes actor is then used as an orientation marker widget, the advantage # of setting it up as a widget is that it is interactive and one can move it # and that it moves as the zoom changes # Must make sure that the widget is part of the main class so that it can # be actually rendered and no segfaults occur ######################################################################## try: ASDGenActors.OrientMarker except: ASDGenActors.OrientMarker= vtk.vtkOrientationMarkerWidget() ASDGenActors.OrientMarker.SetOutlineColor(0.9300, 0.5700, 0.1300) ASDGenActors.OrientMarker.SetOrientationMarker(ASDGenActors.axes) ASDGenActors.OrientMarker.SetViewport(0.0, 0.0, 0.2, 0.2) ASDGenActors.OrientMarker.SetInteractor(iren) ASDGenActors.OrientMarker.EnabledOn() # <== application freeze-crash ASDGenActors.OrientMarker.InteractiveOn() else: pass iren.Start() renWin.Render() return
def load_vtk_legacy_file(self, file): """ Loads the vtk mesh and displays the scalar data in a color map. Allows further postprocessing to be done, such as grayscale and contour plots. """ if hasattr(self, "mesh_actor"): self.ren.RemoveActor(self.mesh_actor) self.ren.RemoveActor(self.sbActor) if file is None: file, _ = get_file("*.vtk") self.ui.statLabel.setText("Reading %s for mesh . . ." % file) mesh_source = vtk.vtkUnstructuredGridReader() mesh_source.SetFileName(file) # read scalar to vtk mesh_source.SetScalarsName("S33") mesh_source.Update() mesh_reader_output = mesh_source.GetOutput() # bounds for axis bounds = mesh_reader_output.GetBounds() # show element edges edges = vtk.vtkExtractEdges() edges.SetInputConnection(mesh_source.GetOutputPort()) edges.Update() # lookup table and scalar range for a vtk file mesh_lookup_table = vtk.vtkLookupTable() # make scalar red = max; blue = min self.ui.statLabel.setText("Building lookup table . . .") self.draw_color_range(mesh_lookup_table) mesh_lookup_table.Build() scalar_range = mesh_reader_output.GetScalarRange() # mesh data set self.mesh_mapper = vtk.vtkDataSetMapper() self.mesh_mapper.SetInputData(mesh_reader_output) self.mesh_mapper.SetScalarRange(scalar_range) self.mesh_mapper.SetLookupTable(mesh_lookup_table) #define actors self.mesh_actor = vtk.vtkActor() # self.sbActor = vtk.vtkScalarBarActor() # #the scalar bar widget is associated with the qt interactor box scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(self.iren) # scalar_bar_widget.SetCurrentRenderer(self.ren.GetRenderer()) # scalar_bar_widget.SetDefaultRenderer(self.ren.GetRenderer()) scalar_bar_widget.SetEnabled(True) scalar_bar_widget.RepositionableOn() scalar_bar_widget.On() # define scalar bar actor self.sbActor = scalar_bar_widget.GetScalarBarActor() # self.sbActor.SetOrientationToVertical() self.sbActor.SetLookupTable(mesh_lookup_table) self.sbActor.SetTitle("S33") scalarBarRep = scalar_bar_widget.GetRepresentation() scalarBarRep.GetPositionCoordinate().SetValue(0.01, 0.01) scalarBarRep.GetPosition2Coordinate().SetValue(0.09, 0.9) #attempt to change scalebar properties [ineffective] propT = vtk.vtkTextProperty() propL = vtk.vtkTextProperty() propT.SetFontFamilyToArial() # propT.ItalicOff() propT.BoldOn() propL.BoldOff() propL.SetFontSize(1) propT.SetFontSize(2) self.sbActor.SetTitleTextProperty(propT) self.sbActor.SetLabelTextProperty(propL) self.sbActor.GetLabelTextProperty().SetFontSize(7) self.sbActor.GetTitleTextProperty().SetFontSize(7) self.sbActor.SetLabelFormat("%.1f") #define the mesh actor properties self.mesh_actor.SetMapper(self.mesh_mapper) self.mesh_actor.GetProperty().SetLineWidth(1) self.mesh_actor.GetProperty().EdgeVisibilityOn() #display the actors self.ren.AddActor(self.mesh_actor) self.ren.AddActor(self.sbActor) #get boundary of mesh self.limits = mesh_reader_output.GetBounds() self.ui.vtkWidget.setFocus() self.AddAxis(self.limits, 1) xyview_post(self.ren, self.ren.GetActiveCamera(), self.cp, self.fp) #sorts out the camera issue self.ui.vtkWidget.update() self.ui.statLabel.setText("Loaded results. Idle.") QtWidgets.QApplication.processEvents()
def main(): # setup the dataset filepath all_filename = np.genfromtxt('stats/filenames.csv', dtype=None) time_index = [] for i in range(60, 120): if (i % 5 == 0): time_index.append(i) #print(time_index); overview_filename = all_filename[time_index] certain_filename = all_filename[69:88] # value_1 = average mean + 3*std # we calculate it in other file "finalproject_T2" value_1 = 0.3547 daryName = "tev" #'v03' 'prs' 'tev' for i in range(0, len(overview_filename)): #for i in range(0, 1): #filename = "yC31/"+overview_filename[i]; filename = "yC31/" + certain_filename[i] print(filename) # for accessomg build-in color access colors = vtk.vtkNamedColors() # Create the renderer, the render window, and the interactor. # The renderer draws into the render window. # The interactor enables mouse and keyboard-based interaction # with the data within the render windows. aRenderer = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(aRenderer) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Set a background color for the renderer # and set the size of the render window. aRenderer.SetBackground(colors.GetColor3d("Silver")) renWin.SetSize(600, 600) # data reader reader = vtk.vtkXMLImageDataReader() reader.SetFileName(filename) reader.Update() # specify the data array in the file to process reader.GetOutput().GetPointData().SetActiveAttribute(daryName, 0) # convert the data array to numpy array and get the min and maximum value dary = VN.vtk_to_numpy( reader.GetOutput().GetPointData().GetScalars(daryName)) dary = dary[dary != 0] dMax = np.amax(dary) dMin = np.amin(dary) dRange = dMax - dMin dMean = np.mean(dary) dMedian = np.median(dary) ''' print("Data array max: ", dMax); print("Data array min: ", dMin); print("Data array range: ", dRange); print("Data array mean: ", dMean); print("Data array median: ", dMedian); ''' ############ setup color map ######### # This creates a black to white lut. hueLut = vtk.vtkLookupTable() # This creates a red to blue lut. hueLut.SetHueRange(0.0, 0.667) hueLut.Build() # An outline provides context around the data. outlineData = vtk.vtkOutlineFilter() outlineData.SetInputConnection(reader.GetOutputPort()) outlineData.Update() mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outlineData.GetOutputPort()) outline = vtk.vtkActor() outline.SetMapper(mapOutline) outline.GetProperty().SetColor(colors.GetColor3d("Black")) ################## create volume rendering ################################ # Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(0, 0.0001) opacityTransferFunction.AddPoint(value_1, 0.0003) opacityTransferFunction.AddPoint(1.0, 0.005) # int AddRGBPoint (double x, double r, double g, double b) # int AddHSVPoint (double x, double h, double s, double v) # Create transfer mapping scalar value to color. colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0, 1.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(dRange / 4, 1.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(dRange / 4 * 2, 0.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(dRange / 4 * 3, 0.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(1.0, 0.0, 0.0, 1.0) # The property describes how the data will look. volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.SetScalarOpacityUnitDistance(1000) volumeProperty.SetInterpolationTypeToLinear() # The mapper / ray cast function know how to render the data. volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(reader.GetOutputPort()) # The volume holds the mapper and the property and # can be used to position/orient the volume. volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) ######################## create a text ##################### # create a text actor txt = vtk.vtkTextActor() txt.SetInput("Scalar Value (tev)") txtprop = txt.GetTextProperty() txtprop.SetFontFamilyToArial() txtprop.SetFontSize(24) txtprop.SetColor(0, 0, 0) txt.SetDisplayPosition(380, 550) ############################################################ txt2 = vtk.vtkTextActor() txt_str2 = "timestep = " + filename[27:32] txt2.SetInput(txt_str2) txtprop2 = txt2.GetTextProperty() txtprop2.SetFontFamilyToArial() txtprop2.SetFontSize(24) txtprop2.SetColor(0, 0, 0) txt2.SetDisplayPosition(100, 550) ############################ create a color bar ########################### # create the scalar_bar scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(hueLut) # create the scalar_bar_widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(iren) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() aCamera = vtk.vtkCamera() aCamera.SetViewUp(0, 0, 1) aCamera.SetPosition(1, 1, 2) aCamera.SetFocalPoint(0, 0, 0) aCamera.ComputeViewPlaneNormal() aCamera.Azimuth(45.0) aCamera.Elevation(45.0) # Actors are added to the renderer. aRenderer.AddActor(outline) aRenderer.AddVolume(volume) aRenderer.AddActor(txt) aRenderer.AddActor(txt2) # An initial camera view is created. The Dolly() method moves # the camera towards the FocalPoint, thereby enlarging the image. aRenderer.SetActiveCamera(aCamera) # Calling Render() directly on a vtkRenderer is strictly forbidden. # Only calling Render() on the vtkRenderWindow is a valid call. renWin.Render() aRenderer.ResetCamera() aCamera.Dolly(-2.0) #################################################################### # screenshot code: w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(renWin) w2if.Update() writer = vtk.vtkPNGWriter() saveName = "plots/v_r/tev/" + daryName + "_t_" + filename[ 27:32] + ".png" writer.SetFileName(saveName) writer.SetInputData(w2if.GetOutput()) writer.Write() ##################################################################### # Note that when camera movement occurs (as it does in the Dolly() method), # the clipping planes often need adjusting. # Clipping planes consist of two planes: # near and far along the view direction. # The near plane clips out objects in front of the plane; # the far plane clips out objects behind the plane. # This way only what is drawn between the planes is actually rendered. aRenderer.ResetCameraClippingRange() # Interact with the data. renWin.Render()
def main(): # Initialize argument and constant variables parser = ArgumentParser("Create isosurfacing of object") parser.add_argument("infections") parser.add_argument("recovered") parser.add_argument("deaths") parser.add_argument("density") parser.add_argument("climate_max") parser.add_argument("climate_min") parser.add_argument("location") parser.add_argument("migration") parser.add_argument("sat") parser.add_argument("--camera", type=str, help="Optional camera settings file") args = parser.parse_args() global sat_x global sat_y global max_cases global max_radius global infections_color global recovered_color global deaths_color global infections_opacity global recovered_opacity global deaths_opacity global infections_data global recovered_data global deaths_data global legend_circle_actors global legend_text_actors global max_weight global ren app = QApplication([]) window = QMainWindow() ui = Ui_MainWindow() ui.setupUi(window) # Read in data for global confirmed cases with open(args.infections) as csvDataFile: csv_reader = csv.reader(csvDataFile) for row in csv_reader: # We do not need country/province name, so we remove the first two columns if (row[2] != 0 or row[3] != 0): infections_data.append(row[2:]) infections_data = infections_data[1:] # Read in data for global deaths with open(args.deaths) as csvDataFile: csv_reader = csv.reader(csvDataFile) for row in csv_reader: if (row[2] != 0 or row[3] != 0): deaths_data.append(row[2:]) deaths_data = deaths_data[1:] # Read in data for global recovered cases with open(args.recovered) as csvDataFile: csv_reader = csv.reader(csvDataFile) for row in csv_reader: if (row[2] != 0 or row[3] != 0): recovered_data.append(row[2:]) recovered_data = recovered_data[1:] numDates = len(infections_data[0]) - 3 max_cases = compute_max(date) # Create reader for density file density_reader = vtk.vtkTIFFReader() density_reader.SetFileName(args.density) density_reader.Update() density_log = vtk.vtkImageLogarithmicScale() density_log.SetInputConnection(density_reader.GetOutputPort()) density_log.SetConstant(0.435) density_log.Update() density_range = density_log.GetOutput().GetScalarRange() climate_max_reader = vtk.vtkTIFFReader() climate_max_reader.SetFileName(args.climate_max + "-" + str(initial_date.month.real).zfill(2) + ".tif") climate_max_reader.Update() climate_max_range = [-40, 45] climate_min_reader = vtk.vtkTIFFReader() climate_min_reader.SetFileName(args.climate_min + "-" + str(initial_date.month.real).zfill(2) + ".tif") climate_min_reader.Update() climate_min_range = [-50, 30] sat_reader = vtk.vtkJPEGReader() sat_reader.SetFileName(args.sat) sat_reader.Update() sat_dimensions = sat_reader.GetOutput().GetDimensions() sat_x = sat_dimensions[0] sat_y = sat_dimensions[1] # Read in data for migration location_map = create_long_lat(args.location) migrations = [] for filename in os.listdir(args.migration): if filename.endswith(".csv"): with open(args.migration + "\\" + filename) as csvDataFile: country = filename.split(".")[0] if country not in location_map: continue loc_dst = location_map[country] csv_reader = csv.reader(csvDataFile) for row in csv_reader: if row[2] not in location_map: continue loc_src = location_map[row[2]] try: migrations.append( add_migration_info(loc_src, loc_dst, int(row[9]))) except ValueError: continue line_actors = process_migration_actors(migrations) # Create a plane to map the satellite image onto plane = vtk.vtkPlaneSource() plane.SetCenter(0.0, 0.0, 0.0) plane.SetNormal(0.0, 0.0, 1.0) plane.SetPoint1(sat_x, 0, 0) plane.SetPoint2(0, sat_y, 0) # Create satellite image texture texture = vtk.vtkTexture() texture.SetInputConnection(sat_reader.GetOutputPort()) # Map satellite texture to plane texturePlane = vtk.vtkTextureMapToPlane() texturePlane.SetInputConnection(plane.GetOutputPort()) max_val = 100 color_count = 1000 density_ctf = vtk.vtkColorTransferFunction() density_ctf.AddRGBPoint(0, 0, 0, 0) density_ctf.AddRGBPoint(10, 0, 0, 1) density_ctf.AddRGBPoint(30, 0, 1, 1) density_ctf.AddRGBPoint(50, 1, 1, 0) density_ctf.AddRGBPoint(65, 1, 0.5, 0) density_ctf.AddRGBPoint(80, 1, 0, 0) density_lut = vtk.vtkLookupTable() density_lut.SetNumberOfTableValues(color_count) density_lut.Build() rgb = list(density_ctf.GetColor(0)) + [0] density_lut.SetTableValue(0, rgb) for i in range(1, color_count): rgb = list(density_ctf.GetColor( max_val * float(i) / color_count)) + [1] density_lut.SetTableValue(i, rgb) climate_ctf = vtk.vtkColorTransferFunction() climate_ctf.AddRGBPoint(5, 0, 0, 1) climate_ctf.AddRGBPoint(35, 0, 1, 1) climate_ctf.AddRGBPoint(65, 1, 1, 0) climate_ctf.AddRGBPoint(95, 1, 0, 0) climate_lut = vtk.vtkLookupTable() climate_lut.SetNumberOfTableValues(color_count) climate_lut.Build() for i in range(0, color_count): rgb = list(climate_ctf.GetColor( max_val * float(i) / color_count)) + [1] climate_lut.SetTableValue(i, rgb) # Create mappers density_mapper = vtk.vtkDataSetMapper() density_mapper.SetInputConnection(density_log.GetOutputPort()) density_mapper.SetLookupTable(density_lut) density_mapper.SetScalarRange([0, density_range[1]]) density_mapper.Update() climate_max_mapper = vtk.vtkDataSetMapper() climate_max_mapper.SetInputConnection(climate_max_reader.GetOutputPort()) climate_max_mapper.SetLookupTable(climate_lut) climate_max_mapper.SetScalarRange(climate_max_range) climate_max_mapper.Update() climate_min_mapper = vtk.vtkDataSetMapper() climate_min_mapper.SetInputConnection(climate_min_reader.GetOutputPort()) climate_min_mapper.SetLookupTable(climate_lut) climate_min_mapper.SetScalarRange(climate_min_range) climate_min_mapper.Update() sat_mapper = vtk.vtkPolyDataMapper() sat_mapper.SetInputConnection(texturePlane.GetOutputPort()) density_actor = vtk.vtkActor() density_actor.SetMapper(density_mapper) density_actor.GetProperty().SetOpacity(0.99) density_actor.VisibilityOn() climate_max_actor = vtk.vtkActor() climate_max_actor.SetMapper(climate_max_mapper) climate_max_actor.GetProperty().SetOpacity(0.6) climate_max_actor.VisibilityOff() climate_min_actor = vtk.vtkActor() climate_min_actor.SetMapper(climate_min_mapper) climate_min_actor.GetProperty().SetOpacity(0.6) climate_min_actor.VisibilityOff() sat_actor = vtk.vtkActor() sat_actor.SetMapper(sat_mapper) sat_actor.SetTexture(texture) sat_actor.GetProperty().SetOpacity(0.6) # Make satellite image same size as contour map crange = sat_actor.GetXRange()[0] - sat_actor.GetXRange()[1] mrange = density_actor.GetXRange()[0] - density_actor.GetXRange()[1] density_actor.SetScale(crange / mrange) crange = sat_actor.GetXRange()[0] - sat_actor.GetXRange()[1] mrange = climate_max_actor.GetXRange()[0] - climate_max_actor.GetXRange( )[1] climate_max_actor.SetScale(crange / mrange) climate_min_actor.SetScale(crange / mrange) # Initialize renderer and place actors ren = vtk.vtkRenderer() ren.AddActor(density_actor) ren.AddActor(climate_max_actor) ren.AddActor(climate_min_actor) # Add legend actors add_legend_actors() # Add infections, recovered, and deaths actors infections_actors = [] if (ui.infections_check.isChecked()): add_case_actors(date, infections_data, infections_actors, infections_color, infections_opacity) recovered_actors = [] if (ui.recovered_check.isChecked()): add_case_actors(date, recovered_data, recovered_actors, recovered_color, recovered_opacity) deaths_actors = [] if (ui.deaths_check.isChecked()): add_case_actors(date, deaths_data, deaths_actors, deaths_color, deaths_opacity) for line_actor in line_actors: line_actor.VisibilityOn() ren.AddActor(line_actor) ren.AddActor(sat_actor) ren.ResetCamera() ren.SetBackground(0, 0, 0) # Initialize camera settings cam1 = ren.GetActiveCamera() cam1.Azimuth(0) cam1.Elevation(0) cam1.Roll(360) cam1.Zoom(1.5) ren.ResetCameraClippingRange() if args.camera: reader = open(args.camera, "r") line = reader.readline().split(",") cam1.SetPosition(float(line[0]), float(line[1]), float(line[2])) line = reader.readline().split(",") cam1.SetFocalPoint(float(line[0]), float(line[1]), float(line[2])) line = reader.readline().split(",") cam1.SetViewUp(float(line[0]), float(line[1]), float(line[2])) line = reader.readline().split(",") cam1.SetClippingRange(float(line[0]), float(line[1])) line = reader.readline().split(",") cam1.SetViewAngle(float(line[0])) line = reader.readline().split(",") cam1.SetParallelScale(float(line[0])) # Initialize PyQT5 UI and link to renderer ui.vtkWidget.GetRenderWindow().AddRenderer(ren) ui.vtkWidget.GetRenderWindow().SetSize(1280, 720) ui.vtkWidget.GetRenderWindow().AddRenderer(ren) ui.vtkWidget.GetRenderWindow().SetAlphaBitPlanes(True) ui.vtkWidget.GetRenderWindow().SetMultiSamples(False) iren = ui.vtkWidget.GetRenderWindow().GetInteractor() # create the scalar_bar density_scalar_bar = vtk.vtkScalarBarActor() density_scalar_bar.SetOrientationToHorizontal() density_scalar_bar.SetMaximumNumberOfColors(color_count) density_scalar_bar.SetLookupTable(density_lut) density_scalar_bar.SetTitle("Density (Log 10)") # create the scalar_bar_widget density_scalar_bar_widget = vtk.vtkScalarBarWidget() density_scalar_bar_widget.SetInteractor(iren) density_scalar_bar_widget.SetScalarBarActor(density_scalar_bar) density_scalar_bar_widget.On() # create the scalar_bar climate_scalar_bar = vtk.vtkScalarBarActor() climate_scalar_bar.SetOrientationToHorizontal() climate_scalar_bar.SetMaximumNumberOfColors(color_count) climate_scalar_bar.SetLookupTable(climate_lut) climate_scalar_bar.SetTitle("Temparature (Celsius)") # create the scalar_bar_widget climate_scalar_bar_widget = vtk.vtkScalarBarWidget() climate_scalar_bar_widget.SetInteractor(iren) climate_scalar_bar_widget.SetScalarBarActor(climate_scalar_bar) climate_scalar_bar_widget.Off() # Function to initialize slider settings def slider_setup(slider, val, bounds, interv): slider.setOrientation(QtCore.Qt.Horizontal) slider.setValue(float(val)) slider.setSliderPosition(val) slider.setTracking(False) slider.setTickInterval(interv) slider.setTickPosition(QSlider.TicksAbove) slider.setRange(bounds[0], bounds[1]) slider_setup(ui.time_slider, 0, [0, numDates], 1) window.show() window.setWindowState(Qt.WindowMaximized) iren.Initialize() def time_slider_callback(val): global max_cases global date date = val new_date = initial_date + timedelta(val) if new_date.month.real != ui.curr_month: ui.curr_month = new_date.month.real climate_max_reader.SetFileName(args.climate_max + "-" + str(ui.curr_month).zfill(2) + ".tif") climate_max_reader.Update() climate_min_reader.SetFileName(args.climate_min + "-" + str(ui.curr_month).zfill(2) + ".tif") climate_min_reader.Update() ui.date_label.setText("Date (" + new_date.strftime('%m/%d/%Y') + "):") # Remove old infections, recovered, and deaths actors remove_case_actors(infections_actors) remove_case_actors(recovered_actors) remove_case_actors(deaths_actors) remove_legend_actors() # Recompute max cases max_cases = compute_max(date) # Add infections, recovered, and deaths actors if (ui.infections_check.isChecked()): add_case_actors(date, infections_data, infections_actors, infections_color, infections_opacity) if (ui.recovered_check.isChecked()): add_case_actors(date, recovered_data, recovered_actors, recovered_color, recovered_opacity) if (ui.deaths_check.isChecked()): add_case_actors(date, deaths_data, deaths_actors, deaths_color, deaths_opacity) add_legend_actors() ui.vtkWidget.GetRenderWindow().Render() def infections_callback(): if (ui.infections_check.isChecked()): add_case_actors(date, infections_data, infections_actors, infections_color, infections_opacity) else: remove_case_actors(infections_actors) ui.vtkWidget.GetRenderWindow().Render() def recovered_callback(): if (ui.recovered_check.isChecked()): add_case_actors(date, recovered_data, recovered_actors, recovered_color, recovered_opacity) else: remove_case_actors(recovered_actors) ui.vtkWidget.GetRenderWindow().Render() def deaths_callback(): if (ui.deaths_check.isChecked()): add_case_actors(date, deaths_data, deaths_actors, deaths_color, deaths_opacity) else: remove_case_actors(deaths_actors) ui.vtkWidget.GetRenderWindow().Render() def density_callback(): if ui.density_check.isChecked(): ui.climate_max_check.setChecked(False) ui.climate_min_check.setChecked(False) density_actor.VisibilityOn() density_scalar_bar_widget.On() ui.vtkWidget.GetRenderWindow().Render() else: density_actor.VisibilityOff() density_scalar_bar_widget.Off() ui.vtkWidget.GetRenderWindow().Render() def climate_max_callback(): if ui.climate_max_check.isChecked(): ui.density_check.setChecked(False) ui.climate_min_check.setChecked(False) climate_max_actor.VisibilityOn() climate_scalar_bar_widget.On() ui.vtkWidget.GetRenderWindow().Render() else: climate_max_actor.VisibilityOff() climate_scalar_bar_widget.Off() ui.vtkWidget.GetRenderWindow().Render() def climate_min_callback(): if ui.climate_min_check.isChecked(): ui.density_check.setChecked(False) ui.climate_max_check.setChecked(False) climate_min_actor.VisibilityOn() climate_scalar_bar_widget.On() ui.vtkWidget.GetRenderWindow().Render() else: climate_min_actor.VisibilityOff() climate_scalar_bar_widget.Off() ui.vtkWidget.GetRenderWindow().Render() def migration_callback(): if ui.migration_check.isChecked(): for line_actor in line_actors: line_actor.VisibilityOn() ui.vtkWidget.GetRenderWindow().Render() else: for line_actor in line_actors: line_actor.VisibilityOff() ui.vtkWidget.GetRenderWindow().Render() # Handle screenshot button event def screenshot_callback(): save_frame(ren.GetActiveCamera(), ui.vtkWidget.GetRenderWindow(), ui.log) # Handle show camera settings button event def camera_callback(): print_camera_settings(ren.GetActiveCamera(), ui.camera_info, ui.log) # Handle quit button event def quit_callback(): sys.exit() # Register callbacks to UI ui.time_slider.valueChanged.connect(time_slider_callback) ui.push_screenshot.clicked.connect(screenshot_callback) ui.push_camera.clicked.connect(camera_callback) ui.push_quit.clicked.connect(quit_callback) ui.infections_check.stateChanged.connect(infections_callback) ui.recovered_check.stateChanged.connect(recovered_callback) ui.deaths_check.stateChanged.connect(deaths_callback) ui.density_check.stateChanged.connect(density_callback) ui.climate_max_check.stateChanged.connect(climate_max_callback) ui.climate_min_check.stateChanged.connect(climate_min_callback) ui.migration_check.stateChanged.connect(migration_callback) # Terminate setup for PyQT5 interface sys.exit(app.exec_())
def __init__(self,dti): self.print_counter=0 ren = vtk.vtkRenderer() self.dti_reader = vtk.vtkStructuredPointsReader() self.dti_reader.SetFileName(dti) """ self.geo_Mapper=vtk.vtkPolyDataMapper() self.geo_Mapper.SetInputConnection(self.dti_reader.GetOutputPort()) """ tensor_extractor = vtk.vtkExtractTensorComponents() tensor_extractor.SetInputConnection(self.dti_reader.GetOutputPort()) tensor_extractor.ExtractScalarsOn() tensor_extractor.Update() self.dti_reader.GetOutput().GetPointData().SetScalars(tensor_extractor.GetOutput().GetPointData().GetScalars()) self.dti_reader.Update() self.arrowColor = vtk.vtkColorTransferFunction() self.update_look_up_table() #------------NEW CODE BEGINS HERE---------- [xposc, yposc, zposc] = self.dti_reader.GetOutput().GetCenter() for k in range(20, 30,2): for i in range(10, 20): ren.AddActor(self.create_hyper_stream_line(xposc+i, yposc+k, zposc)) #------------NEW CODE ENDS HERE------------ #Add renderer to renderwindow and render self.renWin = vtk.vtkRenderWindow() self.renWin.AddRenderer(ren) self.renWin.SetSize(1920, 1080) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(self.renWin) iren.AddObserver('RightButtonPressEvent', self.capture_image, 1.0) # Scalar Bar actor scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(self.arrowColor) scalar_bar.SetTitle("Color map") scalar_bar.SetLabelFormat("%5.5f") scalar_bar.SetMaximumHeightInPixels(300) scalar_bar.SetMaximumWidthInPixels(100) # Scalar Bar Widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(iren) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() ren.SetBackground(0,0,0) self.renWin.Render() iren.Start()
def myMain(controller, args): fname = args.fname controller = args.controller myid = controller.GetLocalProcessId() numProcs = controller.GetNumberOfProcesses() pts = np.loadtxt(fname) sf = 100 paint = rgbPainter() r, t, z = rec2cyl(pts[:, 0], pts[:, 1], pts[:, 2]) #im=np.abs(getGeomImperfection(r,z,np.mean(r))) if pts.shape[1] == 4: im = pts[:, 3] else: im = getGeomImperfection(r, z, np.mean(r)) rid = r - im xx, yy, zz = cyl2rec(rid + im * sf, t, z) math = vtk.vtkMath() points = vtk.vtkPoints() colors = vtk.vtkUnsignedCharArray() colors.SetNumberOfComponents(3) colors.SetName("Colors") for i in range(0, pts.shape[0]): #points.InsertPoint(i,pts[i][0],pts[i][1],pts[i][2] ) points.InsertPoint(i, xx[i], yy[i], zz[i]) polydata = vtk.vtkPolyData() polydata.SetPoints(points) polydata.GetPointData().SetScalars(colors) polydata.Update() surf = vtk.vtkSurfaceReconstructionFilter() surf.SetInput(polydata) surf.SetNeighborhoodSize(40) #surf.SetSampleSpacing(6.0) if (myid != 0): controller.AddRMI(surf.Update, '', 200) controller.ProcessRMIs() else: contourFilter = vtk.vtkContourFilter() contourFilter.SetInputConnection(surf.GetOutputPort()) reverse = vtk.vtkReverseSense() reverse.SetInputConnection(contourFilter.GetOutputPort()) reverse.ReverseCellsOn() reverse.ReverseNormalsOn() reverse.Update() outputPolyData = reverse.GetOutput() #for i in range(0,pts.shape[0]): # dcolor=np.zeros(3) # colorLookupTable.GetColor(im[i],dcolor) # cc=dcolor*255.0 # colors.InsertNextTupleValue(cc) #outputPolyData.GetPointData().SetScalars(polydata.GetPointData().GetScalars() ); newSurf = transform_back(points, reverse.GetOutput()) pts2 = np.zeros((newSurf.GetNumberOfPoints(), 3)) for i in range(0, newSurf.GetNumberOfPoints()): pts2[i, :] = newSurf.GetPoint(i) r2, t2, z2 = rec2cyl(pts2[:, 0], pts2[:, 1], pts2[:, 2]) im2 = getGeomImperfection(r2, z2, np.mean(r2)) #im2-=np.min(im2) #im2=np.abs(im2) paint.setValue(np.min(im2)) paint.setValue(np.max(im2)) for i in range(0, newSurf.GetNumberOfPoints()): colors.InsertNextTupleValue(paint.getRGB(im2[i])) newSurf.GetPointData().SetScalars(colors) mapper = vtk.vtkPolyDataMapper() mapper.InterpolateScalarsBeforeMappingOn() #mapper.SetInputConnection(outputPolyData.GetProducerPort()) mapper.SetInputConnection(newSurf.GetProducerPort()) mapper.SetScalarModeToUsePointData() mapper.ScalarVisibilityOn() surfaceActor = vtk.vtkActor() surfaceActor.SetMapper(mapper) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) style = vtk.vtkInteractorStyleTrackballCamera() iren.SetInteractorStyle(style) ren.AddActor(surfaceActor) ren.SetBackground(1, 1, 1) renWin.SetSize(800, 600) prn = 1000. pc = -prn plXY = vtk.vtkPlaneSource() plXY.SetPoint1(prn, -prn, 0) plXY.SetPoint2(-prn, prn, 0) plXY.SetOrigin(pc, pc, 0) plXY.SetCenter(0, 0, 0) plXYmap = vtk.vtkPolyDataMapper() plXYmap.SetInput(plXY.GetOutput()) plXYact = vtk.vtkActor() plXYact.SetMapper(plXYmap) plXYact.GetProperty().SetOpacity(0.1) plYZ = vtk.vtkPlaneSource() plYZ.SetCenter(0, pc, pc) plYZ.SetPoint1(0, prn, -prn) plYZ.SetPoint2(0, -prn, prn) plYZmap = vtk.vtkPolyDataMapper() plYZmap.SetInput(plYZ.GetOutput()) plYZact = vtk.vtkActor() plYZact.SetMapper(plYZmap) plYZact.GetProperty().SetOpacity(0.1) plZX = vtk.vtkPlaneSource() plZX.SetCenter(pc, 0, pc) plZX.SetPoint1(prn, 0, -prn) plZX.SetPoint2(-prn, 0, prn) plZXmap = vtk.vtkPolyDataMapper() plZXmap.SetInput(plZX.GetOutput()) plZXact = vtk.vtkActor() plZXact.SetMapper(plZXmap) plZXact.GetProperty().SetOpacity(0.1) ren.AddActor(plXYact) ren.AddActor(plYZact) ren.AddActor(plZXact) ax = vtk.vtkAxesActor() ax.GetXAxisCaptionActor2D().GetProperty().SetColor(0, 0, 0) ax.GetYAxisCaptionActor2D().GetProperty().SetColor(0, 0, 0) ax.GetZAxisCaptionActor2D().GetProperty().SetColor(0, 0, 0) ow = vtk.vtkOrientationMarkerWidget() ow.SetOrientationMarker(ax) ow.SetInteractor(iren) ow.SetViewport(0.0, 0.0, 0.4, 0.4) ow.SetEnabled(1) ow.InteractiveOn() lut = vtk.vtkLookupTable() lut.SetHueRange(0.66667, 0.0) lut.SetSaturationRange(1.0, 1.0) lut.SetNumberOfColors(50) # len(self.plotables)) lut.SetTableRange(paint.getMinValue(), paint.getMaxValue()) lut.Build() scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(lut) scalar_bar.SetTitle("Imperfection value") scalar_bar.SetNumberOfLabels(11) scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(iren) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() iren.Initialize() renWin.Render() iren.Start()
def addWidgets(self,opt=None): if opt is not None: if opt.has_key('caption'): self.caption=opt['caption'] if opt.has_key('showAxes'): self.showAxes=opt['showAxes'] if opt.has_key('showCompass'): self.showCompass=opt['showCompass'] if opt.has_key('showScalarBar'): self.showScalarBar=opt['showScalarBar'] if opt.has_key('showXYPlane'): self.showXYPlane=opt['showXYPlane'] if opt.has_key('showYZPlane'): self.showYZPlane=opt['showYZPlane'] if opt.has_key('showZXPlane'): self.showZXPlane=opt['showZXPlane'] if opt.has_key('xlabel'): self.xlabel=opt['xlabel'] if opt.has_key('ylabel'): self.ylabel=opt['ylabel'] if opt.has_key('ylabel'): self.zlabel=opt['zlabel'] if opt.has_key('xrange'): self.xrange=opt['xrange'] if opt.has_key('yrange'): self.yrange=opt['yrange'] if opt.has_key('zrange'): self.zrange=opt['zrange'] prn=1000. pc=-prn plXY = vtk.vtkPlaneSource() plXY.SetPoint1(prn,-prn,0) plXY.SetPoint2(-prn,prn,0) plXY.SetOrigin(pc,pc,0) plXY.SetCenter(0,0,0) plXYmap = vtk.vtkPolyDataMapper() plXYmap.SetInput(plXY.GetOutput()) plXYact = vtk.vtkActor() plXYact.SetMapper(plXYmap) plXYact.GetProperty().SetOpacity(0.1) plYZ = vtk.vtkPlaneSource() plYZ.SetCenter(0,pc,pc) plYZ.SetPoint1(0,prn,-prn) plYZ.SetPoint2(0,-prn,prn) plYZmap = vtk.vtkPolyDataMapper() plYZmap.SetInput(plYZ.GetOutput()) plYZact = vtk.vtkActor() plYZact.SetMapper(plYZmap) plYZact.GetProperty().SetOpacity(0.1) plZX = vtk.vtkPlaneSource() plZX.SetCenter(pc,0,pc) plZX.SetPoint1(prn,0,-prn) plZX.SetPoint2(-prn,0,prn) plZXmap = vtk.vtkPolyDataMapper() plZXmap.SetInput(plZX.GetOutput()) plZXact = vtk.vtkActor() plZXact.SetMapper(plZXmap) plZXact.GetProperty().SetOpacity(0.1) ax=vtk.vtkAxesActor() ax.GetXAxisCaptionActor2D().GetProperty().SetColor(0,0,0) ax.GetYAxisCaptionActor2D().GetProperty().SetColor(0,0,0) ax.GetZAxisCaptionActor2D().GetProperty().SetColor(0,0,0) xa=vtk.vtkAxisActor() xa.SetPoint1(0,0,0) xa.SetPoint2(1000,0,0) xa.SetRange((0,1000)) xa.SetBounds(-1.0, 1000.0, -1.0, 1.0, -1.0, 1.0) self.ow=vtk.vtkOrientationMarkerWidget() textActor = vtk.vtkTextActor() textActor.GetTextProperty().SetFontSize ( 22 ) textActor.SetPosition2( 100, 100 ) textActor.SetInput(r'DESICOS VIEWER: '+str(self.caption)+r' Scaling: '+str(self.scalingFactor)) textActor.GetTextProperty().SetColor ( 0.0,0.0,0.0 ) if self.showXYPlane: self.ren.AddActor(plXYact) if self.showYZPlane: self.ren.AddActor(plYZact) if self.showZXPlane: self.ren.AddActor(plZXact) if self.showCaption: self.ren.AddActor2D( textActor ) if self.showScalarBar: self.scalar_bar = vtk.vtkScalarBarActor() self.scalar_bar.SetOrientationToHorizontal() self.scalar_bar.SetLookupTable(self.lut) self.scalar_bar.SetTitle("Imperfection value"); self.scalar_bar.SetNumberOfLabels(11) self.scalar_bar.GetProperty().SetColor ( 0.0,0.0,0.0 ) self.scalar_bar_widget = vtk.vtkScalarBarWidget() self.scalar_bar_widget.SetInteractor(self.iren) self.scalar_bar_widget.SetScalarBarActor(self.scalar_bar) self.scalar_bar_widget.On() if self.showCompass: self.ow.SetOrientationMarker(ax) self.ow.SetInteractor(self.iren) # self.ow.SetViewport( 0.0, 0.0, 0.4, 0.4 ) self.ow.SetEnabled( 1 ) self.ow.InteractiveOn() if self.showAxes: c=vtk.vtkCubeAxesActor() c.SetBounds(self.boundBox) c.SetXTitle(self.xlabel) c.SetYTitle(self.ylabel) c.SetZTitle(self.zlabel) if self.xrange is not None: c.SetXAxisRange(self.xrange) if self.yrange is not None: c.SetYAxisRange(self.yrange) if self.zrange is not None: c.SetZAxisRange(self.zrange) c.GetProperty().SetColor(0., 0., 0.) c.SetCamera(self.ren.GetActiveCamera()) self.ren.AddActor(c)
def draw_vtk(nodes, elements, values=None, colors_count=256, contours_count=10, use_gray=False, title=None, background=(0.95, 0.95, 0.95), show_mesh=False, mesh_color=(0.25, 0.25, 0.25), use_cell_data=False, show_labels=False, show_axes=False): """ Function draws planar unstructured mesh using vtk :param show_axes: if it equals true than axes is drawn :param use_cell_data: if it equals true than cell data is used to colorize zones :param show_labels: if it equals true than labels are shown :param show_mesh: if it equals true than mesh lines are shown :param mesh_color: color of mesh lines (polygons edges) :param contours_count: Contour lines count :param title: Title of the scalar bar :param background: Background RGB-color value :param use_gray: if it equals true than gray-scale colormap is used :param colors_count: Colors count for values visualization :param nodes: nodes array [nodes_count; 2] :param elements: elements array [elements_count; element_nodes] :param values: values array (coloring rule) :return: nothing """ import vtk points = vtk.vtkPoints() for n in nodes: if len(n) == 2: points.InsertNextPoint([n[0], n[1], 0.0]) elif len(n) == 3: points.InsertNextPoint([n[0], n[1], n[2]]) cells_array = vtk.vtkCellArray() for el in elements: polygon = vtk.vtkPolygon() polygon.GetPointIds().SetNumberOfIds(len(el)) for i in range(len(el)): polygon.GetPointIds().SetId(i, el[i]) cells_array.InsertNextCell(polygon) lut = vtk.vtkLookupTable() lut.SetNumberOfTableValues(colors_count) lut.SetHueRange(0.66667, 0.0) if use_gray: lut.SetValueRange(1.0, 0.0) lut.SetSaturationRange(0.0, 0.0) # no color saturation lut.SetRampToLinear() lut.Build() renderer = vtk.vtkRenderer() renderer.SetBackground(background) render_window = vtk.vtkRenderWindow() render_window.AddRenderer(renderer) render_window_interactor = vtk.vtkRenderWindowInteractor() render_window_interactor.SetRenderWindow(render_window) bcf_actor = vtk.vtkActor() bcf_mapper = vtk.vtkPolyDataMapper() poly_data = vtk.vtkPolyData() poly_data.SetPoints(points) poly_data.SetPolys(cells_array) if values is not None: scalars = vtk.vtkFloatArray() for v in values: scalars.InsertNextValue(v) poly_data.GetPointData().SetScalars(scalars) bcf = vtk.vtkBandedPolyDataContourFilter() if vtk.VTK_MAJOR_VERSION <= 5: bcf.SetInput(poly_data) else: bcf.SetInputData(poly_data) if contours_count > 0: bcf.SetNumberOfContours(contours_count) bcf.GenerateValues(contours_count, [values.min(), values.max()]) bcf.SetNumberOfContours(contours_count + 1) bcf.GenerateContourEdgesOn() bcf.Update() bcf_mapper.ImmediateModeRenderingOn() if vtk.VTK_MAJOR_VERSION <= 5: bcf_mapper.SetInput(bcf.GetOutput()) else: bcf_mapper.SetInputData(bcf.GetOutput()) bcf_mapper.SetScalarRange(values.min(), values.max()) bcf_mapper.SetLookupTable(lut) bcf_mapper.ScalarVisibilityOn() if use_cell_data: bcf_mapper.SetScalarModeToUseCellData() bcf_actor.SetMapper(bcf_mapper) renderer.AddActor(bcf_actor) edge_mapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: edge_mapper.SetInput(bcf.GetContourEdgesOutput()) else: edge_mapper.SetInputData(bcf.GetContourEdgesOutput()) edge_mapper.SetResolveCoincidentTopologyToPolygonOffset() edge_actor = vtk.vtkActor() edge_actor.SetMapper(edge_mapper) if use_gray: edge_actor.GetProperty().SetColor(0.0, 1.0, 0.0) else: edge_actor.GetProperty().SetColor(0.0, 0.0, 0.0) renderer.AddActor(edge_actor) if show_labels: mask = vtk.vtkMaskPoints() if vtk.VTK_MAJOR_VERSION <= 5: mask.SetInput(bcf.GetOutput()) else: mask.SetInputData(bcf.GetOutput()) mask.SetOnRatio(bcf.GetOutput().GetNumberOfPoints() / 20) mask.SetMaximumNumberOfPoints(20) # Create labels for points - only show visible points visible_points = vtk.vtkSelectVisiblePoints() visible_points.SetInputConnection(mask.GetOutputPort()) visible_points.SetRenderer(renderer) ldm = vtk.vtkLabeledDataMapper() ldm.SetInputConnection(mask.GetOutputPort()) ldm.SetLabelFormat("%.2E") ldm.SetLabelModeToLabelScalars() text_property = ldm.GetLabelTextProperty() text_property.SetFontFamilyToArial() text_property.SetFontSize(10) if use_gray: text_property.SetColor(0.0, 1.0, 0.0) else: text_property.SetColor(0.0, 0.0, 0.0) text_property.ShadowOff() text_property.BoldOff() contour_labels = vtk.vtkActor2D() contour_labels.SetMapper(ldm) renderer.AddActor(contour_labels) scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(lut) if title is not None: scalar_bar.SetTitle(title) scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(render_window_interactor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() else: if vtk.VTK_MAJOR_VERSION <= 5: bcf_mapper.SetInput(poly_data) else: bcf_mapper.SetInputData(poly_data) bcf_actor.GetProperty().SetColor(0.0, 1.0, 0.0) if show_mesh: bcf_actor.GetProperty().EdgeVisibilityOn() bcf_actor.GetProperty().SetEdgeColor(mesh_color) bcf_actor.SetMapper(bcf_mapper) renderer.AddActor(bcf_actor) if show_axes: axes = vtk.vtkAxesActor() renderer.AddActor(axes) render_window.Render() render_window_interactor.Start()
def add_widgets(self): # axes axes = vtk.vtkAxesActor() self.marker_widget = vtk.vtkOrientationMarkerWidget() self.marker_widget.SetInteractor(self.iren) self.marker_widget.SetOrientationMarker(axes) self.marker_widget.SetViewport(0.0, 0.0, 0.25, 0.25) # scalar bar self.scalarbar_actor = vtk.vtkScalarBarActor() self.scalarbar_actor.SetLookupTable(self.lut) self.scalarbar_widget = vtk.vtkScalarBarWidget() self.scalarbar_widget.SetInteractor(self.iren) self.scalarbar_widget.SetScalarBarActor(self.scalarbar_actor) # contour slider self.slider_rep = vtk.vtkSliderRepresentation2D() self.slider_rep.SetTitleText("contour") self.slider_rep.GetPoint1Coordinate().SetCoordinateSystemToNormalizedViewport() self.slider_rep.GetPoint1Coordinate().SetValue(0.65, 0.1) self.slider_rep.GetPoint2Coordinate().SetCoordinateSystemToNormalizedViewport() self.slider_rep.GetPoint2Coordinate().SetValue(0.95, 0.1) self.slider_widget = vtk.vtkSliderWidget() self.slider_widget.SetInteractor(self.iren) self.slider_widget.SetRepresentation(self.slider_rep) self.slider_widget.SetAnimationModeToAnimate() self.slider_widget.AddObserver(vtk.vtkCommand.InteractionEvent, self.update_contour);
def __init__(self,delta,wing): self.arrowColor = vtk.vtkColorTransferFunction() self.update_look_up_table() self.print_counter=0 self.ren = vtk.vtkRenderer() self.geo_reader = vtk.vtkUnstructuredGridReader() self.geo_reader.SetFileName(wing) self.vec_reader = vtk.vtkStructuredPointsReader() self.vec_reader.SetFileName(delta) """ This is for drawing the wing,""" geo_Mapper=vtk.vtkDataSetMapper() geo_Mapper.SetInputConnection(self.geo_reader.GetOutputPort()) geo_actor = vtk.vtkActor() geo_actor.SetMapper(geo_Mapper) self.ren.AddActor(geo_actor) """End of adding the wing """ self.ren.AddActor(self.create_stream_line(25,150,0,0.5)) #Add renderer to renderwindow and render self.renWin = vtk.vtkRenderWindow() self.renWin.AddRenderer(self.ren) self.renWin.SetSize(1920, 1080) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(self.renWin) iren.AddObserver('RightButtonPressEvent', self.capture_image, 1.0) # Scalar Bar actor scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(self.arrowColor) scalar_bar.SetTitle("Color map") scalar_bar.SetLabelFormat("%5.2f") scalar_bar.SetMaximumHeightInPixels(300) scalar_bar.SetMaximumWidthInPixels(60) # Scalar Bar Widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(iren) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() self.ren.SetBackground(0,0,0) self.renWin.Render() iren.Start()
def render( data, height ): """ Assume 3D data array with integer-valued input. """ # For VTK to be able to use the data, it must be stored as a # VTK-image. This can be done by the vtkImageImport-class which # imports raw data and stores it. dataImporter = vtk.vtkImageImport() # The previously created array is converted to a string of chars and imported. data_string = data.tostring() dataImporter.CopyImportVoidPointer(data_string, len(data_string)) # The type of the newly imported data is set to unsigned char (uint8) dataImporter.SetDataScalarTypeToUnsignedChar() # Because the data that is imported only contains an intensity # value (it isnt RGB-coded or someting similar), the importer must # be told this is the case. dataImporter.SetNumberOfScalarComponents(1) # The following two functions describe how the data is stored and # the dimensions of the array it is stored in. For this simple # case, all axes are of length 75 and begins with the first # element. For other data, this is probably not the case. I have # to admit however, that I honestly dont know the difference # between SetDataExtent() and SetWholeExtent() although VTK # complains if not both are used. nz, ny, nx = data.shape dataImporter.SetDataExtent(0, nx-1, 0, ny-1, 0, nz-1) dataImporter.SetWholeExtent(0, nx-1, 0, ny-1, 0, nz-1) # The following class is used to store transparencyv-values for # later retrival. In our case, we want the value 0 to be completly # opaque whereas the three different cubes are given different # transperancy-values to show how it works. alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(0, 0.0) alphaChannelFunc.AddPoint(255, 0.0) # alphaChannelFunc.AddPoint(dataAvg, 0.1) # alphaChannelFunc.AddPoint(dataMax, 0.2) # This class stores color data and can create color tables from a # the intensity values. lut = vtk.vtkLookupTable() lut.Build() lutNum = data.max() lut.SetNumberOfTableValues(lutNum) ctf = vtk.vtkColorTransferFunction() ctf.SetColorSpaceToDiverging() ctf.AddRGBPoint(0.0, 0, 0, 1.0) ctf.AddRGBPoint(data.max(), 1.0, 0, 0 ) # Conversion to RGB tuples based on intensity values -- coarsen # the number of height values to only 256 for ii,ss in enumerate([float(xx)/float(lutNum) for xx in range(lutNum)]): cc = ctf.GetColor( ss ) lut.SetTableValue(ii,cc[0],cc[1],cc[2],1.0) # The preavius two classes stored properties. Because we want to # apply these properties to the volume we want to render, we have # to store them in a class that stores volume properties. volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor( ctf ) #colorFunc) volumeProperty.SetScalarOpacity(alphaChannelFunc) # This class describes how the volume is rendered (through ray tracing). compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() # We can finally create our volume. We also have to specify the # data for it, as well as how the data will be rendered. volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetInputConnection(dataImporter.GetOutputPort()) # The class vtkVolume is used to pair the preaviusly declared # volume as well as the properties to be used when rendering that # volume. volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) #create a plane to cut,here it cuts in the XZ direction (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0) # plane=vtk.vtkPlane() # plane.SetOrigin(0,100,100) # plane.SetNormal(1,0,0) # #create cutter # cutter=vtk.vtkCutter() # cutter.SetCutFunction(plane) # cutter.SetInputConnection(dataImporter.GetOutputPort()) # cutter.Update() # cutterMapper=vtk.vtkPolyDataMapper() # cutterMapper.SetInputConnection( cutter.GetOutputPort()) # #create plane actor # planeActor=vtk.vtkActor() # planeActor.GetProperty().SetColor(1.0,1,0) # planeActor.GetProperty().SetLineWidth(2) # planeActor.SetMapper(cutterMapper) #create cube actor # cubeActor=vtk.vtkActor() # cubeActor.GetProperty().SetColor(0.5,1,0.5) # cubeActor.GetProperty().SetOpacity(0.5) # cubeActor.SetMapper(cubeMapper) # With almost everything else ready, its time to initialize the # renderer and window, as well as creating a method for exiting # the application renderer = vtk.vtkRenderer() #renderer.AddActor( planeActor ) renderWin = vtk.vtkRenderWindow() renderWin.AddRenderer(renderer) renderInteractor = vtk.vtkRenderWindowInteractor() renderInteractor.SetRenderWindow(renderWin) # We add the volume to the renderer ... renderer.AddVolume(volume) # ... set background color to white ... renderer.SetBackground(0,0,0) # ... and set window size. renderWin.SetSize(600, 600) # add a scalar color bar sb = vtk.vtkScalarBarActor() sb.SetTitle("Elevation") # If the orientation is vertical there is a problem. sb.SetOrientationToHorizontal() # Vertical is OK. # sb.SetOrientationToVertical() sb.SetWidth(0.6) sb.SetHeight(0.17) sb.SetPosition(0.1, 0.05) sb.SetLookupTable(ctf) sbw = vtk.vtkScalarBarWidget() sbw.SetInteractor(renderInteractor) sbw.SetScalarBarActor(sb) sbw.On() # A simple function to be called when the user decides to quit the application. def exitCheck(obj, event): if obj.GetEventPending() != 0: obj.SetAbortRender(1) # Tell the application to use the function as an exit check. renderWin.AddObserver("AbortCheckEvent", exitCheck) renderInteractor.Initialize() # Because nothing will be rendered without any input, we order the # first render manually before control is handed over to the # main-loop. renderWin.Render() renderInteractor.Start() # write a PNG image to disk writer = vtk.vtkPNGWriter() writer.SetFileName("rbc_stackVTK_height_"+str(height)+".png") writer.SetInput(dataImporter.GetOutput()) writer.Write()
mapper.SetLookupTable(lut) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderer.AddActor(actor) renderer.SetBackground(0.1, 0.2, 0.4) render_window = vtk.vtkRenderWindow() render_window.AddRenderer(renderer) render_window.SetSize(300, 300) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(render_window) # create the scalar_bar scalar_bar = vtk.vtkScalarBarActor() scalar_bar.SetOrientationToHorizontal() scalar_bar.SetLookupTable(lut) # create the scalar_bar_widget scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(interactor) scalar_bar_widget.SetScalarBarActor(scalar_bar) scalar_bar_widget.On() interactor.Initialize() render_window.Render() interactor.Start()