def vtkRenderWindowInteractorConeExample(): """Like it says, just a simple example """ # create root window root = Tkinter.Tk() # create vtkTkRenderWidget pane = vtkTkRenderWindowInteractor(root, width=300, height=300) pane.Initialize() def quit(obj=root): obj.quit() pane.AddObserver("ExitEvent", lambda o,e,q=quit: q()) ren = vtk.vtkRenderer() pane.GetRenderWindow().AddRenderer(ren) cone = vtk.vtkConeSource() cone.SetResolution(8) coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInput(cone.GetOutput()) coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) ren.AddActor(coneActor) # pack the pane into the tk root pane.pack(fill='both', expand=1) pane.Start() # start the tk mainloop root.mainloop()
def __init__(self, interactor): self.interactor = interactor self.window = interactor.GetRenderWindow() self.renderer = vtk.vtkRenderer() self.renderer.SetViewport(0, 0, 1, 1) self.renderer.SetBackground(1, 1, 1) # Used to overlay actors above widgets self.actor_renderer = vtk.vtkRenderer() self.actor_renderer.SetViewport(0, 0, 1, 1) self.actor_renderer.SetBackground(1, 1, 1) self.window.AddRenderer(self.renderer) self.window.AddRenderer(self.actor_renderer) self.widgets = [] self.timer_listener = self.interactor.AddObserver( "TimerEvent", self.__render) self.window_mod = self.window.AddObserver( "ModifiedEvent", self.__place, 30) self.render_listener = self.window.AddObserver( "RenderEvent", self.__rendered) self.last_size = None self.timer = None
def create_slice_window(self): renderer = vtk.vtkRenderer() renderer.SetLayer(0) cam = renderer.GetActiveCamera() overlay_renderer = vtk.vtkRenderer() overlay_renderer.SetLayer(1) overlay_renderer.SetActiveCamera(cam) overlay_renderer.SetInteractive(0) self.interactor.GetRenderWindow().SetNumberOfLayers(2) self.interactor.GetRenderWindow().AddRenderer(overlay_renderer) self.interactor.GetRenderWindow().AddRenderer(renderer) actor = vtk.vtkImageActor() # TODO: Create a option to let the user set if he wants to interpolate # the slice images. #actor.InterpolateOff() slice_data = sd.SliceData() slice_data.SetOrientation(self.orientation) slice_data.renderer = renderer slice_data.overlay_renderer = overlay_renderer slice_data.actor = actor slice_data.SetBorderStyle(sd.BORDER_ALL) renderer.AddActor(actor) renderer.AddActor(slice_data.text.actor) renderer.AddViewProp(slice_data.box_actor) return slice_data
def Render(self): self.Viewport1 = [0.0, 0.0, 0.5, 0.5] self.Viewport2 = [0.5, 0.0, 1.0, 0.5] self.Viewport3 = [0.0, 0.5, 0.5, 1.0] self.Viewport4 = [0.5, 0.5, 1.0, 1.0] self.Renderer1 = vtk.vtkRenderer() self.Renderer2 = vtk.vtkRenderer() self.Renderer3 = vtk.vtkRenderer() self.Renderer4 = vtk.vtkRenderer() self.renderWindow.AddRenderer(self.Renderer1) self.Renderer1.SetViewport(self.Viewport1) self.Renderer1.SetBackground(0.6, 0.5, 0.3) self.renderWindow.AddRenderer(self.Renderer2) self.Renderer2.SetViewport(self.Viewport2) self.Renderer2.SetBackground(0.5, 0.5, 0.4) self.renderWindow.AddRenderer(self.Renderer3) self.Renderer3.SetViewport(self.Viewport3) self.Renderer3.SetBackground(0.4, 0.5, 0.5) self.renderWindow.AddRenderer(self.Renderer4) self.Renderer4.SetViewport(self.Viewport4) self.Renderer4.SetBackground(0.0, 0.5, 0.6) self.Renderer1.AddActor(self.inputActor1) self.Renderer2.AddActor(self.inputActor2) self.Renderer3.AddActor(self.inputActor3) self.Renderer4.AddActor(self.inputActor4) self.camera = vtk.vtkCamera() self.Renderer1.SetActiveCamera(self.camera) self.Renderer2.SetActiveCamera(self.camera) self.Renderer3.SetActiveCamera(self.camera) self.Renderer4.SetActiveCamera(self.camera) self.Renderer1.ResetCamera() self.renderWindow.Render() self.interactor.Start()
def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_Form() self.ui.setupUi(self) self.reader = vtk.vtkDICOMImageReader() #self.viewerL = vtk.vtkImageViewer2() #self.viewerR = vtk.vtkImageViewer2() self.renL = vtk.vtkRenderer() self.ui.leftVtk.GetRenderWindow().AddRenderer(self.renL) self.renR = vtk.vtkRenderer() self.ui.rightVtk.GetRenderWindow().AddRenderer(self.renR) self.mapperL = vtk.vtkImageMapper() self.mapperL.SetInputConnection(self.reader.GetOutputPort()) self.mapperR = vtk.vtkImageMapper() self.actorL = vtk.vtkActor2D() self.actorL.SetMapper(self.mapperL) self.actorR = vtk.vtkActor2D() self.actorR.SetMapper(self.mapperR) self.renL.AddActor2D(self.actorL) self.renR.AddActor2D(self.actorR) self.importer = vtk.vtkImageImport() self.mapperR.SetInputConnection(self.importer.GetOutputPort()) self.loadImage(os.path.join(STARTINGPATH, FILENAME)) self.setWindowingAlg()
def __init__(self): super(RenderWidget, self).__init__() # Default volume renderer self.renderer = vtkRenderer() self.renderer.SetBackground2(0.4, 0.4, 0.4) self.renderer.SetBackground(0.1, 0.1, 0.1) self.renderer.SetGradientBackground(True) self.renderer.SetLayer(0) # Overlay renderer which is synced with the default renderer self.rendererOverlay = vtkRenderer() self.rendererOverlay.SetLayer(1) self.rendererOverlay.SetInteractive(0) self.renderer.GetActiveCamera().AddObserver("ModifiedEvent", self._syncCameras) self.rwi = QVTKRenderWindowInteractor(parent=self) self.rwi.SetInteractorStyle(vtkInteractorStyleTrackballCamera()) self.rwi.GetRenderWindow().AddRenderer(self.renderer) self.rwi.GetRenderWindow().AddRenderer(self.rendererOverlay) self.rwi.GetRenderWindow().SetNumberOfLayers(2) self.rwi.SetDesiredUpdateRate(0) self.imagePlaneWidgets = [vtkImagePlaneWidget() for i in range(3)] for index in range(3): self.imagePlaneWidgets[index].DisplayTextOn() self.imagePlaneWidgets[index].SetInteractor(self.rwi) # Disable the margin for free rotation self.imagePlaneWidgets[index].SetMarginSizeX(0.0) self.imagePlaneWidgets[index].SetMarginSizeY(0.0) self.mapper = vtkOpenGLGPUVolumeRayCastMapper() self.mapper.SetAutoAdjustSampleDistances(1) self.volume = None self.imageData = None self.VolumeVisualization = None self.shouldResetCamera = False self.gridItems = [] self.orientationGridItems = [] self.clippingBox = ClippingBox() self.clippingBox.setWidget(self) # Keep track of the base and user transforms self.baseTransform = vtkTransform() self.userTransform = vtkTransform() self.setMinimumWidth(340) self.setMinimumHeight(340) layout = QGridLayout(self) layout.setSpacing(0) layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(self.rwi, 0, 0) self.setLayout(layout)
def __init__(self, parent=None): QtGui.QMainWindow.__init__(self, parent) self.frame = QtGui.QFrame() self.vl = QtGui.QGridLayout() self.vtkWidget_right_femur = QVTKRenderWindowInteractor(self.frame) self.vtkWidget_right_hip = QVTKRenderWindowInteractor(self.frame) self.vtkWidget_left_femur = QVTKRenderWindowInteractor(self.frame) self.vtkWidget_left_hip = QVTKRenderWindowInteractor(self.frame) title_right_femur = QtGui.QLabel('Femur derecho') title_right_hip = QtGui.QLabel('Cadera derecha') title_left_femur = QtGui.QLabel('Femur izquierdo') title_left_hip = QtGui.QLabel('Cadera izquierda') self.vl.addWidget(title_right_femur, 0, 0) self.vl.addWidget(self.vtkWidget_right_femur, 1, 0) self.vl.addWidget(title_right_hip, 0, 1) self.vl.addWidget(self.vtkWidget_right_hip, 1, 1) self.vl.addWidget(title_left_femur, 2, 0) self.vl.addWidget(self.vtkWidget_left_femur, 3, 0) self.vl.addWidget(title_left_hip, 2, 1) self.vl.addWidget(self.vtkWidget_left_hip, 3, 1) self.ren_right_femur = vtk.vtkRenderer() self.ren_right_hip = vtk.vtkRenderer() self.ren_left_femur = vtk.vtkRenderer() self.ren_left_hip = vtk.vtkRenderer() self.vtkWidget_right_femur.GetRenderWindow().AddRenderer(self.ren_right_femur) self.vtkWidget_right_hip.GetRenderWindow().AddRenderer(self.ren_right_hip) self.vtkWidget_left_femur.GetRenderWindow().AddRenderer(self.ren_left_femur) self.vtkWidget_left_hip.GetRenderWindow().AddRenderer(self.ren_left_hip) self.iren_right_femur = self.vtkWidget_right_femur.GetRenderWindow().GetInteractor() self.iren_right_hip = self.vtkWidget_right_hip.GetRenderWindow().GetInteractor() self.iren_left_femur = self.vtkWidget_left_femur.GetRenderWindow().GetInteractor() self.iren_left_hip = self.vtkWidget_left_hip.GetRenderWindow().GetInteractor() openFile = QtGui.QAction(QtGui.QIcon('open.png'), 'Open', self) openFile.setShortcut('Ctrl+O') openFile.setStatusTip('Open new File') openFile.triggered.connect(self.show_dialog) menubar = self.menuBar() fileMenu = menubar.addMenu('&File') fileMenu.addAction(openFile) self.image_processing = ImageProcessing() self.frame.setLayout(self.vl) self.setCentralWidget(self.frame) self.setGeometry(50, 50, 1200, 800) self.show()
def renderers(window, rows=1, cols=1): renderer = vtk.vtkRenderer() rows = np.linspace(0,1,rows+1) cols = np.linspace(0,1,cols+1) rows, cols = np.meshgrid(rows, cols) renderers = [] for r, c in zip(range(rows.shape[0]-1), range(cols.shape[1]-1)): viewport = rows[r, r], cols[c, c], rows[r+1, r+1], cols[c+1, c+1] renderers.append(vtk.vtkRenderer()) window.AddRenderer(renderers[-1]) renderers[-1].SetViewport(viewport) renderers[-1].SetBackground(1., 1., 1.) return renderers
def clean_gui(self): self.ren_right_femur = vtk.vtkRenderer() self.ren_right_hip = vtk.vtkRenderer() self.ren_left_femur = vtk.vtkRenderer() self.ren_left_hip = vtk.vtkRenderer() self.vtkWidget_right_femur.GetRenderWindow().AddRenderer(self.ren_right_femur) self.vtkWidget_right_hip.GetRenderWindow().AddRenderer(self.ren_right_hip) self.vtkWidget_left_femur.GetRenderWindow().AddRenderer(self.ren_left_femur) self.vtkWidget_left_hip.GetRenderWindow().AddRenderer(self.ren_left_hip) self.iren_right_femur = self.vtkWidget_right_femur.GetRenderWindow().GetInteractor() self.iren_right_hip = self.vtkWidget_right_hip.GetRenderWindow().GetInteractor() self.iren_left_femur = self.vtkWidget_left_femur.GetRenderWindow().GetInteractor() self.iren_left_hip = self.vtkWidget_left_hip.GetRenderWindow().GetInteractor()
def build_vtk_renderer(self): # offscreen rendering if (vtk.vtkVersion().GetVTKMajorVersion() == 5.0): graphics_factory = vtk.vtkGraphicsFactory() graphics_factory.SetOffScreenOnlyMode( 1); graphics_factory.SetUseMesaClasses( 1 ); imaging_factory = vtk.vtkImagingFactory() imaging_factory.SetUseMesaClasses( 1 ); self.renderer = vtk.vtkRenderer() self.renderer.SetBackground(1, 1, 1) self.render_window = vtk.vtkRenderWindow() # offscreen rendering self.render_window.SetOffScreenRendering(1) self.render_window.AddRenderer(self.renderer) # create a renderwindowinteractor #if self.interact: #self.iren = vtk.vtkRenderWindowInteractor() #self.iren.SetRenderWindow(self.render_window) # scalar bar self.scalarbar = vtk.vtkScalarBarActor() # To avoid uninitialized warning in VTK 6 self.scalarbar.SetTitle("") # black text since background is white for printing self.scalarbar.GetLabelTextProperty().SetColor(0, 0, 0) self.scalarbar.GetTitleTextProperty().SetColor(0, 0, 0)
def plotvtk(mesh,boundary): meshMapper = vtk.vtkPolyDataMapper() meshMapper.SetInputConnection(mesh.GetOutputPort()) meshActor = vtk.vtkActor() meshActor.SetMapper(meshMapper) meshActor.GetProperty().SetEdgeColor(0, 0, 1) meshActor.GetProperty().SetInterpolationToFlat() meshActor.GetProperty().SetRepresentationToWireframe() boundaryMapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: boundaryMapper.SetInputConnection(boundary.GetProducerPort()) else: boundaryMapper.SetInputData(boundary) boundaryActor = vtk.vtkActor() boundaryActor.SetMapper(boundaryMapper) boundaryActor.GetProperty().SetColor(1, 0, 0) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(meshActor) renderer.AddActor(boundaryActor) renderer.SetBackground(.3, .6, .3) renderWindowInteractor.Initialize() renderWindow.Render() renderWindowInteractor.Start()
def testFixedPointRayCasterLinearCropped(self): ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() iRen = vtk.vtkRenderWindowInteractor() tFPRCN = TestFixedPointRayCasterNearest.FixedPointRayCasterNearest(ren, renWin, iRen) volumeProperty = tFPRCN.GetVolumeProperty() volumeMapper = tFPRCN.GetVolumeMapper() for j in range(0, 5): for i in range(0, 5): volumeMapper[i][j].SetCroppingRegionPlanes(10, 20, 10, 20, 10, 20) volumeMapper[i][j].SetCroppingRegionFlags(253440) volumeMapper[i][j].CroppingOn() volumeProperty[i][j].SetInterpolationTypeToLinear() # render and interact with data renWin.Render() img_file = "TestFixedPointRayCasterLinearCropped.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=10) vtk.test.Testing.interact()
def __init__(self): GtkGLExtVTKRenderWindowInteractor.__init__(self) EventHandler().attach(self) self.interactButtons = (1,2,3) self.renderOn = 1 self.Initialize() self.Start() self.renderer = vtk.vtkRenderer() self.renWin = self.GetRenderWindow() self.renWin.AddRenderer(self.renderer) self.interactor = self.renWin.GetInteractor() #self.camera = self.renderer.GetActiveCamera() self.pressFuncs = {1 : self._Iren.LeftButtonPressEvent, 2 : self._Iren.MiddleButtonPressEvent, 3 : self._Iren.RightButtonPressEvent} self.releaseFuncs = {1 : self._Iren.LeftButtonReleaseEvent, 2 : self._Iren.MiddleButtonReleaseEvent, 3 : self._Iren.RightButtonReleaseEvent} self.pressHooks = {} self.releaseHooks = {} self.lastLabel = None self.vtk_interact_mode = False
def main(): '''One render window, multiple viewports''' iren_list = [] rw = vtk.vtkRenderWindow() iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(rw) # Define viewport ranges xmins=[0,.5,0,.5] xmaxs=[0.5,1,0.5,1] ymins=[0,0,.5,.5] ymaxs=[0.5,0.5,1,1] for i in range(4): ren = vtk.vtkRenderer() rw.AddRenderer(ren) ren.SetViewport(xmins[i],ymins[i],xmaxs[i],ymaxs[i]) #Create a sphere sphereSource = vtk.vtkSphereSource() sphereSource.SetCenter(0.0, 0.0, 0.0) sphereSource.SetRadius(5) #Create a mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphereSource.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) ren.AddActor(actor) ren.ResetCamera() rw.Render() rw.SetWindowName('RW: Multiple ViewPorts') iren.Start()
def QVTKRenderWidgetConeExample(): """A simple example that uses the QVTKRenderWindowInteractor class. """ # every QT app needs an app app = qt.QApplication(['QVTKRenderWindowInteractor']) # create the widget widget = QVTKRenderWindowInteractor() widget.Initialize() widget.Start() # if you dont want the 'q' key to exit comment this. widget.AddObserver("ExitEvent", lambda o, e, a=app: a.quit()) ren = vtk.vtkRenderer() widget.GetRenderWindow().AddRenderer(ren) cone = vtk.vtkConeSource() cone.SetResolution(8) coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInputConnection(cone.GetOutputPort()) coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) ren.AddActor(coneActor) # show the widget widget.show() # close the application when window is closed app.setMainWidget(widget) # start event processing app.exec_loop()
def testStyleJoystickActor(self): ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) testStyleBaseSpike = TestStyleBaseSpike.StyleBaseSpike(ren, renWin, iRen) # Set interactor style inStyle = vtk.vtkInteractorStyleSwitch() iRen.SetInteractorStyle(inStyle) # Switch to Joystick+Actor mode iRen.SetKeyEventInformation(0, 0, "j", 0) iRen.InvokeEvent("CharEvent") iRen.SetKeyEventInformation(0, 0, "a", 0) iRen.InvokeEvent("CharEvent") # Test style testStyleBase = TestStyleBase.TestStyleBase(ren) testStyleBase.test_style(inStyle.GetCurrentStyle()) # render and interact with data img_file = "TestStyleJoystickActor.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def initialize(self, VTKWebApp, args): if not VTKWebApp.view: # VTK specific code renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderWindowInteractor.GetInteractorStyle().SetCurrentStyleToTrackballCamera() cone = vtk.vtkConeSource() mapper = vtk.vtkPolyDataMapper() actor = vtk.vtkActor() mapper.SetInputConnection(cone.GetOutputPort()) actor.SetMapper(mapper) renderer.AddActor(actor) renderer.ResetCamera() renderWindow.Render() # VTK Web application specific VTKWebApp.view = renderWindow self.Application.GetObjectIdMap().SetActiveObject("VIEW", renderWindow)
def __init__(self, file_list,spacing_list,feature_type,irad = 1.2, h_th=-200, glyph_type='sphere', glyph_scale_factor=1,use_field_data=True, opacity_list=[], color_list=[], lung=[]): assert feature_type == "ridge_line" or feature_type == "valley_line" \ or feature_type == "ridge_surface" or feature_type == "valley_surface" \ or feature_type == "vessel" or feature_type == "airway" \ or feature_type == "fissure", "Invalid feature type" if feature_type == "airway": feature_type = "valley_line" elif feature_type == "vessel": feature_type = "ridge_line" elif feature_type == "fissure": feature_type = "ridge_surface" self.mapper_list = list() self.actor_list = list() self.glyph_list = list() self.glyph_type = glyph_type self.file_list = file_list self.spacing_list = spacing_list self.opacity_list = opacity_list self.irad = irad self.h_th = h_th self.color_list = color_list self.lung = lung self.use_field_data = use_field_data self.feature_type = feature_type self.normal_map=dict() self.normal_map['ridge_line'] = "hevec0" self.normal_map['valley_line'] = "hevec2" self.normal_map['ridge_surface'] = "hevec2" self.normal_map['valley_surface'] = "hevec0" self.strength_map=dict() self.strength_map['ridge_line'] = "h1" self.strength_map['valley_line'] = "h1" self.strength_map['ridge_surface'] = "h2" self.strength_map['valley_surface'] = "h0" if feature_type == 'ridge_line' or feature_type == 'valley_line': self.height = irad self.radius = 0.5 elif feature_type == 'ridge_surface' or feature_type == 'valley_surface': self.height = 0.5 self.radius = irad self.min_rad = 0.5 self.max_rad = 6 self.glyph_scale_factor = glyph_scale_factor self.capture_prefix = "" self.capture_count = 1 # VTK Objects self.ren = vtk.vtkRenderer() self.renWin = vtk.vtkRenderWindow() self.iren = vtk.vtkRenderWindowInteractor() self.image_count = 1
def __init__(self, volume): super(InteractiveIsosurface, self).__init__() self._default_size = (600, 600) self.resize(*self._default_size) #self._volume = numpy.ascontiguousarray(volume, dtype="float32") self._surface_object = IsoSurface(volume) self._central_widget = QtGui.QWidget(self) self._vtk_widget = QVTKRenderWindowInteractor(self._central_widget) self._vtk_widget.SetInteractorStyle(_vtk.vtkInteractorStyleRubberBandPick()) self._renderer = _vtk.vtkRenderer() self._renderer.SetBackground(0., 0., 0.) self._surface_object.set_renderer(self._renderer) self._THRESHOLD_SLIDER_MAXIMUM = 1000 self._THRESHOLD_SLIDER_INIT = self._THRESHOLD_SLIDER_MAXIMUM/2 self._threshold_table = self._adaptive_slider_values(volume, self._THRESHOLD_SLIDER_MAXIMUM, volume.min(), volume.max()) self._threshold_slider = QtGui.QSlider(QtCore.Qt.Horizontal) self._threshold_slider.setMaximum(self._THRESHOLD_SLIDER_MAXIMUM) self._layout = QtGui.QVBoxLayout() self._layout.addWidget(self._vtk_widget) self._layout.addWidget(self._threshold_slider) self._central_widget.setLayout(self._layout) self.setCentralWidget(self._central_widget)
def view(stlfilename): reader = vtk.vtkSTLReader() reader.SetFileName(stlfilename) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(reader.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) # Create a rendering window and renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # Create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Assign actor to the renderer ren.AddActor(actor) # Enable user interface interactor iren.Initialize() renWin.Render() iren.Start()
def __init__(self, input=None, MinOpacity=0.0, MaxOpacity=0.1) : import qt import vtk from vtk.qt.QVTKRenderWindowInteractor import QVTKRenderWindowInteractor self.__MinOpacity__ = MinOpacity self.__MaxOpacity__ = MaxOpacity # every QT app needs an app self.__app__ = qt.QApplication(['itkviewer']) # create the widget self.__widget__ = QVTKRenderWindowInteractor() self.__ren__ = vtk.vtkRenderer() self.__widget__.GetRenderWindow().AddRenderer(self.__ren__) self.__itkvtkConverter__ = None self.__volumeMapper__ = vtk.vtkVolumeTextureMapper2D() self.__volume__ = vtk.vtkVolume() self.__volumeProperty__ = vtk.vtkVolumeProperty() self.__volume__.SetMapper(self.__volumeMapper__) self.__volume__.SetProperty(self.__volumeProperty__) self.__ren__.AddVolume(self.__volume__) self.__outline__ = None self.__outlineMapper__ = None self.__outlineActor__ = None self.AdaptColorAndOpacity(0, 255) if input : self.SetInput(input) self.AdaptColorAndOpacity()
def draw(self): # Update location and movement self.update() # create a rendering window and renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetSize(1200, 900) renWin.AddRenderer(ren) # Create camera camera = vtk.vtkCamera() #camera.SetPosition(0.5,10.0,0.0); #camera.Roll(-90) #ren.SetActiveCamera(camera) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add actors ren.AddActor(self.modelActor) ren.AddActor(self.axesActor) # enable user interface interactor iren.Initialize() renWin.Render() style = vtk.vtkInteractorStyleMultiTouchCamera() iren.SetInteractorStyle(style) iren.Start()
def initialize(self): global renderer, renderWindow, renderWindowInteractor, cone, mapper, actor # Bring used components self.registerVtkWebProtocol(protocols.vtkWebMouseHandler()) self.registerVtkWebProtocol(protocols.vtkWebViewPort()) self.registerVtkWebProtocol(protocols.vtkWebViewPortImageDelivery()) self.registerVtkWebProtocol(protocols.vtkWebViewPortGeometryDelivery()) # Create default pipeline (Only once for all the session) if not _WebCone.view: # VTK specific code renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderWindowInteractor.GetInteractorStyle().SetCurrentStyleToTrackballCamera() cone = vtk.vtkConeSource() mapper = vtk.vtkPolyDataMapper() actor = vtk.vtkActor() mapper.SetInputConnection(cone.GetOutputPort()) actor.SetMapper(mapper) renderer.AddActor(actor) renderer.ResetCamera() renderWindow.Render() # VTK Web application specific _WebCone.view = renderWindow self.Application.GetObjectIdMap().SetActiveObject("VIEW", renderWindow)
def __init__(self, parent = None): super(VTKFrame, self).__init__(parent) self.vl = QtGui.QVBoxLayout(self) self.vl.setContentsMargins(0,0,0,0) self.vtkWidget = QVTKRenderWindowInteractor(self) self.vl.addWidget(self.vtkWidget) self._renderer = vtk.vtkRenderer() self.vtkWidget.GetRenderWindow().AddRenderer(self._renderer) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() #Create an style self._interactorStyle = MouseInteractorActor() self._interactorStyle.SetDefaultRenderer(self._renderer) self.vtkWidget.SetInteractorStyle(self._interactorStyle) self._actor1 = self.createActor1() self._actor2 = self.createActor2() self._renderer.AddActor(self._actor1) self._renderer.AddActor(self._actor2) self._renderer.ResetCamera() self._renderer.SetBackground(.1, .2, .3) self._initialized = False
def __init__(self, id): wx.Frame.__init__(self, id, title='My first VTKwx example', style =wx.DEFAULT_FRAME_STYLE) ## Add a menubar menuBar = wx.MenuBar() menuF = wx.Menu() menuBar.Append(menuF, "File") self.draw = menuF.Append(wx.ID_OPEN, 'Draw') self.SetMenuBar(menuBar) self.sb = self.CreateStatusBar() self.sb.SetFieldsCount(2) # Add the vtk window widget self.widget = wxVTKRenderWindowInteractor(self, -1) self.widget.Enable(1) # Layout sizer = wx.BoxSizer(wx.VERTICAL) sizer.Add(self.widget, 1, wx.EXPAND) self.SetSizer(sizer) self.Layout() # Ad a renderer self.ren = vtk.vtkRenderer() self.widget.GetRenderWindow().AddRenderer(self.ren) # Bind the menu self.Bind(wx.EVT_MENU, self.onDraw, self.draw)
def _create_renderer(self): renderer = vtk.vtkRenderer() renderer.SetViewport(0.0, 0.0, 1., 1.) renderer.SetActiveCamera(self._create_camera()) renderer.SetBackground(self.settings.image_background_color) self._add_lights_to_renderer(renderer) return renderer
def notebookviz(output): width,height = 400, 300 demMapper = vtkPolyDataMapper() demMapper.SetInputConnection(output.GetOutputPort()) surfaceActor = vtkActor() surfaceActor.SetMapper(demMapper) surfaceActor.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784) surfaceActor.GetProperty().SetSpecularColor(1, 1, 1) surfaceActor.GetProperty().SetSpecular(.4) surfaceActor.GetProperty().SetSpecularPower(50) VtkRenderer = vtkRenderer() VtkRenderer.SetBackground(1.0, 1.0, 1.0) VtkRenderer.AddActor(surfaceActor) renderWindow = vtkRenderWindow() renderWindow.SetOffScreenRendering(1) renderWindow.AddRenderer(VtkRenderer) renderWindow.SetSize(width, height) renderWindow.Render() windowToImageFilter = vtkWindowToImageFilter() windowToImageFilter.SetInput(renderWindow) windowToImageFilter.Update() writer = vtkPNGWriter() writer.SetWriteToMemory(1) writer.SetInputConnection(windowToImageFilter.GetOutputPort()) writer.Write() data = str(buffer(writer.GetResult())) return Image(data)
def run(self): self.vtk_renderer = vtkRenderer() self.setup_gui() self.setup_grid() # Handle any deferred configuration # Overlaid polygons for args in self.conf_overlaidPolygons: self.overlay_polygon_internal(*args) # Draw (and maybe alter) the axes if self.vtk_drawAxes: self.vtk_axes = vtkCubeAxesActor2D() # Perform all of the alterations required, by applying func to the vtk_axes instance (with the given args). for func, args in self.conf_axesAlterations: func(*((self.vtk_axes,) + args)) # Alter the Tk root as necessary. for func, args in self.conf_tkAlterations: func(*((self.tk_root,) + args)) # Finished with deferred configuration. # Draw Height Quantities for q in self.height_quantities: self.update_height_quantity(q, self.height_dynamic[q]) self.draw_height_quantity(q) self.tk_root.mainloop()
def add(**kwargs): ren = vtk.vtkRenderer() ren.SetBackground(0.5, 0.5, 0.5) #ren.SetViewport(0, 0, 0.5, 1) renWin.AddRenderer(ren) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(elev.GetOutputPort()) mapper.SetLookupTable(lut) mapper.SetInterpolateScalarsBeforeMapping(kwargs['interpolate_scalars_before_mapping']) mapper.SetScalarMaterialMode(kwargs["material_mode"]) actor = vtk.vtkActor() actor.SetMapper(mapper) ren.AddActor(actor) prop = actor.GetProperty() prop.SetAmbient(kwargs['ambient']) prop.SetDiffuse(kwargs['diffuse']) prop.SetAmbientColor(1, 0, 0) prop.SetDiffuseColor(0, 1, 0) textActorL = vtk.vtkTextActor() txt = " InterpolateScalarsBeforeMapping: %d\n"\ " ScalarMaterialMode: %s\n"\ " Ambient: %.2f\t Ambient Color: 1, 0, 0\n"\ " Diffuse: %.2f\t Diffuse Color: 0, 1, 0" txt = txt % (kwargs['interpolate_scalars_before_mapping'], mapper.GetScalarMaterialModeAsString(), prop.GetAmbient(), prop.GetDiffuse()) textActorL.SetInput(txt) ren.AddActor(textActorL) return (ren, actor, mapper)
def __test_adjust_sphere(): import vtk n_points = 4 points = [] for i in xrange(n_points): p = np.random.random(3) * 100 points.append(p) r, ctr = adjust_sphere(points) r2 = r / 10 ren_win = vtk.vtkRenderWindow() iren = vtk.vtkRenderWindowInteractor() iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) iren.SetRenderWindow(ren_win) ren = vtk.vtkRenderer() ren_win.AddRenderer(ren) # draw points for p in points: __add_sphere_to_ren(p, r2, ren) #draw big sphere ac = __add_sphere_to_ren(ctr, r, ren) ac.GetProperty().SetColor((1, 0, 0)) iren.Initialize() iren.Start()
def ParametricObjects(self): parametricObjects = list() parametricObjects.append(vtk.vtkParametricBoy()) parametricObjects.append(vtk.vtkParametricConicSpiral()) parametricObjects.append(vtk.vtkParametricCrossCap()) parametricObjects.append(vtk.vtkParametricDini()) parametricObjects.append(vtk.vtkParametricEllipsoid()) parametricObjects[-1].SetXRadius(0.5) parametricObjects[-1].SetYRadius(2.0) parametricObjects.append(vtk.vtkParametricEnneper()) parametricObjects.append(vtk.vtkParametricFigure8Klein()) parametricObjects.append(vtk.vtkParametricKlein()) parametricObjects.append(vtk.vtkParametricMobius()) parametricObjects.append(vtk.vtkParametricRandomHills()) parametricObjects[-1].AllowRandomGenerationOff() parametricObjects.append(vtk.vtkParametricRoman()) parametricObjects.append(vtk.vtkParametricSuperEllipsoid()) parametricObjects[-1].SetN1(0.5) parametricObjects[-1].SetN2(0.1) parametricObjects.append(vtk.vtkParametricSuperToroid()) parametricObjects[-1].SetN1(0.2) parametricObjects[-1].SetN2(3.0) parametricObjects.append(vtk.vtkParametricTorus()) parametricObjects.append(vtk.vtkParametricSpline()) # Add some points to the parametric spline. # You can use vtkRandom instead of the python random methods. inputPoints = vtk.vtkPoints() random.seed(8775070) for i in range(10): x = random.uniform(0.0, 1.0) y = random.uniform(0.0, 1.0) z = random.uniform(0.0, 1.0) inputPoints.InsertNextPoint(x, y, z) parametricObjects[-1].SetPoints(inputPoints) # There are only 15 objects. #parametricObjects.append(vtk.??) parametricFunctionSources = list() renderers = list() mappers = list() actors = list() textmappers = list() textactors = list() # Create a common text property. textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(10) textProperty.SetJustificationToCentered() # Create a parametric function source, renderer, mapper # and actor for each object. for idx, item in enumerate(parametricObjects): parametricFunctionSources.append(vtk.vtkParametricFunctionSource()) parametricFunctionSources[idx].SetParametricFunction(item) parametricFunctionSources[idx].Update() mappers.append(vtk.vtkPolyDataMapper()) mappers[idx].SetInputConnection( parametricFunctionSources[idx].GetOutputPort()) actors.append(vtk.vtkActor()) actors[idx].SetMapper(mappers[idx]) textmappers.append(vtk.vtkTextMapper()) textmappers[idx].SetInput(item.GetClassName()) textmappers[idx].SetTextProperty(textProperty) textactors.append(vtk.vtkActor2D()) textactors[idx].SetMapper(textmappers[idx]) textactors[idx].SetPosition(100, 16) renderers.append(vtk.vtkRenderer()) gridDimensions = 4 for idx in range(len(parametricObjects)): if idx < gridDimensions * gridDimensions: renderers.append(vtk.vtkRenderer) rendererSize = 200 # Create the RenderWindow # renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(rendererSize * gridDimensions, rendererSize * gridDimensions) # Add and position the renders to the render window. viewport = list() for row in range(gridDimensions): for col in range(gridDimensions): idx = row * gridDimensions + col viewport[:] = [] viewport.append( float(col) * rendererSize / (gridDimensions * rendererSize)) viewport.append( float(gridDimensions - (row + 1)) * rendererSize / (gridDimensions * rendererSize)) viewport.append( float(col + 1) * rendererSize / (gridDimensions * rendererSize)) viewport.append( float(gridDimensions - row) * rendererSize / (gridDimensions * rendererSize)) if idx > (len(parametricObjects) - 1): continue renderers[idx].SetViewport(viewport) renderWindow.AddRenderer(renderers[idx]) renderers[idx].AddActor(actors[idx]) renderers[idx].AddActor(textactors[idx]) renderers[idx].SetBackground(0.2, 0.3, 0.4) renderers[idx].ResetCamera() renderers[idx].GetActiveCamera().Azimuth(30) renderers[idx].GetActiveCamera().Elevation(-30) renderers[idx].ResetCameraClippingRange() interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
def main(): colors = vtk.vtkNamedColors() fileName = get_program_parameters() polyData = ReadPolyData(fileName) # A renderer. renderer = vtk.vtkRenderer() renderer.SetBackground(colors.GetColor3d("White")) # Create background colors for each viewport. backgroundColors = list() backgroundColors.append(colors.GetColor3d("Cornsilk")) backgroundColors.append(colors.GetColor3d("NavajoWhite")) backgroundColors.append(colors.GetColor3d("Tan")) # Create a renderer for each view port. ren = list() ren.append(vtk.vtkRenderer()) ren.append(vtk.vtkRenderer()) ren.append(vtk.vtkRenderer()) ren[0].SetViewport(0, 0, 1.0 / 3.0, 1) # Input ren[1].SetViewport(1.0 / 3.0, 0, 2.0 / 3.0, 1) # Normals (no split) ren[2].SetViewport(2.0 / 3.0, 0, 1, 1) # Normals (split) # Shared camera. camera = vtk.vtkCamera() normals = vtk.vtkPolyDataNormals() normals.SetInputData(polyData) normals.SetFeatureAngle(30.0) for i in range(0, 3): if i == 0: normals.ComputePointNormalsOff() elif i == 1: normals.ComputePointNormalsOn() normals.SplittingOff() else: normals.ComputePointNormalsOn() normals.SplittingOn() print(normals) normals.Update() normalsPolyData = vtk.vtkPolyData() normalsPolyData.DeepCopy(normals.GetOutput()) # mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(normalsPolyData) mapper.ScalarVisibilityOff() actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetDiffuseColor(colors.GetColor3d("Peacock")) actor.GetProperty().SetDiffuse(.7) actor.GetProperty().SetSpecularPower(20) actor.GetProperty().SetSpecular(.5) # add the actor ren[i].SetBackground(backgroundColors[i]) ren[i].SetActiveCamera(camera) ren[i].AddActor(actor) # Render window. renwin = vtk.vtkRenderWindow() renwin.AddRenderer(ren[0]) renwin.AddRenderer(ren[1]) renwin.AddRenderer(ren[2]) # An interactor. interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renwin) renwin.SetSize(900, 300) ren[0].GetActiveCamera().SetFocalPoint(0, 0, 0) ren[0].GetActiveCamera().SetPosition(1, 0, 0) ren[0].GetActiveCamera().SetViewUp(0, 0, -1) ren[0].ResetCamera() ren[0].GetActiveCamera().Azimuth(120) ren[0].GetActiveCamera().Elevation(30) ren[0].GetActiveCamera().Dolly(1.1) ren[0].ResetCameraClippingRange() renwin.Render() ren[0].ResetCamera() renwin.Render() # Start. interactor.Initialize() interactor.Start()
def testFinancialField(self): """ Demonstrate the use and manipulation of fields and use of vtkProgrammableDataObjectSource. This creates fields the hard way (as compared to reading a vtk field file), but shows you how to interface to your own raw data. The image should be the same as financialField.tcl """ xAxis = "INTEREST_RATE" yAxis = "MONTHLY_PAYMENT" zAxis = "MONTHLY_INCOME" scalar = "TIME_LATE" # Parse an ascii file and manually create a field. Then construct a # dataset from the field. dos = vtk.vtkProgrammableDataObjectSource() def parseFile(): f = open(VTK_DATA_ROOT + "/Data/financial.txt", "r") line = f.readline().split() # From the size calculate the number of lines. numPts = int(line[1]) numLines = (numPts - 1) / 8 + 1 # create the data object field = vtk.vtkFieldData() field.AllocateArrays(4) # read TIME_LATE - dependent variable while True: line = f.readline().split() if len(line) > 0: break timeLate = vtk.vtkFloatArray() timeLate.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: timeLate.InsertNextValue(float(j)) field.AddArray(timeLate) # MONTHLY_PAYMENT - independent variable while True: line = f.readline().split() if len(line) > 0: break monthlyPayment = vtk.vtkFloatArray() monthlyPayment.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: monthlyPayment.InsertNextValue(float(j)) field.AddArray(monthlyPayment) # UNPAID_PRINCIPLE - skip while True: line = f.readline().split() if len(line) > 0: break for i in range(0, numLines): line = f.readline() # LOAN_AMOUNT - skip while True: line = f.readline().split() if len(line) > 0: break for i in range(0, numLines): line = f.readline() # INTEREST_RATE - independent variable while True: line = f.readline().split() if len(line) > 0: break interestRate = vtk.vtkFloatArray() interestRate.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: interestRate.InsertNextValue(float(j)) field.AddArray(interestRate) # MONTHLY_INCOME - independent variable while True: line = f.readline().split() if len(line) > 0: break monthlyIncome = vtk.vtkFloatArray() monthlyIncome.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: monthlyIncome.InsertNextValue(float(j)) field.AddArray(monthlyIncome) dos.GetOutput().SetFieldData(field) dos.SetExecuteMethod(parseFile) # Create the dataset do2ds = vtk.vtkDataObjectToDataSetFilter() do2ds.SetInputConnection(dos.GetOutputPort()) do2ds.SetDataSetTypeToPolyData() #format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize do2ds.DefaultNormalizeOn() do2ds.SetPointComponent(0, xAxis, 0) do2ds.SetPointComponent(1, yAxis, 0) do2ds.SetPointComponent(2, zAxis, 0) do2ds.Update() rf = vtk.vtkRearrangeFields() rf.SetInputConnection(do2ds.GetOutputPort()) rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.RemoveOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.RemoveAllOperations() rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.Update() max = rf.GetOutput().GetPointData().GetArray(scalar).GetRange(0)[1] calc = vtk.vtkArrayCalculator() calc.SetInputConnection(rf.GetOutputPort()) calc.SetAttributeModeToUsePointData() calc.SetFunction("s / %f" % max) calc.AddScalarVariable("s", scalar, 0) calc.SetResultArrayName("resArray") aa = vtk.vtkAssignAttribute() aa.SetInputConnection(calc.GetOutputPort()) aa.Assign("resArray", "SCALARS", "POINT_DATA") aa.Update() rf2 = vtk.vtkRearrangeFields() rf2.SetInputConnection(aa.GetOutputPort()) rf2.AddOperation("COPY", "SCALARS", "POINT_DATA", "DATA_OBJECT") # construct pipeline for original population popSplatter = vtk.vtkGaussianSplatter() popSplatter.SetInputConnection(rf2.GetOutputPort()) popSplatter.SetSampleDimensions(50, 50, 50) popSplatter.SetRadius(0.05) popSplatter.ScalarWarpingOff() popSurface = vtk.vtkContourFilter() popSurface.SetInputConnection(popSplatter.GetOutputPort()) popSurface.SetValue(0, 0.01) popMapper = vtk.vtkPolyDataMapper() popMapper.SetInputConnection(popSurface.GetOutputPort()) popMapper.ScalarVisibilityOff() popMapper.ImmediateModeRenderingOn() popActor = vtk.vtkActor() popActor.SetMapper(popMapper) popActor.GetProperty().SetOpacity(0.3) popActor.GetProperty().SetColor(.9, .9, .9) # construct pipeline for delinquent population lateSplatter = vtk.vtkGaussianSplatter() lateSplatter.SetInputConnection(aa.GetOutputPort()) lateSplatter.SetSampleDimensions(50, 50, 50) lateSplatter.SetRadius(0.05) lateSplatter.SetScaleFactor(0.05) lateSurface = vtk.vtkContourFilter() lateSurface.SetInputConnection(lateSplatter.GetOutputPort()) lateSurface.SetValue(0, 0.01) lateMapper = vtk.vtkPolyDataMapper() lateMapper.SetInputConnection(lateSurface.GetOutputPort()) lateMapper.ScalarVisibilityOff() lateActor = vtk.vtkActor() lateActor.SetMapper(lateMapper) lateActor.GetProperty().SetColor(1.0, 0.0, 0.0) # create axes popSplatter.Update() bounds = popSplatter.GetOutput().GetBounds() axes = vtk.vtkAxes() axes.SetOrigin(bounds[0], bounds[2], bounds[4]) axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(axes.GetScaleFactor() / 25.0) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # label the axes XText = vtk.vtkVectorText() XText.SetText(xAxis) XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(0.02, .02, .02) XActor.SetPosition(0.35, -0.05, -0.05) XActor.GetProperty().SetColor(0, 0, 0) YText = vtk.vtkVectorText() YText.SetText(yAxis) YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(0.02, .02, .02) YActor.SetPosition(-0.05, 0.35, -0.05) YActor.GetProperty().SetColor(0, 0, 0) ZText = vtk.vtkVectorText() ZText.SetText(zAxis) ZTextMapper = vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor = vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(0.02, .02, .02) ZActor.SetPosition(-0.05, -0.05, 0.35) ZActor.GetProperty().SetColor(0, 0, 0) # Graphics stuff # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetWindowName("vtk(-, Field.Data") renWin.SetSize(300, 300) # Add the actors to the renderer, set the background and size # ren.AddActor(axesActor) ren.AddActor(lateActor) ren.AddActor(XActor) ren.AddActor(YActor) ren.AddActor(ZActor) ren.AddActor(popActor) #it's last because its translucent) ren.SetBackground(1, 1, 1) camera = vtk.vtkCamera() camera.SetClippingRange(.274, 13.72) camera.SetFocalPoint(0.433816, 0.333131, 0.449) camera.SetPosition(-1.96987, 1.15145, 1.49053) camera.SetViewUp(0.378927, 0.911821, 0.158107) ren.SetActiveCamera(camera) XActor.SetCamera(camera) YActor.SetCamera(camera) ZActor.SetCamera(camera) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) renWin.Render() img_file = "financialField3.png" vtk.test.Testing.compareImage( iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def __init__(self, name='', create_interactor=True, style=VisualizerInteractionStyle()): self._interactor = vtk.vtkRenderWindowInteractor() self._update_fps = _FPSCallback(self) self._stopped = False self._timer_id = 0 self._exit_main_loop_timer_callback = None self._exit_callback = None self._rens = vtk.RendererCollection() self._win = None self._style = style self._cloud_actor_map = dict() self._shape_actor_map = dict() self._coordinate_actor_map = dict() self._camera_set = False self._camera_file_loaded = False # Create a Renderer ren = vtk.vtkRenderer() ren.AddObserver(vtk.vtkCommand.EndEvent, self._update_fps) self._rens.AddItem(ren) # FPS callback txt = vtk.vtkTextActor() self._update_fps.actor = txt self._update_fps.pcl_visualizer = self self._update_fps.decimated = False ren.AddActor(txt) txt.SetInput('0 FPS') # Create a RendererWindow self._win = vtk.vtkRendererWindow() self._win.SetWindowName(name) # Get screen size scr_size_x, scr_size_y = self._win.GetScreenSize() # Set the window size as 1/2 of the screen size self._win.SetSize(scr_size_x / 2, scr_size_y / 2) # By default, don't use vertex buffer objects self._use_vbox = False # Add all renderers to the window self._rens.InitTraversal() while True: renderer = self._rens.GetNextItem() if renderer is None: break self._win.AddRenderer(renderer) # Set renderer window in case no interactor is created self._style.render_window = self._win # Create the interactor style self._style.initialize() self._style.renderer_collection = self._rens self._style.cloud_actor_map = self._cloud_actor_map self._style.shape_actor_map = self._shape_actor_map self._style.user_timers_on() self._style.use_vbos = self._use_vbos if create_interactor: self.create_interactor() self._win.SetWindowName(name) # XXX duplicate?
__author__ = 'Su Lei' import vtk from vtk.util.colors import tomato cylinder = vtk.vtkCylinderSource() cylinder.SetResolution(8) cylinderMapper = vtk.vtkPolyDataMapper() cylinderMapper.SetInputConnection(cylinder.GetOutputPort()) cylinderActor = vtk.vtkActor() cylinderActor.SetMapper(cylinderMapper) cylinderActor.GetProperty().SetColor(tomato) cylinderActor.RotateX(30.0) cylinderActor.RotateY(-45.0) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.AddActor(cylinderActor) ren.SetBackground(0.1, 0.2, 0.4) renWin.SetSize(200, 200) iren.Initialize() ren.ResetCamera() ren.GetActiveCamera().Zoom(1.5) renWin.Render() iren.Start()
def main(): colors = vtk.vtkNamedColors() source = vtk.vtkSphereSource() source.SetPhiResolution(31) source.SetThetaResolution(31) source.Update() bounds = source.GetOutput().GetBounds() print("Bounds: " + str(bounds[0]) + ", " + str(bounds[2]) + ", " + str(bounds[3]) + ", " + str(bounds[1]) + ", " + str(bounds[3]) + ", " + str(bounds[5])) center = source.GetOutput().GetCenter() print("Center: " + str(center[0]) + ", " + str(center[1]) + ", " + str(center[2])) # Create the axis actor axis = vtk.vtkAxisActor() axis.SetPoint1(-1.1, 0.0, 0.0) axis.SetPoint2(1.1, 0.0, 0.0) axis.SetTickLocationToBoth() axis.SetAxisTypeToX() axis.SetTitle("A Sphere") axis.SetTitleScale(0.2) axis.TitleVisibilityOn() axis.SetMajorTickSize(0.05) axis.SetMinorTickSize(1) axis.DrawGridlinesOff() axis.GetTitleTextProperty().SetColor(colors.GetColor3d("banana")) axis.GetLabelTextProperty().SetColor(colors.GetColor3d("orange")) labels = vtk.vtkStringArray() labels.SetNumberOfTuples(1) labels.SetValue(0, "x Axis") axis.SetLabels(labels) axis.SetLabelScale(.1) axis.MinorTicksVisibleOn() axis.SetDeltaMajor(0, .1) axis.SetCalculateTitleOffset(0) axis.SetCalculateLabelOffset(0) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) # actor.GetProperty().SetDiffuseColor(colors.GetColor4d("Tomato")) actor.GetProperty().SetDiffuseColor(colors.GetColor3d("Tomato")) # Create the RenderWindow, Renderer and both Actors renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.SetWindowName("AxisActor") interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) axis.SetCamera(renderer.GetActiveCamera()) renderer.AddActor(actor) renderer.AddActor(axis) # renderer.SetBackground(colors.GetColor4d("SlateGray")) renderer.SetBackground(colors.GetColor3d("SlateGray")) renderWindow.SetSize(640, 480) renderer.ResetCamera() renderer.ResetCameraClippingRange() # render the image renderWindow.Render() interactor.Initialize() interactor.Start()
def create_render_window(actors, callbacks, **kwargs): """ Creates VTK render window with an interactor. :param actors: list of VTK actors :type actors: list, tuple :param callbacks: callback functions for registering custom events :type callbacks: dict """ # Get keyword arguments figure_size = kwargs.get('figure_size', (800, 600)) camera_position = kwargs.get('camera_position', (0, 0, 100)) # Find camera focal point center_points = [] for actor in actors: center_points.append(actor.GetCenter()) camera_focal_point = linalg.vector_mean(*center_points) # Create camera camera = vtk.vtkCamera() camera.SetPosition(*camera_position) camera.SetFocalPoint(*camera_focal_point) # Create renderer renderer = vtk.vtkRenderer() renderer.SetActiveCamera(camera) renderer.SetBackground(1.0, 1.0, 1.0) # Add actors to the scene for actor in actors: renderer.AddActor(actor) # Render window render_window = vtk.vtkRenderWindow() render_window.AddRenderer(renderer) render_window.SetSize(*figure_size) # Render window interactor window_interactor = vtk.vtkRenderWindowInteractor() window_interactor.SetRenderWindow(render_window) # Add event observers for cb in callbacks: window_interactor.AddObserver( cb, callbacks[cb][0], callbacks[cb][1]) # cb name, cb function ref, cb priority # Render actors render_window.Render() # Set window name after render() is called render_window.SetWindowName("geomdl") # Use trackball camera interactor_style = vtk.vtkInteractorStyleTrackballCamera() window_interactor.SetInteractorStyle(interactor_style) # Start interactor window_interactor.Start() # Return window interactor instance return window_interactor
def main(): xyzFile, qFile = get_program_parameters() colors = vtk.vtkNamedColors() # Create pipeline. Read structured grid data. pl3d = vtk.vtkMultiBlockPLOT3DReader() pl3d.SetXYZFileName(xyzFile) pl3d.SetQFileName(qFile) pl3d.SetScalarFunctionNumber(100) pl3d.SetVectorFunctionNumber(202) pl3d.Update() pl3dOutput = pl3d.GetOutput().GetBlock(0) # A convenience extract = vtk.vtkExtractGrid() extract.SetVOI(1, 55, -1000, 1000, -1000, 1000) extract.SetInputData(pl3dOutput) # The plane is used to do the cutting plane = vtk.vtkPlane() plane.SetOrigin(0, 4, 2) plane.SetNormal(0, 1, 0) # compositing. cutter = vtk.vtkCutter() cutter.SetInputConnection(extract.GetOutputPort()) cutter.SetCutFunction(plane) cutter.GenerateCutScalarsOff() cutter.SetSortByToSortByCell() clut = vtk.vtkLookupTable() clut.SetHueRange(0, 0.67) clut.Build() cutterMapper = vtk.vtkPolyDataMapper() cutterMapper.SetInputConnection(cutter.GetOutputPort()) cutterMapper.SetScalarRange(0.18, 0.7) cutterMapper.SetLookupTable(clut) cut = vtk.vtkActor() cut.SetMapper(cutterMapper) # Add in some surface geometry for interest. iso = vtk.vtkContourFilter() iso.SetInputData(pl3dOutput) iso.SetValue(0, .22) normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(iso.GetOutputPort()) normals.SetFeatureAngle(60) isoMapper = vtk.vtkPolyDataMapper() isoMapper.SetInputConnection(normals.GetOutputPort()) isoMapper.ScalarVisibilityOff() isoActor = vtk.vtkActor() isoActor.SetMapper(isoMapper) isoActor.GetProperty().SetDiffuseColor(colors.GetColor3d("Tomato")) isoActor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) isoActor.GetProperty().SetDiffuse(0.8) isoActor.GetProperty().SetSpecular(0.5) isoActor.GetProperty().SetSpecularPower(30) outline = vtk.vtkStructuredGridOutlineFilter() outline.SetInputData(pl3dOutput) outlineStrip = vtk.vtkStripper() outlineStrip.SetInputConnection(outline.GetOutputPort()) outlineTubes = vtk.vtkTubeFilter() outlineTubes.SetInputConnection(outline.GetOutputPort()) outlineTubes.SetInputConnection(outlineStrip.GetOutputPort()) outlineTubes.SetRadius(0.1) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outlineTubes.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) # Create the RenderWindow, Renderer and Interactor. ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add the actors to the renderer, set the background and size. ren1.AddActor(outlineActor) outlineActor.GetProperty().SetColor(colors.GetColor3d("Banana")) ren1.AddActor(isoActor) isoActor.VisibilityOn() ren1.AddActor(cut) n = 20 opacity = 1.0 / float(n) * 5.0 cut.GetProperty().SetOpacity(1) ren1.SetBackground(colors.GetColor3d("SlateGray")) renWin.SetSize(640, 480) ren1.GetActiveCamera().SetClippingRange(3.95297, 50) ren1.GetActiveCamera().SetFocalPoint(9.71821, 0.458166, 29.3999) ren1.GetActiveCamera().SetPosition(2.7439, -37.3196, 38.7167) ren1.GetActiveCamera().ComputeViewPlaneNormal() ren1.GetActiveCamera().SetViewUp(-0.16123, 0.264271, 0.950876) # Cut: generates n cut planes normal to camera's view plane. plane.SetNormal(ren1.GetActiveCamera().GetViewPlaneNormal()) plane.SetOrigin(ren1.GetActiveCamera().GetFocalPoint()) cutter.GenerateValues(n, -5, 5) clut.SetAlphaRange(opacity, opacity) renWin.Render() iren.Start()
appendF.AddInputConnection(ps3.GetOutputPort()) appendF.AddInputConnection(ps4.GetOutputPort()) appendF.AddInputConnection(ps5.GetOutputPort()) appendF.AddInputConnection(ps6.GetOutputPort()) #appendF.AddInputConnection(ps7.GetOutputPort()) appendF.AddInputConnection(ps8.GetOutputPort()) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(appendF.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) # Create the RenderWindow, Renderer and Interactive Renderer # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren1.AddActor(actor) ren1.SetBackground(0, 0, 0) renWin.SetSize(300, 300) renWin.Render() ren1.GetActiveCamera().SetPosition(1, 1, 1) ren1.ResetCamera() renWin.Render()
def show_3d(L_box, L_coordinates): nums = len(L_box) edge_max = max([max(L_box[i]) for i in range(len(L_box)) ]) if max([max(L_box[i]) for i in range(len(L_box))]) > 0 else 1 # 预设参数 gap = 0.01 CL_p = 1.1 CW_p = nums + gap * (nums - 1) CH_p = 0.01 gap = 0.25 x_re = 0 y_re = 0 z_re = 0 #渲染及渲染窗口,并根据捕捉的鼠标事件执行相应的操作 ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(1200, 600) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) """画容器""" for i in range(nums): cube = vtk.vtkCubeSource() cube.SetXLength(L_box[i][0] / edge_max) cube.SetYLength(L_box[i][1] / edge_max) cube.SetZLength(L_box[i][2] / edge_max) cube.Update() translation = vtkTransform() translation.Translate( L_box[i][0] / edge_max / 2.0 + x_re, L_box[i][1] / edge_max / 2.0 + i + gap * i + y_re, L_box[i][2] / edge_max / 2.0 + z_re) transformFilter = vtkTransformPolyDataFilter() transformFilter.SetInputConnection(cube.GetOutputPort()) transformFilter.SetTransform(translation) transformFilter.Update() transformedMapper = vtkPolyDataMapper() transformedMapper.SetInputConnection(transformFilter.GetOutputPort()) transformedActor = vtkActor() transformedActor.SetMapper(transformedMapper) transformedActor.GetProperty().SetColor((1, 1, 1)) transformedActor.GetProperty().SetRepresentationToWireframe() ren.AddActor(transformedActor) """画托盘""" cube = vtk.vtkCubeSource() cube.SetXLength(CL_p) cube.SetYLength(CW_p) cube.SetZLength(CH_p) cube.Update() translation = vtkTransform() translation.Translate(CL_p / 2.0 + x_re, CW_p / 2.0 + y_re, -CH_p / 2.0 + z_re) transformFilter = vtkTransformPolyDataFilter() transformFilter.SetInputConnection(cube.GetOutputPort()) transformFilter.SetTransform(translation) transformFilter.Update() transformedMapper = vtkPolyDataMapper() transformedMapper.SetInputConnection(transformFilter.GetOutputPort()) transformedActor = vtkActor() transformedActor.SetMapper(transformedMapper) transformedActor.GetProperty().SetColor((0.2, 0.4, 0.8)) ren.AddActor(transformedActor) for i in range(len(L_coordinates)): for j in range(len(L_coordinates[i])): Addcube_3d(ren, L_coordinates[i][j], edge_max, x_re, i + gap * i + y_re, z_re) camera = vtk.vtkCamera() camera.SetViewUp(0, 0, 1) # 设置相机的“上”方向 camera.SetPosition(10, 10, 1) # 位置:世界坐标系,设置相机位置 camera.SetFocalPoint(0, 8, 0) camera.ComputeViewPlaneNormal() # camera.SetPosition(5, -0.5, 2) ren.SetActiveCamera(camera) iren.Initialize() renWin.Render() # 保存过程 png_save(renWin, "result_D3.png") # 展示 iren.Start()
import random import vtk a = [] for i in xrange(5): b = [] print id(b) for j in xrange(3): b.append(random.randint(1, 100)) a.append(b) print id(a[i]) print a r = vtk.vtkRenderer() print r.GetNumberOfPropsRendered()
Actor4a.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784) map4b = vtk.vtkPolyDataMapper() map4b.SetInputData(procrustes3.GetOutput().GetBlock(1)) Actor4b = vtk.vtkActor() Actor4b.SetMapper(map4b) Actor4b.GetProperty().SetDiffuseColor(0.3882, 1.0000, 0.2784) map4c = vtk.vtkPolyDataMapper() map4c.SetInputData(procrustes3.GetOutput().GetBlock(2)) Actor4c = vtk.vtkActor() Actor4c.SetMapper(map4c) Actor4c.GetProperty().SetDiffuseColor(0.3882, 0.2784, 1.0000) # Create the RenderWindow and its four Renderers ren = vtk.vtkRenderer() ren2 = vtk.vtkRenderer() ren3 = vtk.vtkRenderer() ren4 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.AddRenderer(ren2) renWin.AddRenderer(ren3) renWin.AddRenderer(ren4) renWin.SetSize(400, 100) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add the actors to the renderer ren.AddActor(Actor1a) ren.AddActor(Actor1b)
def testGlyphs(self): """Test if texturing of the glyphs works correctly.""" # The Glyph cs = vtk.vtkCubeSource() cs.SetXLength(2.0) cs.SetYLength(1.0) cs.SetZLength(0.5) # Create input point data. pts = vtk.vtkPoints() pts.InsertPoint(0, (1, 1, 1)) pts.InsertPoint(1, (0, 0, 0)) pts.InsertPoint(2, (-1, -1, -1)) polys = vtk.vtkCellArray() polys.InsertNextCell(1) polys.InsertCellPoint(0) polys.InsertNextCell(1) polys.InsertCellPoint(1) polys.InsertNextCell(1) polys.InsertCellPoint(2) pd = vtk.vtkPolyData() pd.SetPoints(pts) pd.SetPolys(polys) # Orient the glyphs as per vectors. vec = vtk.vtkFloatArray() vec.SetNumberOfComponents(3) vec.InsertTuple3(0, 1, 0, 0) vec.InsertTuple3(1, 0, 1, 0) vec.InsertTuple3(2, 0, 0, 1) pd.GetPointData().SetVectors(vec) # The glyph filter. g = vtk.vtkGlyph3D() g.SetScaleModeToDataScalingOff() g.SetVectorModeToUseVector() g.SetInputData(pd) g.SetSourceConnection(cs.GetOutputPort()) m = vtk.vtkPolyDataMapper() m.SetInputConnection(g.GetOutputPort()) a = vtk.vtkActor() a.SetMapper(m) # The texture. img_file = os.path.join(Testing.VTK_DATA_ROOT, "Data", "masonry.bmp") img_r = vtk.vtkBMPReader() img_r.SetFileName(img_file) t = vtk.vtkTexture() t.SetInputConnection(img_r.GetOutputPort()) t.InterpolateOn() a.SetTexture(t) # Renderer, RenderWindow etc. ren = vtk.vtkRenderer() ren.SetBackground(0.5, 0.5, 0.5) ren.AddActor(a) ren.ResetCamera() cam = ren.GetActiveCamera() cam.Azimuth(-90) cam.Zoom(1.4) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) rwi = vtk.vtkRenderWindowInteractor() rwi.SetRenderWindow(renWin) rwi.Initialize() rwi.Render()
def main(): colors = vtk.vtkNamedColors() lineColor = colors.GetColor3d("peacock") modelColor = colors.GetColor3d("silver") backgroundColor = colors.GetColor3d("wheat") modelSource = vtk.vtkSphereSource() plane = vtk.vtkPlane() cutter = vtk.vtkCutter() cutter.SetInputConnection(modelSource.GetOutputPort()) cutter.SetCutFunction(plane) cutter.GenerateValues(10, -.5, .5) modelMapper = vtk.vtkPolyDataMapper() modelMapper.SetInputConnection(modelSource.GetOutputPort()) model = vtk.vtkActor() model.SetMapper(modelMapper) model.GetProperty().SetDiffuseColor(modelColor) model.GetProperty().SetInterpolationToFlat() stripper = vtk.vtkStripper() stripper.SetInputConnection(cutter.GetOutputPort()) stripper.JoinContiguousSegmentsOn() linesMapper = vtk.vtkPolyDataMapper() linesMapper.SetInputConnection(stripper.GetOutputPort()) lines = vtk.vtkActor() lines.SetMapper(linesMapper) lines.GetProperty().SetDiffuseColor(lineColor) lines.GetProperty().SetLineWidth(3.) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.SetSize(640, 480) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) # Add the actors to the renderer. renderer.AddActor(model) renderer.AddActor(lines) renderer.SetBackground(backgroundColor) # This starts the event loop and as a side effect causes an # initial render. renderWindow.Render() interactor.Start() # Extract the lines from the polydata. numberOfLines = cutter.GetOutput().GetNumberOfLines() print("-----------Lines without using vtkStripper") print("There are {0} lines in the polydata".format(numberOfLines)) numberOfLines = stripper.GetOutput().GetNumberOfLines() points = stripper.GetOutput().GetPoints() cells = stripper.GetOutput().GetLines() cells.InitTraversal() print("-----------Lines using vtkStripper") print("There are {0} lines in the polydata".format(numberOfLines)) indices = vtk.vtkIdList() lineCount = 0 while cells.GetNextCell(indices): print("Line {0}:".format(lineCount)) for i in range(indices.GetNumberOfIds()): point = points.GetPoint(indices.GetId(i)) print("\t({0:0.6f} ,{1:0.6f}, {2:0.6f})".format( point[0], point[1], point[2])) lineCount += 1
def main(): fileName = get_program_parameters() colors = vtk.vtkNamedColors() # Create the RenderWindow, Renderer and Interactor. # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create the pipeline. # reader = vtk.vtkMetaImageReader() reader.SetFileName(fileName) reader.Update() extractVOI = vtk.vtkExtractVOI() extractVOI.SetInputConnection(reader.GetOutputPort()) extractVOI.SetVOI(0, 255, 0, 255, 45, 45) iso = vtk.vtkContourFilter() iso.SetInputConnection(extractVOI.GetOutputPort()) iso.GenerateValues(12, 500, 1150) isoMapper = vtk.vtkPolyDataMapper() isoMapper.SetInputConnection(iso.GetOutputPort()) isoMapper.ScalarVisibilityOff() isoActor = vtk.vtkActor() isoActor.SetMapper(isoMapper) isoActor.GetProperty().SetColor(colors.GetColor3d('Wheat')) outline = vtk.vtkOutlineFilter() outline.SetInputConnection(extractVOI.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) # Add the actors to the renderer, set the background and size. # ren1.AddActor(outlineActor) ren1.AddActor(isoActor) ren1.SetBackground(colors.GetColor3d('SlateGray')) ren1.ResetCamera() ren1.GetActiveCamera().Dolly(1.5) ren1.ResetCameraClippingRange() renWin.SetSize(640, 640) renWin.SetWindowName('HeadSlice') renWin.Render() iren.Start()
def __init__(self, parent=None, originatingWidget=None): QtGui.QFrame.__init__(self, parent) # print '\n\n\n\n\n CREATING NEW GRAPHICS FRAME WIDGET ',self # self.allowSaveLayout = True self.is_screenshot_widget = False self.qvtkWidget = QVTKRenderWindowInteractor(self) # a QWidget self.setAttribute(QtCore.Qt.WA_DeleteOnClose) # MDIFIX self.parentWidget = originatingWidget # self.parentWidget = parent self.plane = None self.planePos = None self.lineEdit = QtGui.QLineEdit() self.__initCrossSectionActions() self.cstb = self.initCrossSectionToolbar() layout = QtGui.QBoxLayout(QtGui.QBoxLayout.TopToBottom) layout.addWidget(self.cstb) layout.addWidget(self.qvtkWidget) self.setLayout(layout) self.setMinimumSize(100, 100) #needs to be defined to resize smaller than 400x400 self.resize(600, 600) self.qvtkWidget.Initialize() self.qvtkWidget.Start() self.ren = vtk.vtkRenderer() self.renWin = self.qvtkWidget.GetRenderWindow() self.renWin.AddRenderer(self.ren) # print MODULENAME,"GraphicsFrameWidget():__init__: parent=",parent # some objects below create cyclic dependencies - the widget will not free its memory unless in the close event e.g. self.drawModel2D gets set to None # # # from weakref import ref # # # self_weakref=ref(self) # # # self.drawModel2D = MVCDrawModel2D(self_weakref,parent) # # # self.draw2D = MVCDrawView2D(self.drawModel2D,self_weakref,parent) # # # self.drawModel3D = MVCDrawModel3D(self_weakref,parent) # # # self.draw3D = MVCDrawView3D(self.drawModel3D,self_weakref,parent) # MDIFIX self.drawModel2D = MVCDrawModel2D(self, self.parentWidget) self.draw2D = MVCDrawView2D(self.drawModel2D, self, self.parentWidget) self.drawModel3D = MVCDrawModel3D(self, self.parentWidget) self.draw3D = MVCDrawView3D(self.drawModel3D, self, self.parentWidget) # self.drawModel2D = MVCDrawModel2D(self,parent) # self.draw2D = MVCDrawView2D(self.drawModel2D,self,parent) # # self.drawModel3D = MVCDrawModel3D(self,parent) # self.draw3D = MVCDrawView3D(self.drawModel3D,self,parent) # self.draw2D=Draw2D(self,parent) # self.draw3D=Draw3D(self,parent) self.camera3D = self.ren.MakeCamera() self.camera2D = self.ren.GetActiveCamera() self.ren.SetActiveCamera(self.camera2D) self.currentDrawingObject = self.draw2D self.draw3DFlag = False self.usedDraw3DFlag = False # self.getattrFcn=self.getattrDraw2D # rwh test # print MODULENAME,' self.parentWidget.playerSettingsFileName= ',self.parentWidget.playerSettingsFileName if self.parentWidget.playerSettingsFileName: # does not work on Windows with Python 2.5 # with open(self.parentWidget.playerSettingsFileName, 'r') as f: f=None try: f=open(self.parentWidget.playerSettingsFileName, 'r') while True: l = f.readline() if l == "": break v = l.split() print v if string.find(v[0], 'CameraPosition') > -1: self.camera3D.SetPosition(float(v[1]), float(v[2]), float(v[3])) elif string.find(v[0], 'CameraFocalPoint') > -1: self.camera3D.SetFocalPoint(float(v[1]), float(v[2]), float(v[3])) elif string.find(v[0], 'CameraViewUp') > -1: self.camera3D.SetViewUp(float(v[1]), float(v[2]), float(v[3])) # elif string.find(v[0], 'ViewPlaneNormal') > -1: # deprecated # self.camera3D.SetViewPlaneNormal(float(v[1]), float(v[2]), float(v[3])) elif string.find(v[0], 'CameraClippingRange') > -1: self.camera3D.SetClippingRange(float(v[1]), float(v[2])) elif string.find(v[0], 'CameraDistance') > -1: print 'SetDistance = ',float(v[1]) self.camera3D.SetDistance(float(v[1])) elif string.find(v[0], 'ViewAngle') > -1: self.camera3D.SetViewAngle(float(v[1])) except IOError: pass self.screenshotWindowFlag=False
def contour_movie(name): gridreader = vtk.vtkXMLStructuredGridReader() #gridreader=vtk.vtkImageReader() gridreader.SetFileName(name) gridreader.Update() grid = gridreader.GetOutput() data = grid.GetPointData() points = grid.GetPoints() dims = grid.GetDimensions() #velocity=data.GetArray("v") #phase=data.GetArray("phi") #print phase velocity = data.GetArray("Velocity") phase = data.GetArray("Phase") #data.SetActiveScalars("Phase") phase_image = vtk.vtkImageData() phase_image.SetSpacing(1.0, 1.0, 1.0) phase_image.SetOrigin(0.0, 0.0, 0.0) phase_image.SetDimensions(dims[0], dims[1], dims[2]) phase_image.GetPointData().SetScalars(phase) phase_image.GetPointData().SetVectors(velocity) outline = vtk.vtkOutlineFilter() outline.SetInput(phase_image) outlineMapper = vtk.vtkDataSetMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) extract = vtk.vtkExtractVOI() extract.SetInput(phase_image) extract.SetVOI(0, 0, 0, dims[1] - 1, 0, dims[2] - 1) extract.Update() contour = vtk.vtkContourFilter() #contour.SetInputConnection(phase_image.GetOutputPort()) contour.SetInput(phase_image) contour.SetValue(0, 0.0) contour.Update() contourMapper = vtk.vtkPolyDataMapper() #contourMapper.SetScalarRange(phase.GetRange()) contourMapper.SetInputConnection(contour.GetOutputPort()) contourActor = vtk.vtkActor() contourActor.SetMapper(contourMapper) ren = vtk.vtkRenderer() ren.AddActor(contourActor) ren.AddActor(outlineActor) ren.SetBackground(0.1, 0.2, 0.4) #ren.SetColor(0.1,0.5,0.2) #ren.SetViewport(0, 0, .3, 1) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(500, 500) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.Initialize() renWin.Render() numbers = 720 delta = 2.0 * math.pi / numbers cam = ren.GetActiveCamera() #cam.SetPosition(300,0,750) renWin.Render() xinit, yinit, zinit = cam.GetPosition() radius = math.sqrt(xinit**2 + yinit**2 + zinit**2) print xinit, yinit, zinit cam.SetViewUp(1.00000, 0.0000001, 0.00000) cam.Zoom(3) for counter, alpha in enumerate(numpy.arange(0, 2.0 * math.pi, delta)): cam.Azimuth(delta * 180.0 / math.pi) renWin.Render() im_filter = vtk.vtkWindowToImageFilter() im_filter.SetInput(renWin) writer = vtk.vtkJPEGWriter() file_name = "tmp/contour" + str(0) * (3 - len(str(counter))) + str( counter) + ".jpg" writer.SetFileName(file_name) writer.SetInput(im_filter.GetOutput()) writer.Write() iren.Start()
def Main(): global ren, sliders, planes, planeCuts, origins # Create the RenderWindow, Renderer and both Actors ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetMultiSamples(0) renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.RemoveObservers('RightButtonPressEvent') iren.AddObserver('RightButtonPressEvent', print_camera_settings, 1.0) iren.AddObserver('RightButtonPressEvent', after_print_camera_settings, -1.0) print "data: %s %s" % (sys.argv[1], sys.argv[2]) cfdreader = vtk.vtkStructuredPointsReader() cfdreader.SetFileName(sys.argv[1]) # setup wing data wingReader = vtk.vtkUnstructuredGridReader() wingReader.SetFileName(sys.argv[2]) wingReader.Update() wingMapper = vtk.vtkDataSetMapper() wingMapper.SetInputConnection(wingReader.GetOutputPort()) wingActor = vtk.vtkActor() wingActor.SetMapper(wingMapper) wingActor.GetProperty().SetColor(.4, .4, .4) planes = [ vtk.vtkPlane(), vtk.vtkPlane(), vtk.vtkPlane() ] planeCuts = [ vtk.vtkCutter(), vtk.vtkCutter(), vtk.vtkCutter() ] normals = [ [1, 0, 0], [1, 0, 0], [1, 0, 0] ] origins = [ [20, 0, 0], [100, 0, 0], [190, 0, 0] ] sliders = [ vtk.vtkSliderRepresentation2D(), vtk.vtkSliderRepresentation2D(), vtk.vtkSliderRepresentation2D() ] sliderWidgets = [ vtk.vtkSliderWidget(), vtk.vtkSliderWidget(), vtk.vtkSliderWidget() ] bPlaneToActor = [True, True, True] bWingToActor = True datamin = 0 datamax = 230 lut = vtk.vtkColorTransferFunction() lut.SetColorSpaceToHSV() lut.AddHSVPoint(datamin, 0, 1, 1) dis = (datamax - datamin) / 7 for i in range(0, 8): lut.AddHSVPoint(datamin + dis * i, 0.1 * i, 1, 1) for i in range(0, len(planes)): planes[i].SetOrigin(origins[i]) planes[i].SetNormal(normals[i]) planeCuts[i].SetInputConnection(cfdreader.GetOutputPort()) planeCuts[i].SetCutFunction(planes[i]) arrowSource = vtk.vtkArrowSource() arrowSource.SetTipLength(0.3) arrowSource.SetShaftRadius(0.001) vectorGlyph = vtk.vtkGlyph3D() vectorGlyph.SetInputConnection(0, planeCuts[i].GetOutputPort()) vectorGlyph.SetInputConnection(1, arrowSource.GetOutputPort()) vectorGlyph.ScalingOn() vectorGlyph.SetScaleModeToScaleByVector() vectorGlyph.SetScaleFactor(0.35) vectorGlyph.OrientOn() vectorGlyph.ClampingOff() vectorGlyph.SetVectorModeToUseVector() vectorGlyph.SetIndexModeToOff() cutMapper = vtk.vtkDataSetMapper() cutMapper.SetLookupTable(lut) cutMapper.SetScalarRange(vectorGlyph.GetRange()) cutMapper.SetInputConnection(vectorGlyph.GetOutputPort()) cutActor = vtk.vtkActor() cutActor.SetMapper(cutMapper) cutActor.GetProperty().SetOpacity(0.4); cutActor.GetProperty().SetColor(0, 1, 0) if bPlaneToActor[i]: ren.AddActor(cutActor) sliders[i].SetMinimumValue(-50) sliders[i].SetMaximumValue(230) sliders[i].SetValue(origins[i][0]) sliders[i].SetTitleText("x-axis of plane %d" % i) sliders[i].GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay() sliders[i].GetPoint1Coordinate().SetValue(0.0, 1 - 0.1 * (i + 1)) sliders[i].GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay() sliders[i].GetPoint2Coordinate().SetValue(0.2, 1 - 0.1 * (i + 1)) sliders[i].SetSliderLength(0.02) sliders[i].SetSliderWidth(0.03) sliders[i].SetEndCapLength(0.01) sliders[i].SetEndCapWidth(0.03) sliders[i].SetTubeWidth(0.005) sliders[i].SetLabelFormat("%3.0lf") sliders[i].SetTitleHeight(0.02) sliders[i].SetLabelHeight(0.02) sliderWidgets[i].SetInteractor(iren) sliderWidgets[i].SetRepresentation(sliders[i]) sliderWidgets[i].KeyPressActivationOff() sliderWidgets[i].SetAnimationModeToAnimate() sliderWidgets[i].SetEnabled(False) sliderWidgets[i].AddObserver("InteractionEvent", sliderHandler) if bWingToActor: ren.AddActor(wingActor) ren.SetBackground(0, 0, 0) renWin.SetSize(1600, 900) ren.ResetCamera() ren.GetActiveCamera().SetClippingRange(203.2899494251721, 731.8103494457274) ren.GetActiveCamera().SetFocalPoint(118.72183980792761, 0.00012969970703125, 36.469017028808594) ren.GetActiveCamera().SetPosition(300.86018729049954, -5.765715551063601, 435.4418666873332) ren.GetActiveCamera().SetViewUp(-0.802117714199773, -0.005112780752923929, 0.5971440630533839) # Render iren.Initialize() renWin.Render() iren.Start()
def testFreetypeTextMapper(self): currentFontSize = 16 defaultText = "ABCDEFGHIJKLMnopqrstuvwxyz 0123456789 !@#$%()-=_+{};:,./<>?" textColor = [246, 255, 11] bgColor = [56, 56, 154] for i in range(0, len(textColor)): textColor[i] /= 255.0 bgColor[i] /= 255.0 renWin = vtk.vtkRenderWindow() renWin.SetSize(790, 351) ren = vtk.vtkRenderer() ren.SetBackground(bgColor) renWin.AddRenderer(ren) families = ["Arial", "Courier", "Times"] attributes = [[0, 0, 0], [0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 1, 0]] # bold, italic, shadow def SetAttributesText(attrib): """ Expects a list of attributes of size 3, returns a string """ s = "" if attrib[0] != 0: s += "b" if attrib[1] != 0: s += "i" if attrib[2] != 0: s += "s" return ','.join(list(s)) mapper = dict() actor = dict() pos = 0 for i, family in enumerate(families): for j, attrib in enumerate(attributes): pos += 1 txt = "" txtAttrib = SetAttributesText(attrib) if len(txtAttrib) != 0: txt = family + " (" + SetAttributesText( attrib) + "): " + defaultText else: txt = family + ": " + defaultText idx = ''.join(map(str, [i, j])) mapper.update({idx: vtk.vtkOpenGLFreeTypeTextMapper()}) mapper[idx].SetInput(txt) tprop = mapper[idx].GetTextProperty() eval('tprop.SetFontFamilyTo' + family + '()') tprop.SetColor(textColor) tprop.SetBold(attrib[0]) tprop.SetItalic(attrib[1]) tprop.SetShadow(attrib[2]) tprop.SetFontSize(currentFontSize) actor.update({idx: vtk.vtkActor2D()}) actor[idx].SetMapper(mapper[idx]) actor[idx].SetDisplayPosition(10, pos * (currentFontSize + 5)) ren.AddActor(actor[idx]) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) renWin.Render() img_file = "TestFreetypeTextMapper.png" vtk.test.Testing.compareImage( iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def __init__(self, vtkWidget=None): self.ren = vtk.vtkRenderer() self.window = vtkWidget.GetRenderWindow() self.window.AddRenderer(self.ren) self.iren = self.window.GetInteractor() self.iren.Initialize()#SetRenderWindow(self.window) # # this is the time for delay the action # self.fps = 10.0 # # # Create plane # planeSource = vtk.vtkPlaneSource(); # planeSource.SetCenter(0.0, 0.0, 0.0) # planeSource.SetNormal(0.0, 0.0, 1.0) # planeSource.SetResolution(10,10) # planeSource.Update() # # planeMapper = vtk.vtkPolyDataMapper(); # if(vtk.vtkVersion.GetVTKMajorVersion()<= 5): # planeMapper.SetInput(planeSource.GetOutput()) # else: # planeMapper.SetInputData(planeSource.GetOutput()) # # # planeActor = vtk.vtkActor() # planeActor.SetMapper(planeMapper) # # self.ren.AddActor(planeActor) # # Create cone # coneSource = vtk.vtkConeSource() # coneSource.SetCenter(0.2,0.0,0.15) # coneSource.SetHeight(0.3) # coneSource.SetDirection(0.0,0.0,1.0) # coneSource.SetAngle(30.0) # coneSource.SetResolution(36) # coneSource.Update() # # coneMapper = vtk.vtkPolyDataMapper() # if(vtk.vtkVersion.GetVTKMajorVersion()<= 5): # coneMapper.SetInput(coneSource.GetOutput()) # else: # coneMapper.SetInputData(coneSource.GetOutput()) # # coneActor = vtk.vtkActor() # coneActor.SetMapper(coneMapper) # coneActor.GetProperty().SetColor(1.0,1.0,0.0) # self.ren.AddActor(coneActor) # # # Create sphere # sphereSource = vtk.vtkSphereSource() # sphereSource.SetCenter(0.3,0.3,0.3) # sphereSource.SetPhiResolution(10) # sphereSource.SetThetaResolution(36) # sphereSource.SetRadius(0.15) # sphereSource.Update() # # sphereMapper = vtk.vtkPolyDataMapper() # if(vtk.vtkVersion.GetVTKMajorVersion()<= 5): # sphereMapper.SetInput(sphereSource.GetOutput()) # else: # sphereMapper.SetInputData(sphereSource.GetOutput()) # # sphereActor = vtk.vtkActor() # sphereActor.SetMapper(sphereMapper) # sphereActor.GetProperty().SetColor(0.0,0.5,1.0) # self.ren.AddActor(sphereActor) # Create orientation axes axes = vtk.vtkAxesActor() axes.SetShaftTypeToCylinder() self.orient = vtk.vtkOrientationMarkerWidget() self.orient.SetOrientationMarker( axes ) #self.orient.SetInteractor( self.iren ) # self.orient.SetViewport( 0.0, 0.0, 0.2, 0.2 )#self.orient.SetViewport( 0.0, 0.0, 0.2, 0.2 ) # self.orient.SetEnabled(1) # Needed to set InteractiveOff # self.orient.InteractiveOff() # self.orient.SetEnabled(0) self.ren.ResetCamera()
def main(): colors = vtk.vtkNamedColors() # We are going to handle two different sources. # The first source is a superquadric source. torus = vtk.vtkSuperquadricSource() torus.SetCenter(0.0, 0.0, 0.0) torus.SetScale(1.0, 1.0, 1.0) torus.SetPhiResolution(64) torus.SetThetaResolution(64) torus.SetThetaRoundness(1) torus.SetThickness(0.5) torus.SetSize(0.5) torus.SetToroidal(1) # Rotate the torus towards the observer (around the x-axis) torusT = vtk.vtkTransform() torusT.RotateX(55) torusTF = vtk.vtkTransformFilter() torusTF.SetInputConnection(torus.GetOutputPort()) torusTF.SetTransform(torusT) # The quadric is made of strips, so pass it through a triangle filter as # the curvature filter only operates on polys tri = vtk.vtkTriangleFilter() tri.SetInputConnection(torusTF.GetOutputPort()) # The quadric has nasty discontinuities from the way the edges are generated # so let's pass it though a CleanPolyDataFilter and merge any points which # are coincident, or very close cleaner = vtk.vtkCleanPolyData() cleaner.SetInputConnection(tri.GetOutputPort()) cleaner.SetTolerance(0.005) # The next source will be a parametric function rh = vtk.vtkParametricRandomHills() rhFnSrc = vtk.vtkParametricFunctionSource() rhFnSrc.SetParametricFunction(rh) # Now we have the sources, lets put them into a list. sources = list() sources.append(cleaner) sources.append(cleaner) sources.append(rhFnSrc) sources.append(rhFnSrc) # Colour transfer function. ctf = vtk.vtkColorTransferFunction() ctf.SetColorSpaceToDiverging() p1 = [0.0] + list(colors.GetColor3d('MidnightBlue')) p2 = [1.0] + list(colors.GetColor3d('DarkOrange')) ctf.AddRGBPoint(*p1) ctf.AddRGBPoint(*p2) cc = list() for i in range(256): cc.append(ctf.GetColor(float(i) / 255.0)) # Lookup table. lut = list() for idx in range(len(sources)): lut.append(vtk.vtkLookupTable()) lut[idx].SetNumberOfColors(256) for i, item in enumerate(cc): lut[idx].SetTableValue(i, item[0], item[1], item[2], 1.0) if idx == 0: lut[idx].SetRange(-10, 10) if idx == 1: lut[idx].SetRange(0, 4) if idx == 2: lut[idx].SetRange(-1, 1) if idx == 3: lut[idx].SetRange(-1, 1) lut[idx].Build() curvatures = list() for idx in range(len(sources)): curvatures.append(vtk.vtkCurvatures()) if idx % 2 == 0: curvatures[idx].SetCurvatureTypeToGaussian() else: curvatures[idx].SetCurvatureTypeToMean() renderers = list() mappers = list() actors = list() textmappers = list() textactors = list() # Create a common text property. textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(24) textProperty.SetJustificationToCentered() names = [ 'Torus - Gaussian Curvature', 'Torus - Mean Curvature', 'Random Hills - Gaussian Curvature', 'Random Hills - Mean Curvature' ] # Link the pipeline together. for idx, item in enumerate(sources): sources[idx].Update() curvatures[idx].SetInputConnection(sources[idx].GetOutputPort()) mappers.append(vtk.vtkPolyDataMapper()) mappers[idx].SetInputConnection(curvatures[idx].GetOutputPort()) mappers[idx].SetLookupTable(lut[idx]) mappers[idx].SetUseLookupTableScalarRange(1) actors.append(vtk.vtkActor()) actors[idx].SetMapper(mappers[idx]) textmappers.append(vtk.vtkTextMapper()) textmappers[idx].SetInput(names[idx]) textmappers[idx].SetTextProperty(textProperty) textactors.append(vtk.vtkActor2D()) textactors[idx].SetMapper(textmappers[idx]) textactors[idx].SetPosition(250, 16) renderers.append(vtk.vtkRenderer()) gridDimensions = 2 rendererSize = 512 for idx in range(len(sources)): if idx < gridDimensions * gridDimensions: renderers.append(vtk.vtkRenderer) # Create the RenderWindow # renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(rendererSize * gridDimensions, rendererSize * gridDimensions) renderWindow.SetWindowName('CurvaturesDemo') # Add and position the renders to the render window. viewport = list() for row in range(gridDimensions): for col in range(gridDimensions): idx = row * gridDimensions + col viewport[:] = [] viewport.append(float(col) / gridDimensions) viewport.append(float(gridDimensions - (row + 1)) / gridDimensions) viewport.append(float(col + 1) / gridDimensions) viewport.append(float(gridDimensions - row) / gridDimensions) if idx > (len(sources) - 1): continue renderers[idx].SetViewport(viewport) renderWindow.AddRenderer(renderers[idx]) renderers[idx].AddActor(actors[idx]) renderers[idx].AddActor(textactors[idx]) renderers[idx].SetBackground(colors.GetColor3d('CornflowerBlue')) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
def contour_movie_vti(name): #gridreader = vtk.vtkXMLStructuredGridReader() gridreader = vtk.vtkXMLImageDataReader() gridreader.SetFileName(name) gridreader.Update() grid = gridreader.GetOutput() data = grid.GetPointData() #dims =grid.GetDimensions() #print "Dims=",dims velocity = data.GetArray("v") phase = data.GetArray("phi") data.SetScalars(phase) data.SetVectors(velocity) print "Phase=", phase print "Data=", data outline = vtk.vtkOutlineFilter() outline.SetInputConnection(gridreader.GetOutputPort()) #outline.SetInput(grid) outlineMapper = vtk.vtkDataSetMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) contour = vtk.vtkContourFilter() #contour.SetInputConnection(phase_image.GetOutputPort()) #contour.SetInput(phase_image) contour.SetInputConnection(gridreader.GetOutputPort()) contour.SetValue(0, 0.0) contour.Update() contourMapper = vtk.vtkPolyDataMapper() #contourMapper.SetScalarRange(phase.GetRange()) contourMapper.SetInputConnection(contour.GetOutputPort()) contourActor = vtk.vtkActor() contourActor.SetMapper(contourMapper) ren = vtk.vtkRenderer() ren.AddActor(contourActor) ren.AddActor(outlineActor) ren.SetBackground(0.1, 0.2, 0.4) #ren.SetColor(0.1,0.5,0.2) #ren.SetViewport(0, 0, .3, 1) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(500, 500) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.Initialize() renWin.Render() numbers = 720 delta = 2.0 * math.pi / numbers cam = ren.GetActiveCamera() print "Camera=", cam.GetViewUp() xinit, yinit, zinit = cam.GetPosition() radius = math.sqrt(xinit**2 + yinit**2 + zinit**2) print xinit, yinit, zinit #cam.Azimuth(delta*50) #contourActor.RotateWXYZ(25,1,0,0) #renWin.Render() #cam.Zoom(3) cam.SetViewUp(1, 0, 0) for counter, alpha in enumerate(numpy.arange(0, 2.0 * math.pi, delta)): cam.Azimuth(delta * 180.0 / math.pi) #contourActor.RotateWXYZ(delta*180/math.pi,0,1,0) #outlineActor.RotateWXYZ(delta*180/math.pi,0,1,0) renWin.Render() im_filter = vtk.vtkWindowToImageFilter() im_filter.SetInput(renWin) writer = vtk.vtkJPEGWriter() file_name = "tmp/contour" + str(0) * (3 - len(str(counter))) + str( counter) + ".jpg" writer.SetFileName(file_name) writer.SetInput(im_filter.GetOutput()) writer.Write() iren.Start()
def main(): SHOW_AXES = True SHOW_SCENE_AXES = True SHOW_COIL_AXES = True SHOW_SKIN = True SHOW_BRAIN = True SHOW_COIL = True SHOW_MARKERS = True TRANSF_COIL = True SHOW_PLANE = False SELECT_LANDMARKS = 'scalp' # 'all', 'mri' 'scalp' SAVE_ID = False AFFINE_IMG = True NO_SCALE = True SCREENSHOT = False reorder = [0, 2, 1] flipx = [True, False, False] # reorder = [0, 1, 2] # flipx = [False, False, False] # default folder and subject subj = 'S5' # 1 - 9 id_extra = False # 8, 9, 10, 12, False data_dir = r'P:\tms_eeg\mTMS\projects\2016 Lateral ppTMS M1\E-fields' simnibs_dir = os.path.join(data_dir, 'simnibs', 'm2m_ppM1_{}_nc'.format(subj)) if id_extra and subj == 'S1': subj_id = '{}_{}'.format(subj, id_extra) else: subj_id = '{}'.format(subj) nav_dir = os.path.join(data_dir, 'nav_coordinates', 'ppM1_{}'.format(subj_id)) # filenames coil_file = os.path.join(os.environ['OneDrive'], 'data', 'nexstim_coord', 'magstim_fig8_coil.stl') coord_file = os.path.join(nav_dir, 'ppM1_eximia_{}.txt'.format(subj_id)) img_file = os.path.join(data_dir, r'mri\ppM1_{}\ppM1_{}.nii'.format(subj, subj)) brain_file = os.path.join(simnibs_dir, 'wm.stl') skin_file = os.path.join(simnibs_dir, 'skin.stl') output_file = os.path.join(nav_dir, 'transf_mat_{}'.format(subj_id)) coords = lc.load_nexstim(coord_file) # red, green, blue, maroon (dark red), # olive (shitty green), teal (petrol blue), yellow, orange col = [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.], [1., .0, 1.], [.5, .5, 0.], [0., .5, .5], [1., 1., 0.], [1., .4, .0]] # extract image header shape and affine transformation from original nifti file imagedata = nb.squeeze_image(nb.load(img_file)) imagedata = nb.as_closest_canonical(imagedata) imagedata.update_header() pix_dim = imagedata.header.get_zooms() img_shape = imagedata.header.get_data_shape() print("Pixel size: \n") print(pix_dim) print("\nImage shape: \n") print(img_shape) affine_aux = imagedata.affine.copy() if NO_SCALE: scale, shear, angs, trans, persp = tf.decompose_matrix( imagedata.affine) affine_aux = tf.compose_matrix(scale=None, shear=shear, angles=angs, translate=trans, perspective=persp) if AFFINE_IMG: affine = affine_aux # if NO_SCALE: # scale, shear, angs, trans, persp = tf.decompose_matrix(imagedata.affine) # affine = tf.compose_matrix(scale=None, shear=shear, angles=angs, translate=trans, perspective=persp) else: affine = np.identity(4) # affine_I = np.identity(4) # create a camera, render window and renderer camera = vtk.vtkCamera() camera.SetPosition(0, 1000, 0) camera.SetFocalPoint(0, 0, 0) camera.SetViewUp(0, 0, 1) camera.ComputeViewPlaneNormal() camera.Azimuth(90.0) camera.Elevation(10.0) ren = vtk.vtkRenderer() ren.SetActiveCamera(camera) ren.ResetCamera() camera.Dolly(1.5) ren_win = vtk.vtkRenderWindow() ren_win.AddRenderer(ren) ren_win.SetSize(800, 800) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(ren_win) if SELECT_LANDMARKS == 'mri': # MRI landmarks coord_mri = [['Nose/Nasion'], ['Left ear'], ['Right ear'], ['Coil Loc'], ['EF max']] pts_ref = [1, 2, 3, 7, 10] elif SELECT_LANDMARKS == 'all': # all coords coord_mri = [['Nose/Nasion'], ['Left ear'], ['Right ear'], ['Nose/Nasion'], ['Left ear'], ['Right ear'], ['Coil Loc'], ['EF max']] pts_ref = [1, 2, 3, 5, 4, 6, 7, 10] elif SELECT_LANDMARKS == 'scalp': # scalp landmarks coord_mri = [['Nose/Nasion'], ['Left ear'], ['Right ear'], ['Coil Loc'], ['EF max']] hdr_mri = [ 'Nose/Nasion', 'Left ear', 'Right ear', 'Coil Loc', 'EF max' ] pts_ref = [5, 4, 6, 7, 10] coords_np = np.zeros([len(pts_ref), 3]) for n, pts_id in enumerate(pts_ref): # to keep in the MRI space use the identity as the affine # coord_aux = n2m.coord_change(coords[pts_id][1:], img_shape, affine_I, flipx, reorder) # affine_trans = affine_I.copy() # affine_trans = affine.copy() # affine_trans[:3, -1] = affine[:3, -1] coord_aux = n2m.coord_change(coords[pts_id][1:], img_shape, affine, flipx, reorder) coords_np[n, :] = coord_aux [coord_mri[n].append(s) for s in coord_aux] if SHOW_MARKERS: marker_actor = add_marker(coord_aux, ren, col[n]) if id_extra: # compare coil locations in experiments with 8, 9, 10 and 12 mm shifts # MRI Nexstim space: 8, 9, 10, 12 mm coil locations # coord_others = [[122.2, 198.8, 99.7], # [121.1, 200.4, 100.1], # [120.5, 200.7, 98.2], # [117.7, 202.9, 96.6]] if AFFINE_IMG: # World space: 8, 9, 10, 12 mm coil locations coord_others = [ [-42.60270233154297, 28.266497802734378, 81.02450256347657], [-41.50270233154296, 28.66649780273437, 82.62450256347657], [-40.90270233154297, 26.766497802734378, 82.92450256347655], [-38.10270233154297, 25.16649780273437, 85.12450256347657] ] else: # MRI space reordered and flipped: 8, 9, 10, 12 mm coil locations coord_others = [[27.8, 99.7, 198.8], [28.9, 100.1, 200.4], [29.5, 98.2, 200.7], [32.3, 96.6, 202.9]] col_others = [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.], [0., 0., 0.]] for n, c in enumerate(coord_others): marker_actor = add_marker(c, ren, col_others[n]) print('\nOriginal coordinates from Nexstim: \n') [print(s) for s in coords] print('\nMRI coordinates flipped and reordered: \n') [print(s) for s in coords_np] print('\nTransformed coordinates to MRI space: \n') [print(s) for s in coord_mri] # coil location, normal vector and direction vector coil_loc = coord_mri[-2][1:] coil_norm = coords[8][1:] coil_dir = coords[9][1:] # creating the coil coordinate system by adding a point in the direction of each given coil vector # the additional vector is just the cross product from coil direction and coil normal vectors # origin of the coordinate system is the coil location given by Nexstim # the vec_length is to allow line creation with visible length in VTK scene vec_length = 75 p1 = coords[7][1:] p2 = [x + vec_length * y for x, y in zip(p1, coil_norm)] p2_norm = n2m.coord_change(p2, img_shape, affine, flipx, reorder) p2 = [x + vec_length * y for x, y in zip(p1, coil_dir)] p2_dir = n2m.coord_change(p2, img_shape, affine, flipx, reorder) coil_face = np.cross(coil_norm, coil_dir) p2 = [x - vec_length * y for x, y in zip(p1, coil_face.tolist())] p2_face = n2m.coord_change(p2, img_shape, affine, flipx, reorder) # Coil face unit vector (X) u1 = np.asarray(p2_face) - np.asarray(coil_loc) u1_n = u1 / np.linalg.norm(u1) # Coil direction unit vector (Y) u2 = np.asarray(p2_dir) - np.asarray(coil_loc) u2_n = u2 / np.linalg.norm(u2) # Coil normal unit vector (Z) u3 = np.asarray(p2_norm) - np.asarray(coil_loc) u3_n = u3 / np.linalg.norm(u3) transf_matrix = np.identity(4) if TRANSF_COIL: transf_matrix[:3, 0] = u1_n transf_matrix[:3, 1] = u2_n transf_matrix[:3, 2] = u3_n transf_matrix[:3, 3] = coil_loc[:] # the absolute value of the determinant indicates the scaling factor # the sign of the determinant indicates how it affects the orientation: if positive maintain the # original orientation and if negative inverts all the orientations (flip the object inside-out)' # the negative determinant is what makes objects in VTK scene to become black print('Transformation matrix: \n', transf_matrix, '\n') print('Determinant: ', np.linalg.det(transf_matrix)) if SAVE_ID: coord_dict = { 'm_affine': transf_matrix, 'coords_labels': hdr_mri, 'coords': coords_np } io.savemat(output_file + '.mat', coord_dict) hdr_names = ';'.join( ['m' + str(i) + str(j) for i in range(1, 5) for j in range(1, 5)]) np.savetxt(output_file + '.txt', transf_matrix.reshape([1, 16]), delimiter=';', header=hdr_names) if SHOW_BRAIN: if AFFINE_IMG: brain_actor = load_stl(brain_file, ren, colour=[0., 1., 1.], opacity=1.) else: # to visualize brain in MRI space brain_actor = load_stl(brain_file, ren, colour=[0., 1., 1.], opacity=1., user_matrix=np.linalg.inv(affine_aux)) if SHOW_SKIN: if AFFINE_IMG: skin_actor = load_stl(skin_file, ren, colour="SkinColor", opacity=.4) else: # to visualize skin in MRI space skin_actor = load_stl(skin_file, ren, colour="SkinColor", opacity=.4, user_matrix=np.linalg.inv(affine_aux)) if SHOW_COIL: # reposition STL object prior to transformation matrix # [translation_x, translation_y, translation_z, rotation_x, rotation_y, rotation_z] # old translation when using Y as normal vector # repos = [0., -6., 0., 0., -90., 90.] # Translate coil loc coordinate to coil bottom # repos = [0., 0., 5.5, 0., 0., 180.] repos = [0., 0., 0., 0., 0., 180.] # SimNIBS coil orientation requires 180deg around Y # Ry = tf.rotation_matrix(np.pi, [0, 1, 0], [0, 0, 0]) # transf_matrix = transf_matrix @ Ry act_coil = load_stl(coil_file, ren, replace=repos, user_matrix=transf_matrix, opacity=.3) if SHOW_PLANE: act_plane = add_plane(ren, user_matrix=transf_matrix) # Add axes to scene origin if SHOW_AXES: add_line(ren, [0, 0, 0], [150, 0, 0], color=[1.0, 0.0, 0.0]) add_line(ren, [0, 0, 0], [0, 150, 0], color=[0.0, 1.0, 0.0]) add_line(ren, [0, 0, 0], [0, 0, 150], color=[0.0, 0.0, 1.0]) # Add axes to object origin if SHOW_COIL_AXES: add_line(ren, coil_loc, p2_norm, color=[.0, .0, 1.0]) add_line(ren, coil_loc, p2_dir, color=[.0, 1.0, .0]) add_line(ren, coil_loc, p2_face, color=[1.0, .0, .0]) # Add interactive axes to scene if SHOW_SCENE_AXES: axes = vtk.vtkAxesActor() widget = vtk.vtkOrientationMarkerWidget() widget.SetOutlineColor(0.9300, 0.5700, 0.1300) widget.SetOrientationMarker(axes) widget.SetInteractor(iren) # widget.SetViewport(0.0, 0.0, 0.4, 0.4) widget.SetEnabled(1) widget.InteractiveOn() if SCREENSHOT: # screenshot of VTK scene w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(ren_win) w2if.Update() writer = vtk.vtkPNGWriter() writer.SetFileName("screenshot.png") writer.SetInput(w2if.GetOutput()) writer.Write() # Enable user interface interactor # ren_win.Render() ren.ResetCameraClippingRange() iren.Initialize() iren.Start()
sampleActor = vtk.vtkActor() sampleActor.SetMapper(sampleMapper) # Create an outline outline = vtk.vtkOutlineFilter() outline.SetInputConnection(sample.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) # Create the RenderWindow, Renderer and both Actors # ren0 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren0) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add the actors to the renderer, set the background and size # ren0.AddActor(sampleActor) ren0.AddActor(outlineActor) ren0.SetBackground(0.1, 0.2, 0.4) renWin.SetSize(250, 250) cam = ren0.GetActiveCamera() cam.SetFocalPoint(0, 0, 0)
def main(): colors = vtk.vtkNamedColors() # Set the background color. colors.SetColor('BkgColor', [26, 51, 77, 255]) # Create a cylinder. # Cylinder height vector is (0,1,0). # Cylinder center is in the middle of the cylinder cylinderSource = vtk.vtkCylinderSource() cylinderSource.SetResolution(15) # Generate a random start and end point startPoint = [0] * 3 endPoint = [0] * 3 rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(8775070) # For testing. for i in range(0, 3): rng.Next() startPoint[i] = rng.GetRangeValue(-10, 10) rng.Next() endPoint[i] = rng.GetRangeValue(-10, 10) # Compute a basis normalizedX = [0] * 3 normalizedY = [0] * 3 normalizedZ = [0] * 3 # The X axis is a vector from start to end vtk.vtkMath.Subtract(endPoint, startPoint, normalizedX) length = vtk.vtkMath.Norm(normalizedX) vtk.vtkMath.Normalize(normalizedX) # The Z axis is an arbitrary vector cross X arbitrary = [0] * 3 for i in range(0, 3): rng.Next() arbitrary[i] = rng.GetRangeValue(-10, 10) vtk.vtkMath.Cross(normalizedX, arbitrary, normalizedZ) vtk.vtkMath.Normalize(normalizedZ) # The Y axis is Z cross X vtk.vtkMath.Cross(normalizedZ, normalizedX, normalizedY) matrix = vtk.vtkMatrix4x4() # Create the direction cosine matrix matrix.Identity() for i in range(0, 3): matrix.SetElement(i, 0, normalizedX[i]) matrix.SetElement(i, 1, normalizedY[i]) matrix.SetElement(i, 2, normalizedZ[i]) # Apply the transforms transform = vtk.vtkTransform() transform.Translate(startPoint) # translate to starting point transform.Concatenate(matrix) # apply direction cosines transform.RotateZ(-90.0) # align cylinder to x axis transform.Scale(1.0, length, 1.0) # scale along the height vector transform.Translate(0, .5, 0) # translate to start of cylinder # Transform the polydata transformPD = vtk.vtkTransformPolyDataFilter() transformPD.SetTransform(transform) transformPD.SetInputConnection(cylinderSource.GetOutputPort()) # Create a mapper and actor for the arrow mapper = vtk.vtkPolyDataMapper() actor = vtk.vtkActor() if USER_MATRIX: mapper.SetInputConnection(cylinderSource.GetOutputPort()) actor.SetUserMatrix(transform.GetMatrix()) else: mapper.SetInputConnection(transformPD.GetOutputPort()) actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.GetColor3d('Cyan')) # Create spheres for start and end point sphereStartSource = vtk.vtkSphereSource() sphereStartSource.SetCenter(startPoint) sphereStartSource.SetRadius(0.8) sphereStartMapper = vtk.vtkPolyDataMapper() sphereStartMapper.SetInputConnection(sphereStartSource.GetOutputPort()) sphereStart = vtk.vtkActor() sphereStart.SetMapper(sphereStartMapper) sphereStart.GetProperty().SetColor(colors.GetColor3d('Yellow')) sphereEndSource = vtk.vtkSphereSource() sphereEndSource.SetCenter(endPoint) sphereEndSource.SetRadius(0.8) sphereEndMapper = vtk.vtkPolyDataMapper() sphereEndMapper.SetInputConnection(sphereEndSource.GetOutputPort()) sphereEnd = vtk.vtkActor() sphereEnd.SetMapper(sphereEndMapper) sphereEnd.GetProperty().SetColor(colors.GetColor3d('Magenta')) # Create a renderer, render window, and interactor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.SetWindowName('Oriented Cylinder') renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Add the actor to the scene renderer.AddActor(actor) renderer.AddActor(sphereStart) renderer.AddActor(sphereEnd) renderer.SetBackground(colors.GetColor3d('BkgColor')) # Render and interact renderWindow.Render() renderWindowInteractor.Start()
def main(): colors = vtk.vtkNamedColors() # # Next we create an instance of vtkConeSource and set some of its # properties. The instance of vtkConeSource 'cone' is part of a visualization # pipeline (it is a source process object); it produces data (output type is # vtkPolyData) which other filters may process. # cone = vtk.vtkConeSource() cone.SetHeight(3.0) cone.SetRadius(1.0) cone.SetResolution(10) # # In this example we terminate the pipeline with a mapper process object. # (Intermediate filters such as vtkShrinkPolyData could be inserted in # between the source and the mapper.) We create an instance of # vtkPolyDataMapper to map the polygonal data into graphics primitives. We # connect the output of the cone source to the input of this mapper. # coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInputConnection(cone.GetOutputPort()) # # Create an actor to represent the first cone. The actor's properties are # modified to give it different surface properties. By default, an actor # is create with a property so the GetProperty() method can be used. # coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) coneActor.GetProperty().SetColor(colors.GetColor3d('Peacock')) coneActor.GetProperty().SetDiffuse(0.7) coneActor.GetProperty().SetSpecular(0.4) coneActor.GetProperty().SetSpecularPower(20) # # Create a property and directly manipulate it. Assign it to the # second actor. # property = vtk.vtkProperty() property.SetColor(colors.GetColor3d('Tomato')) property.SetDiffuse(0.7) property.SetSpecular(0.4) property.SetSpecularPower(20) # # Create a second actor and a property. The property is directly # manipulated and then assigned to the actor. In this way, a single # property can be shared among many actors. Note also that we use the # same mapper as the first actor did. This way we avoid duplicating # geometry, which may save lots of memory if the geometry is large. coneActor2 = vtk.vtkActor() coneActor2.SetMapper(coneMapper) # coneActor2.GetProperty().SetColor(colors.GetColor3d('Peacock')) coneActor2.SetProperty(property) coneActor2.SetPosition(0, 2, 0) # # Create the Renderer and assign actors to it. A renderer is like a # viewport. It is part or all of a window on the screen and it is responsible # for drawing the actors it has. We also set the background color here. # ren1 = vtk.vtkRenderer() ren1.AddActor(coneActor) ren1.AddActor(coneActor2) ren1.SetBackground(colors.GetColor3d('LightSlateGray')) # # Finally we create the render window which will show up on the screen # We put our renderer into the render window using AddRenderer. We also # set the size to be 300 pixels by 300. # renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) renWin.SetSize(640, 480) renWin.SetWindowName('Cone4') iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # # Now we loop over 60 degrees and render the cone each time. # ren1.GetActiveCamera().Elevation(30) ren1.ResetCamera() for i in range(0, 60): time.sleep(0.03) renWin.Render() ren1.GetActiveCamera().Azimuth(1) iren.Start()
def main(): fn1, fn2 = get_program_parameters() polyData1 = ReadPolyData(fn1) if fn2: polyData2 = ReadPolyData(fn1) else: # If only one polydata is present, generate a second polydata by # rotating the original about its center. print('Generating modified polyData1') center = polyData1.GetCenter() transform = vtk.vtkTransform() transform.Translate(center[0], center[1], center[2]) transform.RotateY(90.0) transform.Translate(-center[0], -center[1], -center[2]) transformPD = vtk.vtkTransformPolyDataFilter() transformPD.SetTransform(transform) transformPD.SetInputData(polyData1) transformPD.Update() polyData2 = transformPD.GetOutput() # Mark points inside with 1 and outside with a 0 select = vtk.vtkSelectEnclosedPoints() select.SetInputData(polyData1) select.SetSurfaceData(polyData2) # Extract three meshes, one completely inside, one completely # outside and on the border between the inside and outside. threshold = vtk.vtkMultiThreshold() # Outside points have a 0 value in ALL points of a cell outsideId = threshold.AddBandpassIntervalSet( 0, 0, vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, "SelectedPoints", 0, 1) # Inside points have a 1 value in ALL points of a cell insideId = threshold.AddBandpassIntervalSet( 1, 1, vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, "SelectedPoints", 0, 1) # Border points have a 0 or a 1 in at least one point of a cell borderId = threshold.AddIntervalSet( 0, 1, vtk.vtkMultiThreshold.OPEN, vtk.vtkMultiThreshold.OPEN, vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, "SelectedPoints", 0, 0) threshold.SetInputConnection(select.GetOutputPort()) # Select the intervals to be output threshold.OutputSet(outsideId) threshold.OutputSet(insideId) threshold.OutputSet(borderId) threshold.Update() # Visualize colors = vtk.vtkNamedColors() outsideColor = colors.GetColor3d("Crimson") insideColor = colors.GetColor3d("Banana") borderColor = colors.GetColor3d("Mint") surfaceColor = colors.GetColor3d("Peacock") backgroundColor = colors.GetColor3d("Silver") # Outside outsideMapper = vtk.vtkDataSetMapper() outsideMapper.SetInputData( threshold.GetOutput().GetBlock(outsideId).GetBlock(0)) outsideMapper.ScalarVisibilityOff() outsideActor = vtk.vtkActor() outsideActor.SetMapper(outsideMapper) outsideActor.GetProperty().SetDiffuseColor(outsideColor) outsideActor.GetProperty().SetSpecular(.6) outsideActor.GetProperty().SetSpecularPower(30) # Inside insideMapper = vtk.vtkDataSetMapper() insideMapper.SetInputData( threshold.GetOutput().GetBlock(insideId).GetBlock(0)) insideMapper.ScalarVisibilityOff() insideActor = vtk.vtkActor() insideActor.SetMapper(insideMapper) insideActor.GetProperty().SetDiffuseColor(insideColor) insideActor.GetProperty().SetSpecular(.6) insideActor.GetProperty().SetSpecularPower(30) insideActor.GetProperty().EdgeVisibilityOn() # Border borderMapper = vtk.vtkDataSetMapper() borderMapper.SetInputData( threshold.GetOutput().GetBlock(borderId).GetBlock(0)) borderMapper.ScalarVisibilityOff() borderActor = vtk.vtkActor() borderActor.SetMapper(borderMapper) borderActor.GetProperty().SetDiffuseColor(borderColor) borderActor.GetProperty().SetSpecular(.6) borderActor.GetProperty().SetSpecularPower(30) borderActor.GetProperty().EdgeVisibilityOn() surfaceMapper = vtk.vtkDataSetMapper() surfaceMapper.SetInputData(polyData2) surfaceMapper.ScalarVisibilityOff() # Surface of object containing cell surfaceActor = vtk.vtkActor() surfaceActor.SetMapper(surfaceMapper) surfaceActor.GetProperty().SetDiffuseColor(surfaceColor) surfaceActor.GetProperty().SetOpacity(.1) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.SetSize(640, 480) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.SetBackground(backgroundColor) renderer.UseHiddenLineRemovalOn() renderer.AddActor(surfaceActor) renderer.AddActor(outsideActor) renderer.AddActor(insideActor) renderer.AddActor(borderActor) renderWindow.SetWindowName('CellsInsideObject') renderWindow.Render() renderer.GetActiveCamera().Azimuth(30) renderer.GetActiveCamera().Elevation(30) renderer.GetActiveCamera().Dolly(1.25) renderWindow.Render() renderWindowInteractor.Start()
def render(self, color=None, opacity=1., view='+x', axes_scale=0., filename=None, window=None, renderer=None, interact=True): """ Plots the mesh on the provided vtkRenderWindow :param color: (N, 3) or (N, ) array defining the color across the mesh :param opacity: float setting the opacity of the surface :param view: where the object is viewed from; one of '+x', '-x', '+y', '-y', '+z', or '-z' or tuple with - vector pointing from the mesh center to the camera - vector defining the hemisphere that is up from the camera :param filename: if set saves the image to the given filename :param window: If provded the window on which the mesh will be plotted (otherwise a new window is created) :type window: vtk.vtkRenderWindow :param renderer: the VTK rendered to which the actor plotting the mesh will be added (default: a new one is created) :type renderer: vtk.vtkRenderer :param interact: if True allows interaction of the window (this will pause the evaulation) :return: the window the mesh is plotted on and the rendered doing the plotting :rtype: (vtk.vtkRenderWindow, vtk.vtkRenderer) """ import vtk if renderer is None: renderer = vtk.vtkRenderer() renderer.SetBackground(1, 1, 1) if window is None: window = vtk.vtkRenderWindow() window.SetSize(1000, 1000) renderer.AddActor(self.to_vtk_actor(color=color, opacity=opacity)) window.AddRenderer(renderer) if axes_scale > 0: vtk_axes = vtk.vtkAxesActor() transform = vtk.vtkTransform() transform.Scale(axes_scale, axes_scale, axes_scale) vtk_axes.SetUserTransform(transform) vtk_axes.SetAxisLabels(0) renderer.AddActor(vtk_axes) if isinstance(view, str): assert len(view) == 2 view = { '+x': ((1, 0, 0), (0, 0, 1)), '-x': ((-1, 0, 0), (0, 0, 1)), '+y': ((0, 1, 0), (0, 0, 1)), '-y': ((0, -1, 0), (0, 0, 1)), '+z': ((0, 0, 1), (0, 1, 0)), '-z': ((0, 0, -1), (0, 1, 0)) }[view] camera = renderer.GetActiveCamera() renderer.ResetCamera() camera.SetPosition( np.array(camera.GetFocalPoint()) + np.array(view[0])) camera.SetViewUp(view[1]) renderer.ResetCamera() window.Render() if filename is not None: imfilt = vtk.vtkWindowToImageFilter() imfilt.SetInput(window) imfilt.Update() pngwriter = vtk.vtkPNGWriter() pngwriter.SetInputData(imfilt.GetOutput()) pngwriter.SetFileName(filename) pngwriter.Write() if interact: interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(window) interactor.Start() return window, renderer
def render(self): try: pred_mask except NameError: pass else: pred_mask[pred_mask > 0.5] = 50 data_matrix = pred_mask.astype(np.uint8) m, n, z = data_matrix.shape # data_matrix[data_matrix>0.5]=50 vtk.vtkObject.GlobalWarningDisplayOff() dataImporter = vtk.vtkImageImport() data_string = data_matrix.tostring() dataImporter.CopyImportVoidPointer(data_string, len(data_string)) dataImporter.SetDataScalarTypeToUnsignedChar() dataImporter.SetNumberOfScalarComponents(1) dataImporter.SetDataExtent(0, z - 1, 0, n - 1, 0, m - 1) dataImporter.SetWholeExtent(0, z - 1, 0, n - 1, 0, m - 1) alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(0, 0.0) alphaChannelFunc.AddPoint(50, 2) colorFunc = vtk.vtkColorTransferFunction() colorFunc.AddRGBPoint(50, 1.0, 0.0, 0.0) colorFunc.AddRGBPoint(0, 0.0, 0.0, 0.0) # colorFunc.AddRGBPoint(150, 0.0, 0.0, 1.0) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorFunc) volumeProperty.SetScalarOpacity(alphaChannelFunc) compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetInputConnection(dataImporter.GetOutputPort()) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) renderer = vtk.vtkRenderer() renderWin = vtk.vtkRenderWindow() renderWin.AddRenderer(renderer) renderInteractor = vtk.vtkRenderWindowInteractor() renderInteractor.SetRenderWindow(renderWin) renderer.AddVolume(volume) renderer.SetBackground(1, 1, 1) renderWin.SetSize(400, 400) def exitCheck(obj, event): if obj.GetEventPending() != 0: obj.SetAbortRender(1) renderWin.AddObserver("AbortCheckEvent", exitCheck) renderInteractor.Initialize() renderWin.Render() renderWin.SetWindowName('3D Vessal') renderInteractor.Start()
def marching_cubes(mcCases, rotation=0, label=True): color = vtk.vtkNamedColors() # Rotate the final figure 0, 90, 180, 270 degrees. rotation = abs(int(rotation)) if rotation > 3: rotation = 0 if len(mcCases) > 1: print('Cases', ', '.join(map(str, mcCases))) else: print('Cases', ','.join(map(str, mcCases))) print('Rotated', rotation * 90, 'degrees.') renWin = vtk.vtkRenderWindow() renWin.SetSize(640, 480) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Always use a grid of four columns unless number of cases < 4. renderers = list() gridSize = ((len(mcCases) + 3) // 4) * 4 if len(mcCases) < 4: gridSize = len(mcCases) for i in range(0, gridSize): # Create the Renderer renderer = vtk.vtkRenderer() renderers.append(renderer) # Set the background color. renderers[i].SetBackground(color.GetColor3d('slate_grey')) renWin.AddRenderer(renderer) for i in range(0, len(mcCases)): # Define a Single Cube Scalars = vtk.vtkFloatArray() Scalars.InsertNextValue(1.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(1.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(0.0) Points = vtk.vtkPoints() Points.InsertNextPoint(0, 0, 0) Points.InsertNextPoint(1, 0, 0) Points.InsertNextPoint(1, 1, 0) Points.InsertNextPoint(0, 1, 0) Points.InsertNextPoint(0, 0, 1) Points.InsertNextPoint(1, 0, 1) Points.InsertNextPoint(1, 1, 1) Points.InsertNextPoint(0, 1, 1) Ids = vtk.vtkIdList() Ids.InsertNextId(0) Ids.InsertNextId(1) Ids.InsertNextId(2) Ids.InsertNextId(3) Ids.InsertNextId(4) Ids.InsertNextId(5) Ids.InsertNextId(6) Ids.InsertNextId(7) Grid = vtk.vtkUnstructuredGrid() Grid.Allocate(10, 10) Grid.InsertNextCell(12, Ids) Grid.SetPoints(Points) Grid.GetPointData().SetScalars(Scalars) # Find the triangles that lie along the 0.5 contour in this cube. Marching = vtk.vtkContourFilter() Marching.SetInputData(Grid) Marching.SetValue(0, 0.5) Marching.Update() # Extract the edges of the triangles just found. triangleEdges = vtk.vtkExtractEdges() triangleEdges.SetInputConnection(Marching.GetOutputPort()) # Draw the edges as tubes instead of lines. Also create the associated # mapper and actor to display the tubes. triangleEdgeTubes = vtk.vtkTubeFilter() triangleEdgeTubes.SetInputConnection(triangleEdges.GetOutputPort()) triangleEdgeTubes.SetRadius(.005) triangleEdgeTubes.SetNumberOfSides(6) triangleEdgeTubes.UseDefaultNormalOn() triangleEdgeTubes.SetDefaultNormal(.577, .577, .577) triangleEdgeMapper = vtk.vtkPolyDataMapper() triangleEdgeMapper.SetInputConnection(triangleEdgeTubes.GetOutputPort()) triangleEdgeMapper.ScalarVisibilityOff() triangleEdgeActor = vtk.vtkActor() triangleEdgeActor.SetMapper(triangleEdgeMapper) triangleEdgeActor.GetProperty().SetDiffuseColor( color.GetColor3d('lamp_black')) triangleEdgeActor.GetProperty().SetSpecular(.4) triangleEdgeActor.GetProperty().SetSpecularPower(10) # Shrink the triangles we found earlier. Create the associated mapper # and actor. Set the opacity of the shrunken triangles. aShrinker = vtk.vtkShrinkPolyData() aShrinker.SetShrinkFactor(1) aShrinker.SetInputConnection(Marching.GetOutputPort()) aMapper = vtk.vtkPolyDataMapper() aMapper.ScalarVisibilityOff() aMapper.SetInputConnection(aShrinker.GetOutputPort()) Triangles = vtk.vtkActor() Triangles.SetMapper(aMapper) Triangles.GetProperty().SetDiffuseColor( color.GetColor3d('banana')) Triangles.GetProperty().SetOpacity(.6) # Draw a cube the same size and at the same position as the one # created previously. Extract the edges because we only want to see # the outline of the cube. Pass the edges through a vtkTubeFilter so # they are displayed as tubes rather than lines. CubeModel = vtk.vtkCubeSource() CubeModel.SetCenter(.5, .5, .5) Edges = vtk.vtkExtractEdges() Edges.SetInputConnection(CubeModel.GetOutputPort()) Tubes = vtk.vtkTubeFilter() Tubes.SetInputConnection(Edges.GetOutputPort()) Tubes.SetRadius(.01) Tubes.SetNumberOfSides(6) Tubes.UseDefaultNormalOn() Tubes.SetDefaultNormal(.577, .577, .577) # Create the mapper and actor to display the cube edges. TubeMapper = vtk.vtkPolyDataMapper() TubeMapper.SetInputConnection(Tubes.GetOutputPort()) CubeEdges = vtk.vtkActor() CubeEdges.SetMapper(TubeMapper) CubeEdges.GetProperty().SetDiffuseColor( color.GetColor3d('khaki')) CubeEdges.GetProperty().SetSpecular(.4) CubeEdges.GetProperty().SetSpecularPower(10) # Create a sphere to use as a glyph source for vtkGlyph3D. Sphere = vtk.vtkSphereSource() Sphere.SetRadius(0.04) Sphere.SetPhiResolution(20) Sphere.SetThetaResolution(20) # Remove the part of the cube with data values below 0.5. ThresholdIn = vtk.vtkThresholdPoints() ThresholdIn.SetInputData(Grid) ThresholdIn.ThresholdByUpper(.5) # Display spheres at the vertices remaining in the cube data set after # it was passed through vtkThresholdPoints. Vertices = vtk.vtkGlyph3D() Vertices.SetInputConnection(ThresholdIn.GetOutputPort()) Vertices.SetSourceConnection(Sphere.GetOutputPort()) # Create a mapper and actor to display the glyphs. SphereMapper = vtk.vtkPolyDataMapper() SphereMapper.SetInputConnection(Vertices.GetOutputPort()) SphereMapper.ScalarVisibilityOff() CubeVertices = vtk.vtkActor() CubeVertices.SetMapper(SphereMapper) CubeVertices.GetProperty().SetDiffuseColor( color.GetColor3d('tomato')) # Define the text for the label caseLabel = vtk.vtkVectorText() caseLabel.SetText('Case 1') if label: # Set up a transform to move the label to a new position. aLabelTransform = vtk.vtkTransform() aLabelTransform.Identity() # Position the label according to the rotation of the figure. if rotation == 0: aLabelTransform.Translate(-0.2, 0, 1.25) aLabelTransform.Scale(.05, .05, .05) elif rotation == 1: aLabelTransform.RotateY(90) aLabelTransform.Translate(-1.25, 0, 1.25) aLabelTransform.Scale(.05, .05, .05) elif rotation == 2: aLabelTransform.RotateY(180) aLabelTransform.Translate(-1.25, 0, 0.2) aLabelTransform.Scale(.05, .05, .05) else: aLabelTransform.RotateY(270) aLabelTransform.Translate(-0.2, 0, 0.2) aLabelTransform.Scale(.05, .05, .05) # Move the label to a new position. labelTransform = vtk.vtkTransformPolyDataFilter() labelTransform.SetTransform(aLabelTransform) labelTransform.SetInputConnection(caseLabel.GetOutputPort()) # Create a mapper and actor to display the text. labelMapper = vtk.vtkPolyDataMapper() labelMapper.SetInputConnection(labelTransform.GetOutputPort()) labelActor = vtk.vtkActor() labelActor.SetMapper(labelMapper) # Define the base that the cube sits on. Create its associated mapper # and actor. Set the position of the actor. baseModel = vtk.vtkCubeSource() baseModel.SetXLength(1.5) baseModel.SetYLength(.01) baseModel.SetZLength(1.5) baseMapper = vtk.vtkPolyDataMapper() baseMapper.SetInputConnection(baseModel.GetOutputPort()) base = vtk.vtkActor() base.SetMapper(baseMapper) base.SetPosition(.5, -0.09, .5) # Set the scalar values for this case of marching cubes. # A negative case number will generate a complementary case mcCase = mcCases[i] if mcCase < 0: cases[-mcCase](Scalars, caseLabel, 0, 1) else: cases[mcCase](Scalars, caseLabel, 1, 0) # Force the grid to update. Grid.Modified() # Add the actors to the renderer renderers[i].AddActor(triangleEdgeActor) renderers[i].AddActor(base) if label: renderers[i].AddActor(labelActor) renderers[i].AddActor(CubeEdges) renderers[i].AddActor(CubeVertices) renderers[i].AddActor(Triangles) # Position the camera. renderers[i].GetActiveCamera().Dolly(1.2) # Rotate the camera an extra 30 degrees so the cube is not face on. if rotation == 0: renderers[i].GetActiveCamera().Azimuth(30) elif rotation == 1: renderers[i].GetActiveCamera().Azimuth(30 + 90) elif rotation == 2: renderers[i].GetActiveCamera().Azimuth(30 + 180) else: renderers[i].GetActiveCamera().Azimuth(30 + 270) renderers[i].GetActiveCamera().Elevation(20) renderers[i].ResetCamera() renderers[i].ResetCameraClippingRange() if i > 0: renderers[i].SetActiveCamera(renderers[0].GetActiveCamera()) # Setup viewports for the renderers rendererSize = 300 xGridDimensions = 4 if len(mcCases) < 4: xGridDimensions = len(mcCases) yGridDimensions = (len(mcCases) - 1) // 4 + 1 print('Grid dimensions, (x, y): ({:d}, {:d})'.format(xGridDimensions, yGridDimensions)) renWin.SetSize( rendererSize * xGridDimensions, rendererSize * yGridDimensions) renWin.SetWindowName('MarchingCases') for row in range(0, yGridDimensions): for col in range(0, xGridDimensions): index = row * xGridDimensions + col # (xmin, ymin, xmax, ymax) viewport = [ float(col) / xGridDimensions, float(yGridDimensions - (row + 1)) / yGridDimensions, float(col + 1) / xGridDimensions, float(yGridDimensions - row) / yGridDimensions] renderers[index].SetViewport(viewport) iren.Initialize() renWin.Render() iren.Start()