def WriteImage(self, m_outFileName="./Dump/tmp.png", m_dimension=[400, 400]): """ Write current renderer to a png file. For Debug :param m_outFileName: [str] Output name of the file, can be directory name. Default="./Dump/tmp.png" :param m_dimension: [x, y]. Dimension, i.e. width and height of the image file. :return: """ if self._renderer.GetRenderWindow() == None: self._renderWindow.AddRenderer(self._renderer) elif self._renderer.GetRenderWindow() != self._renderWindow: self._renderer.GetRenderWindow().Finalize() self._renderWindow = vtk.vtkRenderWindow() self._renderWindow.AddRenderer(self._renderer) else: self._renderWindow = vtk.vtkRenderWindow() self._renderWindow.AddRenderer(self._renderer) self._renderWindow.SetOffScreenRendering(1) self._renderWindow.SetSize(m_dimension) self._renderWindow.Render() self._renderWindow.SetAAFrames(10) m_writer = vtk.vtkPNGWriter() m_wintoim = vtk.vtkWindowToImageFilter() m_wintoim.SetInput(self._renderWindow) m_wintoim.Update() m_writer.SetInputConnection(m_wintoim.GetOutputPort()) m_writer.SetFileName(m_outFileName) m_writer.Write() pass
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 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 main(): #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) # Setup a renderer, render window, and interactor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() #renderWindow.SetWindowName("Test") renderWindow.AddRenderer(renderer); renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) #Add the actor to the scene renderer.AddActor(actor) renderer.SetBackground(1,1,1) # Background color white #Render and interact renderWindow.Render() #*** SetWindowName after renderWindow.Render() is called*** renderWindow.SetWindowName("Test") renderWindowInteractor.Start()
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 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 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 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 compute(self): r = self.get_input("renderer").vtkInstance window = vtk.vtkRenderWindow() w = self.force_get_input("width", 512) h = self.force_get_input("height", 512) window.OffScreenRenderingOn() window.SetSize(w, h) # r.ResetCamera() widget = None if system.systemType=='Darwin': from PyQt4 import QtCore, QtGui widget = QtGui.QWidget(None, QtCore.Qt.FramelessWindowHint) widget.resize(w, h) widget.show() window.SetWindowInfo(str(int(widget.winId()))) window.AddRenderer(r) # window.Start() window.Render() win2image = vtk.vtkWindowToImageFilter() win2image.SetInput(window) win2image.Update() writer = vtk.vtkPNGWriter() writer.SetInput(win2image.GetOutput()) output = self.interpreter.filePool.create_file(suffix='.png') writer.SetFileName(output.name) writer.Write() window.Finalize() if widget!=None: widget.close() self.set_output("image", output)
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, 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 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_render(self): window = vtk.vtkRenderWindow() window.SetSize(int(self.settings.image_width), int(self.settings.image_height)) window.SetOffScreenRendering(self.settings.offscreen_rendering) window.AddRenderer(self._renderer.renderer) self.window = window
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 vtk_basic( actors ): """ Create a window, renderer, interactor, add the actors and start the thing Parameters ---------- actors : list of vtkActors Returns ------- nothing """ # create a rendering window and renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(600,600) # ren.SetBackground( 1, 1, 1) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) for a in actors: # assign actor to the renderer ren.AddActor(a ) #enable user interface interactor iren.Initialize() renWin.Render() iren.Start()
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 testThreshold(self): global args writefiles = "SaveData" in args renderer = vtk.vtkRenderer() renwin = vtk.vtkRenderWindow() renwin.AddRenderer(renderer) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renwin) renwin.Render() if "GPURender" in args: vtk.vtkPistonMapper.InitCUDAGL(renwin) src = vtk.vtkImageMandelbrotSource() src.SetWholeExtent(0,10,0,10,0,10) #scale and bias until piston's threshold understands origin and spacing src.Update() inputdata = src.GetOutput() if "Normalize" in args: testdata1 = inputdata.NewInstance() testdata1.ShallowCopy(inputdata) testdata1.SetSpacing(1,1,1) testdata1.SetOrigin(0,0,0) inputdata = testdata1 d2p = vtk.vtkDataSetToPiston() d2p.SetInputData(inputdata) #d2p.SetInputConnection(src.GetOutputPort()) threshF = vtk.vtkPistonThreshold() threshF.SetInputConnection(d2p.GetOutputPort()) threshF.SetMinValue(0) threshF.SetMaxValue(80) p2d = vtk.vtkPistonToDataSet() p2d.SetInputConnection(threshF.GetOutputPort()) p2d.SetOutputDataSetType(vtk.VTK_POLY_DATA) if writefiles: writeFile(p2d, "piston_threshold.vtk") mapper = vtk.vtkPistonMapper() mapper.SetInputConnection(threshF.GetOutputPort()) mapper.Update() actor = vtk.vtkActor() actor.SetMapper(mapper) renderer.AddActor(actor) renderer.ResetCamera() renwin.Render() img_file = "TestThreshold.png" Testing.compareImage(renwin, Testing.getAbsImagePath(img_file)) if Testing.isInteractive(): iren.Start()
def vtk_Nviews( actors ): """ Create a window, an interactor and one renderer per actor Parameters ---------- actors : list of vtkActors Returns ------- nothing """ N = len(actors) # create a rendering window and renderers renderers = [vtk.vtkRenderer() for i in range(N)] renWin = vtk.vtkRenderWindow() renWin.SetSize( 600, 600 ) for i in range(N): # split the viewport renderers[i].SetViewport(0,float(N-i-1)/N,1,float(N-i)/N) renderers[i].SetBackground( 1, 1, 1) renderers[i].AddActor( actors[i] ) renWin.AddRenderer(renderers[i]) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) #enable user interface interactor iren.Initialize() renWin.Render() iren.Start()
def __init__(self): # Create the Renderer, RenderWindow, etc. and set the Picker. self.ren = vtk.vtkRenderer() self.renwin = vtk.vtkRenderWindow() self.renwin.AddRenderer(self.ren) self.ren.SetViewport(0,0,1,1) self.iren = vtk.vtkRenderWindowInteractor() self.iren.SetRenderWindow(self.renwin) # Create text mappers and 2d actors to display finger position. self.fingerMarker1 = Marker("(1)") self.fingerMarker2 = Marker("(2)") self.fingerMarker3 = Marker("(3)") self.fingerMarker4 = Marker("(4)") self.fingerMarker5 = Marker("(5)") # Add the actors to the renderer, set the background and size self.ren.AddActor2D(self.fingerMarker1.textActor) self.ren.AddActor2D(self.fingerMarker2.textActor) self.ren.AddActor2D(self.fingerMarker3.textActor) self.ren.AddActor2D(self.fingerMarker4.textActor) self.ren.AddActor2D(self.fingerMarker5.textActor) self.ren.SetBackground(0, 0, 0) self.renwin.SetSize(680, 460) #self.renwin.FullScreenOn() ''' TUIO STUFF ''' self.tracking = tuio.Tracking('') self.tracker = CursorTracker(8) self.terminate = False
def __init__(self): self.outputs=[] self.paint=rgbPainter() self.scalingFactor=1.0 self.showAxes=True self.showScalarBar=True self.showCaption=True self.showXYPlane=True self.showYZPlane=True self.showZXPlane=True self.nbSize=80 self.sampleSpacing=8.0 self.camera = vtk.vtkCamera() self.ren = vtk.vtkRenderer(); self.renWin = vtk.vtkRenderWindow(); self.renWin.AddRenderer(self.ren); self.renWin.SetWindowName("DESICOS-viewer v0.1 ") self.iren = vtk.vtkRenderWindowInteractor(); self.iren.SetRenderWindow(self.renWin); style1 = vtk.vtkInteractorStyleTrackballCamera() self.iren.SetInteractorStyle(style1) self.ren.SetBackground(1, 1, 1); self.renWin.SetSize(800, 600);
def main(): setup_vn() aPolyVertexGrid1 = Tns.vn.represent_map("pop")[0] Tns.vn.update_scalars([a/20. for a in Tns.p1_l_x], [aPolyVertexGrid1], [len(Tns.p1_l_id)]) aPolyVertexGrid2 = Tns.vn.represent_map("pop2")[0] # aPolyVertexActor = Tns.vn.make_actor_for_grid(aPolyVertexGrid) # aPolyVertexActor2 = Tns.vn.make_actor_for_grid(aPolyVertexGrid2) lvl_to_g = {0:[aPolyVertexGrid1, aPolyVertexGrid2]} #lvl_to_g = Tns.vn.levels_to_grids() all_actors = Tns.vn.make_all_actors(lvl_to_g) # Create the usual rendering stuff. ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(1024, 768) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.SetBackground(.0, .0, .0) for a in all_actors: ren.AddActor(a) ren.ResetCamera() ren.GetActiveCamera().Azimuth(00) ren.GetActiveCamera().Elevation(-40) ren.GetActiveCamera().Dolly(0) ren.ResetCameraClippingRange() # Render the scene and start interaction. iren.Initialize() renWin.Render() import time time.sleep(0.1) iren.Start()
def render_to_image(output_filename, vtk_format, renderer, w, h): window = vtk.vtkRenderWindow() window.OffScreenRenderingOn() window.SetSize(w, h) # FIXME think this may be fixed in VTK6 so we don't have this # dependency... widget = None if systemType=='Darwin': from PyQt4 import QtCore, QtGui widget = QtGui.QWidget(None, QtCore.Qt.FramelessWindowHint) widget.resize(w, h) widget.show() window.SetWindowInfo(str(int(widget.winId()))) window.AddRenderer(renderer) window.Render() win2image = vtk.vtkWindowToImageFilter() win2image.SetInput(window) win2image.Update() writer = vtk_format() if LooseVersion(vtk.vtkVersion().GetVTKVersion()) >= \ LooseVersion('6.0.0'): writer.SetInputData(win2image.GetOutput()) else: writer.SetInput(win2image.GetOutput()) writer.SetFileName(output_filename) writer.Write() window.Finalize() if widget!=None: widget.close()
def show(self): # Add to the cloud self.vtkPolyData.SetPoints(self.vtkPoints) self.vtkPolyData.SetVerts(self.vtkCells) self.vtkPolyData.GetPointData().SetVectors(self.vtkColor) self.vtkPolyData.Modified() self.vtkPolyData.Update() # Renderer mapper = vtk.vtkPolyDataMapper() mapper.SetInput(self.vtkPolyData) renderer = vtk.vtkRenderer() self.vtkActor.SetMapper(mapper) renderer.AddActor(self.vtkActor) renderer.SetBackground(.2, .3, .4) renderer.ResetCamera() #renderer.SetPosition([-3, 0, 11]) # Render Window renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) # Interactor renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Begin Interaction renderWindow.Render() renderWindowInteractor.Start()
def testUnstructured(self): rt = vtk.vtkRTAnalyticSource() rt.SetWholeExtent(-5, 5, -5, 5, -5, 5) t = vtk.vtkThreshold() t.SetInputConnection(rt.GetOutputPort()) t.ThresholdByUpper(-10) s = vtk.vtkSphere() s.SetRadius(2) s.SetCenter(0,0,0) c = vtk.vtkTableBasedClipDataSet() c.SetInputConnection(t.GetOutputPort()) c.SetClipFunction(s) c.SetInsideOut(1) c.Update() self.assertEqual(c.GetOutput().GetNumberOfCells(), 64) eg = vtk.vtkEnSightGoldReader() eg.SetCaseFileName(VTK_DATA_ROOT + "/Data/EnSight/elements.case") eg.Update() pl = vtk.vtkPlane() pl.SetOrigin(3.5, 3.5, 0.5) pl.SetNormal(0, 0, 1) c.SetInputConnection(eg.GetOutputPort()) c.SetClipFunction(pl) c.SetInsideOut(1) c.Update() data = c.GetOutputDataObject(0).GetBlock(0) self.assertEqual(data.GetNumberOfCells(), 75) rw = vtk.vtkRenderWindow() ren = vtk.vtkRenderer() rw.AddRenderer(ren) mapper = vtk.vtkDataSetMapper() mapper.SetInputData(data) actor = vtk.vtkActor() actor.SetMapper(mapper) ren.AddActor(actor) ac = ren.GetActiveCamera() ac.SetPosition(-7.9, 9.7, 14.6) ac.SetFocalPoint(3.5, 3.5, 0.5) ac.SetViewUp(0.08, 0.93, -0.34) rw.Render() ren.ResetCameraClippingRange() rtTester = vtk.vtkTesting() for arg in sys.argv[1:]: rtTester.AddArgument(arg) rtTester.AddArgument("-V") rtTester.AddArgument("tableBasedClip.png") rtTester.SetRenderWindow(rw) rw.Render() rtResult = rtTester.RegressionTest(10)
def createRenderWindow( self, **args ): blocking = args.get( 'blocking', False ) renWin = args.get( 'renwin', None ) if renWin == None: renWin = vtk.vtkRenderWindow() rendWinInteractor = renWin.GetInteractor() if rendWinInteractor == None: rendWinInteractor = vtk.vtkRenderWindowInteractor() if blocking else vtk.vtkGenericRenderWindowInteractor() renWin.SetInteractor( rendWinInteractor ) rendWinInteractor.SetRenderWindow(renWin) self.renderWindowInteractor = rendWinInteractor self.renderer = vtk.vtkRenderer() renWin.AddRenderer( self.renderer ) self.interactorStyle = vtk.vtkInteractorStyleTrackballCamera( ) self.renderWindowInteractor.SetInteractorStyle( self.interactorStyle ) self.interactorStyle.KeyPressActivationOff( ) self.interactorStyle.SetEnabled(1) if self.useDepthPeeling: self.renderer.UseDepthPeelingOn( ) self.renderer.SetOcclusionRatio( 0.2 ) renWin.SetAlphaBitPlanes( 1 ) renWin.SetMultiSamples( 0 ) self.renderer.SetBackground(1.0, 1.0, 1.0) self.renderer.SetNearClippingPlaneTolerance( 0.0001 ) self.renderWindow = renWin
def Visualize_Orientation(model, out_file): # create coordinate actor axes_actor = vtk.vtkAxesActor() axes_actor.SetTotalLength(500.0, 500.0, 500.0) # create model actor model_mapper = vtk.vtkPolyDataMapper() model_mapper.SetInputData(model) model_actor = vtk.vtkActor() model_actor.SetMapper(model_mapper) global renderer global interactor renderer = vtk.vtkRenderer() renderer.AddActor(model_actor) renderer.AddActor(axes_actor) win = vtk.vtkRenderWindow() win.AddRenderer(renderer) interactor = vtk.vtkRenderWindowInteractor() interactor_style = QIN_Style() interactor_style.SetRenderer(renderer) interactor_style.SetActor(model_actor) interactor_style.SetPolyData(model) interactor_style.SetOutName(out_file) interactor.SetInteractorStyle(interactor_style) win.SetInteractor(interactor) win.Render() interactor.Start() pass
def initialize(): # Create a rendering window and renderer transform = vtk.vtkTransform() transform.Scale(10.0, 10.0, 10.0) axes = vtk.vtkAxesActor() axes.SetUserTransform(transform) transform.Translate(3.0, -2.0, 0.0) axes.SetUserTransform(transform) ren = vtk.vtkRenderer() ren.AddActor(axes) ren.ResetCamera() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # Create a RenderWindowInteractor to permit manipulating the camera iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) style = vtk.vtkInteractorStyleTrackballCamera() iren.SetInteractorStyle(style) # enable user interface interactor iren.Initialize() renWin.Render() iren.Start() return ren, iren, renWin
def show_vtk_file(path): # open vtk file from arglist reader = vtk.vtkDataSetReader() reader.SetFileName(path) reader.Update() # read out data and scalarrange output = reader.GetOutput() scalarrange = output.GetScalarRange() # generate Mapper and set DataSource mapper = vtk.vtkDataSetMapper() mapper.SetInput(output) mapper.SetScalarRange(scalarrange) # create actor actor = vtk.vtkActor() actor.SetMapper(mapper) # build renderer renderer = vtk.vtkRenderer() window = vtk.vtkRenderWindow() window.AddRenderer(renderer) # create interaction interaction = vtk.vtkRenderWindowInteractor() interaction.SetRenderWindow(window) # add actor renderer.AddActor(actor) # show window and start inteaction and renderer interaction.Initialize() window.Render() interaction.Start()
def RenderVTKVolume(image, volprops): volmap = vtk.vtkVolumeRayCastMapper() volmap.SetVolumeRayCastFunction(vtk.vtkVolumeRayCastCompositeFunction()) volmap.SetInputConnection(image.GetOutputPort()) vol = vtk.vtkVolume() vol.SetMapper(volmap) vol.SetProperty(volprops) #Standard VTK stuff ren = vtk.vtkRenderer() ren.AddVolume(vol) ren.SetBackground((1, 1, 1)) renwin = vtk.vtkRenderWindow() renwin.AddRenderer(ren) istyle = vtk.vtkInteractorStyleSwitch() istyle.SetCurrentStyleToTrackballCamera() iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renwin) iren.SetInteractorStyle(istyle) renwin.Render() iren.Start()
def vis(dyns, save, cross): datdir = os.path.abspath(os.path.join(dyns[0], '../..')) stat = np.load('%s/static.npz' % datdir) l = stat['l'] lu, ld = l / 2.0, l / 2.0 R = stat['R'] R_drop = stat['R_d'] ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetSize(600, 600) renWin.AddRenderer(ren) if save: renWin.OffScreenRenderingOn() winImFilt = vtk.vtkWindowToImageFilter() winImFilt.SetInput(renWin) writer = vtk.vtkPNGWriter() writer.SetInputConnection(winImFilt.GetOutputPort()) else: iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.Initialize() timeActor = vtk.vtkTextActor() timeActor.SetInput('init') ren.AddActor(timeActor) env = vtk.vtkSphereSource() env.SetThetaResolution(30) env.SetPhiResolution(30) env.SetRadius(R_drop) # env = vtk.vtkRegularPolygonSource() # env.GeneratePolygonOff() # env.SetNumberOfSides(200) # x = 4.0 # th = np.arcsin(x / R_drop) # env.SetRadius(R_drop * np.cos(th)) # env_tube = vtk.vtkTubeFilter() # env_tube.SetInputConnection(env.GetOutputPort()) # env_tube.SetRadius(0.5) # env.Update() envMapper = vtk.vtkPolyDataMapper() envMapper.SetInputConnection(env.GetOutputPort()) envActor = vtk.vtkActor() envActor.SetMapper(envMapper) envActor.GetProperty().SetColor(1, 0, 0) envActor.GetProperty().SetRepresentationToWireframe() envActor.GetProperty().SetOpacity(0.5) ren.AddActor(envActor) particleCPoints = vtk.vtkPoints() particleCPolys = vtk.vtkPolyData() particleCPolys.SetPoints(particleCPoints) particlesC = vtk.vtkGlyph3D() lineSource = vtk.vtkLineSource() lineSource.SetPoint1(-ld, 0.0, 0.0) lineSource.SetPoint2(lu, 0.0, 0.0) particleCSource = vtk.vtkTubeFilter() particleCSource.SetInputConnection(lineSource.GetOutputPort()) particleCSource.SetRadius(R) particleCSource.SetNumberOfSides(10) particlesC.SetSourceConnection(particleCSource.GetOutputPort()) particlesC.SetInputData(particleCPolys) particlesCMapper = vtk.vtkPolyDataMapper() particlesCMapper.SetInputConnection(particlesC.GetOutputPort()) particlesCActor = vtk.vtkActor() particlesCActor.SetMapper(particlesCMapper) particlesCActor.GetProperty().SetColor(0, 1, 0) ren.AddActor(particlesCActor) particleESource = vtk.vtkSphereSource() particleESource.SetRadius(0.95 * R) particleESource.SetThetaResolution(20) particleESource.SetPhiResolution(20) particleE1Points = vtk.vtkPoints() particleE1Polys = vtk.vtkPolyData() particleE1Polys.SetPoints(particleE1Points) particlesE1 = vtk.vtkGlyph3D() particlesE1.SetSourceConnection(particleESource.GetOutputPort()) particlesE1.SetInputData(particleE1Polys) particlesE1Mapper = vtk.vtkPolyDataMapper() particlesE1Mapper.SetInputConnection(particlesE1.GetOutputPort()) particlesE1Actor = vtk.vtkActor() particlesE1Actor.SetMapper(particlesE1Mapper) particlesE1Actor.GetProperty().SetColor(0, 1, 0) ren.AddActor(particlesE1Actor) particleE2Points = vtk.vtkPoints() particleE2Polys = vtk.vtkPolyData() particleE2Polys.SetPoints(particleE2Points) particlesE2 = vtk.vtkGlyph3D() particlesE2.SetSourceConnection(particleESource.GetOutputPort()) particlesE2.SetInputData(particleE2Polys) particlesE2Mapper = vtk.vtkPolyDataMapper() particlesE2Mapper.SetInputConnection(particlesE2.GetOutputPort()) particlesE2Actor = vtk.vtkActor() particlesE2Actor.SetMapper(particlesE2Mapper) particlesE2Actor.GetProperty().SetColor(0, 1, 0) ren.AddActor(particlesE2Actor) renWin.fnames = dyns renWin.index = 0 renWin.l = l renWin.cross = cross renWin.timeActor = timeActor renWin.particleCPoints = particleCPoints renWin.particleCPolys = particleCPolys renWin.particleE1Points = particleE1Points renWin.particleE2Points = particleE2Points if not save: ren.GetActiveCamera().SetPosition(0.0, 0.0, -73.0) ren.GetActiveCamera().Zoom(1.0) iren.RemoveObservers('KeyPressEvent') iren.AddObserver('KeyPressEvent', progress_iren, 1.0) iren.Start() else: while True: fname = progress_renwin(renWin) print(fname) outname = os.path.splitext(os.path.basename(fname))[0] winImFilt.Modified() writer.SetFileName('{}.jpg'.format(outname)) writer.Write()
import vtk # create a rendering window and renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) style = vtk.vtkInteractorStyleTrackballActor() iren.SetInteractorStyle(style) # create source sphereSource = vtk.vtkSphereSource() sphereSource.Update() # mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInput(sphereSource.GetOutput()) # actor actor = vtk.vtkActor() actor.SetMapper(mapper) # assign actor to the renderer ren.AddActor(actor) # enable user interface interactor iren.Initialize()
def testCells(self): # Demonstrates all cell types # # NOTE: the use of NewInstance/DeepCopy is included to increase # regression coverage. It is not required in most applications. ren = vtk.vtkRenderer() # turn off all cullers ren.GetCullers().RemoveAllItems() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(300, 150) iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) # create a scene with one of each cell type # Voxel voxelPoints = vtk.vtkPoints() voxelPoints.SetNumberOfPoints(8) voxelPoints.InsertPoint(0, 0, 0, 0) voxelPoints.InsertPoint(1, 1, 0, 0) voxelPoints.InsertPoint(2, 0, 1, 0) voxelPoints.InsertPoint(3, 1, 1, 0) voxelPoints.InsertPoint(4, 0, 0, 1) voxelPoints.InsertPoint(5, 1, 0, 1) voxelPoints.InsertPoint(6, 0, 1, 1) voxelPoints.InsertPoint(7, 1, 1, 1) aVoxel = vtk.vtkVoxel() aVoxel.GetPointIds().SetId(0, 0) aVoxel.GetPointIds().SetId(1, 1) aVoxel.GetPointIds().SetId(2, 2) aVoxel.GetPointIds().SetId(3, 3) aVoxel.GetPointIds().SetId(4, 4) aVoxel.GetPointIds().SetId(5, 5) aVoxel.GetPointIds().SetId(6, 6) aVoxel.GetPointIds().SetId(7, 7) bVoxel = aVoxel.NewInstance() bVoxel.DeepCopy(aVoxel) aVoxelGrid = vtk.vtkUnstructuredGrid() aVoxelGrid.Allocate(1, 1) aVoxelGrid.InsertNextCell(aVoxel.GetCellType(), aVoxel.GetPointIds()) aVoxelGrid.SetPoints(voxelPoints) aVoxelMapper = vtk.vtkDataSetMapper() aVoxelMapper.SetInputData(aVoxelGrid) aVoxelActor = vtk.vtkActor() aVoxelActor.SetMapper(aVoxelMapper) aVoxelActor.GetProperty().BackfaceCullingOn() # Hexahedron hexahedronPoints = vtk.vtkPoints() hexahedronPoints.SetNumberOfPoints(8) hexahedronPoints.InsertPoint(0, 0, 0, 0) hexahedronPoints.InsertPoint(1, 1, 0, 0) hexahedronPoints.InsertPoint(2, 1, 1, 0) hexahedronPoints.InsertPoint(3, 0, 1, 0) hexahedronPoints.InsertPoint(4, 0, 0, 1) hexahedronPoints.InsertPoint(5, 1, 0, 1) hexahedronPoints.InsertPoint(6, 1, 1, 1) hexahedronPoints.InsertPoint(7, 0, 1, 1) aHexahedron = vtk.vtkHexahedron() aHexahedron.GetPointIds().SetId(0, 0) aHexahedron.GetPointIds().SetId(1, 1) aHexahedron.GetPointIds().SetId(2, 2) aHexahedron.GetPointIds().SetId(3, 3) aHexahedron.GetPointIds().SetId(4, 4) aHexahedron.GetPointIds().SetId(5, 5) aHexahedron.GetPointIds().SetId(6, 6) aHexahedron.GetPointIds().SetId(7, 7) bHexahedron = aHexahedron.NewInstance() bHexahedron.DeepCopy(aHexahedron) aHexahedronGrid = vtk.vtkUnstructuredGrid() aHexahedronGrid.Allocate(1, 1) aHexahedronGrid.InsertNextCell(aHexahedron.GetCellType(), aHexahedron.GetPointIds()) aHexahedronGrid.SetPoints(hexahedronPoints) aHexahedronMapper = vtk.vtkDataSetMapper() aHexahedronMapper.SetInputData(aHexahedronGrid) aHexahedronActor = vtk.vtkActor() aHexahedronActor.SetMapper(aHexahedronMapper) aHexahedronActor.AddPosition(2, 0, 0) aHexahedronActor.GetProperty().BackfaceCullingOn() # Tetra tetraPoints = vtk.vtkPoints() tetraPoints.SetNumberOfPoints(4) tetraPoints.InsertPoint(0, 0, 0, 0) tetraPoints.InsertPoint(1, 1, 0, 0) tetraPoints.InsertPoint(2, .5, 1, 0) tetraPoints.InsertPoint(3, .5, .5, 1) aTetra = vtk.vtkTetra() aTetra.GetPointIds().SetId(0, 0) aTetra.GetPointIds().SetId(1, 1) aTetra.GetPointIds().SetId(2, 2) aTetra.GetPointIds().SetId(3, 3) bTetra = aTetra.NewInstance() bTetra.DeepCopy(aTetra) aTetraGrid = vtk.vtkUnstructuredGrid() aTetraGrid.Allocate(1, 1) aTetraGrid.InsertNextCell(aTetra.GetCellType(), aTetra.GetPointIds()) aTetraGrid.SetPoints(tetraPoints) aTetraCopy = vtk.vtkUnstructuredGrid() aTetraCopy.ShallowCopy(aTetraGrid) aTetraMapper = vtk.vtkDataSetMapper() aTetraMapper.SetInputData(aTetraCopy) aTetraActor = vtk.vtkActor() aTetraActor.SetMapper(aTetraMapper) aTetraActor.AddPosition(4, 0, 0) aTetraActor.GetProperty().BackfaceCullingOn() # Wedge wedgePoints = vtk.vtkPoints() wedgePoints.SetNumberOfPoints(6) wedgePoints.InsertPoint(0, 0, 1, 0) wedgePoints.InsertPoint(1, 0, 0, 0) wedgePoints.InsertPoint(2, 0, .5, .5) wedgePoints.InsertPoint(3, 1, 1, 0) wedgePoints.InsertPoint(4, 1, 0, 0) wedgePoints.InsertPoint(5, 1, .5, .5) aWedge = vtk.vtkWedge() aWedge.GetPointIds().SetId(0, 0) aWedge.GetPointIds().SetId(1, 1) aWedge.GetPointIds().SetId(2, 2) aWedge.GetPointIds().SetId(3, 3) aWedge.GetPointIds().SetId(4, 4) aWedge.GetPointIds().SetId(5, 5) bWedge = aWedge.NewInstance() bWedge.DeepCopy(aWedge) aWedgeGrid = vtk.vtkUnstructuredGrid() aWedgeGrid.Allocate(1, 1) aWedgeGrid.InsertNextCell(aWedge.GetCellType(), aWedge.GetPointIds()) aWedgeGrid.SetPoints(wedgePoints) aWedgeCopy = vtk.vtkUnstructuredGrid() aWedgeCopy.DeepCopy(aWedgeGrid) aWedgeMapper = vtk.vtkDataSetMapper() aWedgeMapper.SetInputData(aWedgeCopy) aWedgeActor = vtk.vtkActor() aWedgeActor.SetMapper(aWedgeMapper) aWedgeActor.AddPosition(6, 0, 0) aWedgeActor.GetProperty().BackfaceCullingOn() # Pyramid pyramidPoints = vtk.vtkPoints() pyramidPoints.SetNumberOfPoints(5) pyramidPoints.InsertPoint(0, 0, 0, 0) pyramidPoints.InsertPoint(1, 1, 0, 0) pyramidPoints.InsertPoint(2, 1, 1, 0) pyramidPoints.InsertPoint(3, 0, 1, 0) pyramidPoints.InsertPoint(4, .5, .5, 1) aPyramid = vtk.vtkPyramid() aPyramid.GetPointIds().SetId(0, 0) aPyramid.GetPointIds().SetId(1, 1) aPyramid.GetPointIds().SetId(2, 2) aPyramid.GetPointIds().SetId(3, 3) aPyramid.GetPointIds().SetId(4, 4) bPyramid = aPyramid.NewInstance() bPyramid.DeepCopy(aPyramid) aPyramidGrid = vtk.vtkUnstructuredGrid() aPyramidGrid.Allocate(1, 1) aPyramidGrid.InsertNextCell(aPyramid.GetCellType(), aPyramid.GetPointIds()) aPyramidGrid.SetPoints(pyramidPoints) aPyramidMapper = vtk.vtkDataSetMapper() aPyramidMapper.SetInputData(aPyramidGrid) aPyramidActor = vtk.vtkActor() aPyramidActor.SetMapper(aPyramidMapper) aPyramidActor.AddPosition(8, 0, 0) aPyramidActor.GetProperty().BackfaceCullingOn() # Pixel pixelPoints = vtk.vtkPoints() pixelPoints.SetNumberOfPoints(4) pixelPoints.InsertPoint(0, 0, 0, 0) pixelPoints.InsertPoint(1, 1, 0, 0) pixelPoints.InsertPoint(2, 0, 1, 0) pixelPoints.InsertPoint(3, 1, 1, 0) aPixel = vtk.vtkPixel() aPixel.GetPointIds().SetId(0, 0) aPixel.GetPointIds().SetId(1, 1) aPixel.GetPointIds().SetId(2, 2) aPixel.GetPointIds().SetId(3, 3) bPixel = aPixel.NewInstance() bPixel.DeepCopy(aPixel) aPixelGrid = vtk.vtkUnstructuredGrid() aPixelGrid.Allocate(1, 1) aPixelGrid.InsertNextCell(aPixel.GetCellType(), aPixel.GetPointIds()) aPixelGrid.SetPoints(pixelPoints) aPixelMapper = vtk.vtkDataSetMapper() aPixelMapper.SetInputData(aPixelGrid) aPixelActor = vtk.vtkActor() aPixelActor.SetMapper(aPixelMapper) aPixelActor.AddPosition(0, 0, 2) aPixelActor.GetProperty().BackfaceCullingOn() # Quad quadPoints = vtk.vtkPoints() quadPoints.SetNumberOfPoints(4) quadPoints.InsertPoint(0, 0, 0, 0) quadPoints.InsertPoint(1, 1, 0, 0) quadPoints.InsertPoint(2, 1, 1, 0) quadPoints.InsertPoint(3, 0, 1, 0) aQuad = vtk.vtkQuad() aQuad.GetPointIds().SetId(0, 0) aQuad.GetPointIds().SetId(1, 1) aQuad.GetPointIds().SetId(2, 2) aQuad.GetPointIds().SetId(3, 3) bQuad = aQuad.NewInstance() bQuad.DeepCopy(aQuad) aQuadGrid = vtk.vtkUnstructuredGrid() aQuadGrid.Allocate(1, 1) aQuadGrid.InsertNextCell(aQuad.GetCellType(), aQuad.GetPointIds()) aQuadGrid.SetPoints(quadPoints) aQuadMapper = vtk.vtkDataSetMapper() aQuadMapper.SetInputData(aQuadGrid) aQuadActor = vtk.vtkActor() aQuadActor.SetMapper(aQuadMapper) aQuadActor.AddPosition(2, 0, 2) aQuadActor.GetProperty().BackfaceCullingOn() # Triangle trianglePoints = vtk.vtkPoints() trianglePoints.SetNumberOfPoints(3) trianglePoints.InsertPoint(0, 0, 0, 0) trianglePoints.InsertPoint(1, 1, 0, 0) trianglePoints.InsertPoint(2, .5, .5, 0) triangleTCoords = vtk.vtkFloatArray() triangleTCoords.SetNumberOfComponents(2) triangleTCoords.SetNumberOfTuples(3) triangleTCoords.InsertTuple2(0, 1, 1) triangleTCoords.InsertTuple2(1, 2, 2) triangleTCoords.InsertTuple2(2, 3, 3) aTriangle = vtk.vtkTriangle() aTriangle.GetPointIds().SetId(0, 0) aTriangle.GetPointIds().SetId(1, 1) aTriangle.GetPointIds().SetId(2, 2) bTriangle = aTriangle.NewInstance() bTriangle.DeepCopy(aTriangle) aTriangleGrid = vtk.vtkUnstructuredGrid() aTriangleGrid.Allocate(1, 1) aTriangleGrid.InsertNextCell(aTriangle.GetCellType(), aTriangle.GetPointIds()) aTriangleGrid.SetPoints(trianglePoints) aTriangleGrid.GetPointData().SetTCoords(triangleTCoords) aTriangleMapper = vtk.vtkDataSetMapper() aTriangleMapper.SetInputData(aTriangleGrid) aTriangleActor = vtk.vtkActor() aTriangleActor.SetMapper(aTriangleMapper) aTriangleActor.AddPosition(4, 0, 2) aTriangleActor.GetProperty().BackfaceCullingOn() # Polygon polygonPoints = vtk.vtkPoints() polygonPoints.SetNumberOfPoints(4) polygonPoints.InsertPoint(0, 0, 0, 0) polygonPoints.InsertPoint(1, 1, 0, 0) polygonPoints.InsertPoint(2, 1, 1, 0) polygonPoints.InsertPoint(3, 0, 1, 0) aPolygon = vtk.vtkPolygon() aPolygon.GetPointIds().SetNumberOfIds(4) aPolygon.GetPointIds().SetId(0, 0) aPolygon.GetPointIds().SetId(1, 1) aPolygon.GetPointIds().SetId(2, 2) aPolygon.GetPointIds().SetId(3, 3) bPolygon = aPolygon.NewInstance() bPolygon.DeepCopy(aPolygon) aPolygonGrid = vtk.vtkUnstructuredGrid() aPolygonGrid.Allocate(1, 1) aPolygonGrid.InsertNextCell(aPolygon.GetCellType(), aPolygon.GetPointIds()) aPolygonGrid.SetPoints(polygonPoints) aPolygonMapper = vtk.vtkDataSetMapper() aPolygonMapper.SetInputData(aPolygonGrid) aPolygonActor = vtk.vtkActor() aPolygonActor.SetMapper(aPolygonMapper) aPolygonActor.AddPosition(6, 0, 2) aPolygonActor.GetProperty().BackfaceCullingOn() # Triangle Strip triangleStripPoints = vtk.vtkPoints() triangleStripPoints.SetNumberOfPoints(5) triangleStripPoints.InsertPoint(0, 0, 1, 0) triangleStripPoints.InsertPoint(1, 0, 0, 0) triangleStripPoints.InsertPoint(2, 1, 1, 0) triangleStripPoints.InsertPoint(3, 1, 0, 0) triangleStripPoints.InsertPoint(4, 2, 1, 0) triangleStripTCoords = vtk.vtkFloatArray() triangleStripTCoords.SetNumberOfComponents(2) triangleStripTCoords.SetNumberOfTuples(3) triangleStripTCoords.InsertTuple2(0, 1, 1) triangleStripTCoords.InsertTuple2(1, 2, 2) triangleStripTCoords.InsertTuple2(2, 3, 3) triangleStripTCoords.InsertTuple2(3, 4, 4) triangleStripTCoords.InsertTuple2(4, 5, 5) aTriangleStrip = vtk.vtkTriangleStrip() aTriangleStrip.GetPointIds().SetNumberOfIds(5) aTriangleStrip.GetPointIds().SetId(0, 0) aTriangleStrip.GetPointIds().SetId(1, 1) aTriangleStrip.GetPointIds().SetId(2, 2) aTriangleStrip.GetPointIds().SetId(3, 3) aTriangleStrip.GetPointIds().SetId(4, 4) bTriangleStrip = aTriangleStrip.NewInstance() bTriangleStrip.DeepCopy(aTriangleStrip) aTriangleStripGrid = vtk.vtkUnstructuredGrid() aTriangleStripGrid.Allocate(1, 1) aTriangleStripGrid.InsertNextCell(aTriangleStrip.GetCellType(), aTriangleStrip.GetPointIds()) aTriangleStripGrid.SetPoints(triangleStripPoints) aTriangleStripGrid.GetPointData().SetTCoords(triangleStripTCoords) aTriangleStripMapper = vtk.vtkDataSetMapper() aTriangleStripMapper.SetInputData(aTriangleStripGrid) aTriangleStripActor = vtk.vtkActor() aTriangleStripActor.SetMapper(aTriangleStripMapper) aTriangleStripActor.AddPosition(8, 0, 2) aTriangleStripActor.GetProperty().BackfaceCullingOn() # Line linePoints = vtk.vtkPoints() linePoints.SetNumberOfPoints(2) linePoints.InsertPoint(0, 0, 0, 0) linePoints.InsertPoint(1, 1, 1, 0) aLine = vtk.vtkLine() aLine.GetPointIds().SetId(0, 0) aLine.GetPointIds().SetId(1, 1) bLine = aLine.NewInstance() bLine.DeepCopy(aLine) aLineGrid = vtk.vtkUnstructuredGrid() aLineGrid.Allocate(1, 1) aLineGrid.InsertNextCell(aLine.GetCellType(), aLine.GetPointIds()) aLineGrid.SetPoints(linePoints) aLineMapper = vtk.vtkDataSetMapper() aLineMapper.SetInputData(aLineGrid) aLineActor = vtk.vtkActor() aLineActor.SetMapper(aLineMapper) aLineActor.AddPosition(0, 0, 4) aLineActor.GetProperty().BackfaceCullingOn() # Poly line polyLinePoints = vtk.vtkPoints() polyLinePoints.SetNumberOfPoints(3) polyLinePoints.InsertPoint(0, 0, 0, 0) polyLinePoints.InsertPoint(1, 1, 1, 0) polyLinePoints.InsertPoint(2, 1, 0, 0) aPolyLine = vtk.vtkPolyLine() aPolyLine.GetPointIds().SetNumberOfIds(3) aPolyLine.GetPointIds().SetId(0, 0) aPolyLine.GetPointIds().SetId(1, 1) aPolyLine.GetPointIds().SetId(2, 2) bPolyLine = aPolyLine.NewInstance() bPolyLine.DeepCopy(aPolyLine) aPolyLineGrid = vtk.vtkUnstructuredGrid() aPolyLineGrid.Allocate(1, 1) aPolyLineGrid.InsertNextCell(aPolyLine.GetCellType(), aPolyLine.GetPointIds()) aPolyLineGrid.SetPoints(polyLinePoints) aPolyLineMapper = vtk.vtkDataSetMapper() aPolyLineMapper.SetInputData(aPolyLineGrid) aPolyLineActor = vtk.vtkActor() aPolyLineActor.SetMapper(aPolyLineMapper) aPolyLineActor.AddPosition(2, 0, 4) aPolyLineActor.GetProperty().BackfaceCullingOn() # Vertex vertexPoints = vtk.vtkPoints() vertexPoints.SetNumberOfPoints(1) vertexPoints.InsertPoint(0, 0, 0, 0) aVertex = vtk.vtkVertex() aVertex.GetPointIds().SetId(0, 0) bVertex = aVertex.NewInstance() bVertex.DeepCopy(aVertex) aVertexGrid = vtk.vtkUnstructuredGrid() aVertexGrid.Allocate(1, 1) aVertexGrid.InsertNextCell(aVertex.GetCellType(), aVertex.GetPointIds()) aVertexGrid.SetPoints(vertexPoints) aVertexMapper = vtk.vtkDataSetMapper() aVertexMapper.SetInputData(aVertexGrid) aVertexActor = vtk.vtkActor() aVertexActor.SetMapper(aVertexMapper) aVertexActor.AddPosition(0, 0, 6) aVertexActor.GetProperty().BackfaceCullingOn() # Poly Vertex polyVertexPoints = vtk.vtkPoints() polyVertexPoints.SetNumberOfPoints(3) polyVertexPoints.InsertPoint(0, 0, 0, 0) polyVertexPoints.InsertPoint(1, 1, 0, 0) polyVertexPoints.InsertPoint(2, 1, 1, 0) aPolyVertex = vtk.vtkPolyVertex() aPolyVertex.GetPointIds().SetNumberOfIds(3) aPolyVertex.GetPointIds().SetId(0, 0) aPolyVertex.GetPointIds().SetId(1, 1) aPolyVertex.GetPointIds().SetId(2, 2) bPolyVertex = aPolyVertex.NewInstance() bPolyVertex.DeepCopy(aPolyVertex) aPolyVertexGrid = vtk.vtkUnstructuredGrid() aPolyVertexGrid.Allocate(1, 1) aPolyVertexGrid.InsertNextCell(aPolyVertex.GetCellType(), aPolyVertex.GetPointIds()) aPolyVertexGrid.SetPoints(polyVertexPoints) aPolyVertexMapper = vtk.vtkDataSetMapper() aPolyVertexMapper.SetInputData(aPolyVertexGrid) aPolyVertexActor = vtk.vtkActor() aPolyVertexActor.SetMapper(aPolyVertexMapper) aPolyVertexActor.AddPosition(2, 0, 6) aPolyVertexActor.GetProperty().BackfaceCullingOn() # Pentagonal prism pentaPoints = vtk.vtkPoints() pentaPoints.SetNumberOfPoints(10) pentaPoints.InsertPoint(0, 0.25, 0.0, 0.0) pentaPoints.InsertPoint(1, 0.75, 0.0, 0.0) pentaPoints.InsertPoint(2, 1.0, 0.5, 0.0) pentaPoints.InsertPoint(3, 0.5, 1.0, 0.0) pentaPoints.InsertPoint(4, 0.0, 0.5, 0.0) pentaPoints.InsertPoint(5, 0.25, 0.0, 1.0) pentaPoints.InsertPoint(6, 0.75, 0.0, 1.0) pentaPoints.InsertPoint(7, 1.0, 0.5, 1.0) pentaPoints.InsertPoint(8, 0.5, 1.0, 1.0) pentaPoints.InsertPoint(9, 0.0, 0.5, 1.0) aPenta = vtk.vtkPentagonalPrism() aPenta.GetPointIds().SetId(0, 0) aPenta.GetPointIds().SetId(1, 1) aPenta.GetPointIds().SetId(2, 2) aPenta.GetPointIds().SetId(3, 3) aPenta.GetPointIds().SetId(4, 4) aPenta.GetPointIds().SetId(5, 5) aPenta.GetPointIds().SetId(6, 6) aPenta.GetPointIds().SetId(7, 7) aPenta.GetPointIds().SetId(8, 8) aPenta.GetPointIds().SetId(9, 9) bPenta = aPenta.NewInstance() bPenta.DeepCopy(aPenta) aPentaGrid = vtk.vtkUnstructuredGrid() aPentaGrid.Allocate(1, 1) aPentaGrid.InsertNextCell(aPenta.GetCellType(), aPenta.GetPointIds()) aPentaGrid.SetPoints(pentaPoints) aPentaCopy = vtk.vtkUnstructuredGrid() aPentaCopy.DeepCopy(aPentaGrid) aPentaMapper = vtk.vtkDataSetMapper() aPentaMapper.SetInputData(aPentaCopy) aPentaActor = vtk.vtkActor() aPentaActor.SetMapper(aPentaMapper) aPentaActor.AddPosition(10, 0, 0) aPentaActor.GetProperty().BackfaceCullingOn() # Hexagonal prism hexaPoints = vtk.vtkPoints() hexaPoints.SetNumberOfPoints(12) hexaPoints.InsertPoint(0, 0.0, 0.0, 0.0) hexaPoints.InsertPoint(1, 0.5, 0.0, 0.0) hexaPoints.InsertPoint(2, 1.0, 0.5, 0.0) hexaPoints.InsertPoint(3, 1.0, 1.0, 0.0) hexaPoints.InsertPoint(4, 0.5, 1.0, 0.0) hexaPoints.InsertPoint(5, 0.0, 0.5, 0.0) hexaPoints.InsertPoint(6, 0.0, 0.0, 1.0) hexaPoints.InsertPoint(7, 0.5, 0.0, 1.0) hexaPoints.InsertPoint(8, 1.0, 0.5, 1.0) hexaPoints.InsertPoint(9, 1.0, 1.0, 1.0) hexaPoints.InsertPoint(10, 0.5, 1.0, 1.0) hexaPoints.InsertPoint(11, 0.0, 0.5, 1.0) aHexa = vtk.vtkHexagonalPrism() aHexa.GetPointIds().SetId(0, 0) aHexa.GetPointIds().SetId(1, 1) aHexa.GetPointIds().SetId(2, 2) aHexa.GetPointIds().SetId(3, 3) aHexa.GetPointIds().SetId(4, 4) aHexa.GetPointIds().SetId(5, 5) aHexa.GetPointIds().SetId(6, 6) aHexa.GetPointIds().SetId(7, 7) aHexa.GetPointIds().SetId(8, 8) aHexa.GetPointIds().SetId(9, 9) aHexa.GetPointIds().SetId(10, 10) aHexa.GetPointIds().SetId(11, 11) bHexa = aHexa.NewInstance() bHexa.DeepCopy(aHexa) aHexaGrid = vtk.vtkUnstructuredGrid() aHexaGrid.Allocate(1, 1) aHexaGrid.InsertNextCell(aHexa.GetCellType(), aHexa.GetPointIds()) aHexaGrid.SetPoints(hexaPoints) aHexaCopy = vtk.vtkUnstructuredGrid() aHexaCopy.DeepCopy(aHexaGrid) aHexaMapper = vtk.vtkDataSetMapper() aHexaMapper.SetInputData(aHexaCopy) aHexaActor = vtk.vtkActor() aHexaActor.SetMapper(aHexaMapper) aHexaActor.AddPosition(12, 0, 0) aHexaActor.GetProperty().BackfaceCullingOn() # RIB property if hasattr(vtk, 'vtkRIBProperty'): aRIBProperty = vtk.vtkRIBProperty() aRIBProperty.SetVariable("Km", "float") aRIBProperty.SetSurfaceShader("LGVeinedmarble") aRIBProperty.SetVariable("veinfreq", "float") aRIBProperty.AddVariable("warpfreq", "float") aRIBProperty.AddVariable("veincolor", "color") aRIBProperty.AddSurfaceShaderParameter("veinfreq", " 2") aRIBProperty.AddSurfaceShaderParameter("veincolor", "1.0000 1.0000 0.9412") bRIBProperty = vtk.vtkRIBProperty() bRIBProperty.SetVariable("Km", "float") bRIBProperty.SetSurfaceShaderParameter("Km", "1.0") bRIBProperty.SetDisplacementShader("dented") bRIBProperty.SetSurfaceShader("plastic") aProperty = vtk.vtkProperty() bProperty = vtk.vtkProperty() aTriangleActor.SetProperty(aProperty) aTriangleStripActor.SetProperty(bProperty) ren.SetBackground(.1, .2, .4) ren.AddActor(aVoxelActor) aVoxelActor.GetProperty().SetDiffuseColor(1, 0, 0) ren.AddActor(aHexahedronActor) aHexahedronActor.GetProperty().SetDiffuseColor(1, 1, 0) ren.AddActor(aTetraActor) aTetraActor.GetProperty().SetDiffuseColor(0, 1, 0) ren.AddActor(aWedgeActor) aWedgeActor.GetProperty().SetDiffuseColor(0, 1, 1) ren.AddActor(aPyramidActor) aPyramidActor.GetProperty().SetDiffuseColor(1, 0, 1) ren.AddActor(aPixelActor) aPixelActor.GetProperty().SetDiffuseColor(0, 1, 1) ren.AddActor(aQuadActor) aQuadActor.GetProperty().SetDiffuseColor(1, 0, 1) ren.AddActor(aTriangleActor) aTriangleActor.GetProperty().SetDiffuseColor(.3, 1, .5) ren.AddActor(aPolygonActor) aPolygonActor.GetProperty().SetDiffuseColor(1, .4, .5) ren.AddActor(aTriangleStripActor) aTriangleStripActor.GetProperty().SetDiffuseColor(.3, .7, 1) ren.AddActor(aLineActor) aLineActor.GetProperty().SetDiffuseColor(.2, 1, 1) ren.AddActor(aPolyLineActor) aPolyLineActor.GetProperty().SetDiffuseColor(1, 1, 1) ren.AddActor(aVertexActor) aVertexActor.GetProperty().SetDiffuseColor(1, 1, 1) ren.AddActor(aPolyVertexActor) aPolyVertexActor.GetProperty().SetDiffuseColor(1, 1, 1) ren.AddActor(aPentaActor) aPentaActor.GetProperty().SetDiffuseColor(.2, .4, .7) ren.AddActor(aHexaActor) aHexaActor.GetProperty().SetDiffuseColor(.7, .5, 1) aRIBLight = vtk.vtkRIBLight() aRIBLight.SetIntensity(0.7) ren.AddLight(aRIBLight) aLight = vtk.vtkLight() aLight.PositionalOn() aLight.SetConeAngle(10.0) aLight.SetIntensity(0.7) ren.AddLight(aLight) ren.ResetCamera() ren.GetActiveCamera().Azimuth(30) ren.GetActiveCamera().Elevation(20) ren.GetActiveCamera().Dolly(2.8) ren.ResetCameraClippingRange() dir = VTK_TEMP_DIR atext = vtk.vtkTexture() pnmReader = vtk.vtkBMPReader() pnmReader.SetFileName(VTK_DATA_ROOT + "/Data/masonry.bmp") atext.SetInputConnection(pnmReader.GetOutputPort()) atext.InterpolateOff() aTriangleActor.SetTexture(atext) aRIBLight.SetFocalPoint(ren.GetActiveCamera().GetFocalPoint()) aRIBLight.SetPosition(ren.GetActiveCamera().GetPosition()) aLight.SetFocalPoint(ren.GetActiveCamera().GetFocalPoint()) aLight.SetPosition(ren.GetActiveCamera().GetPosition()) # basically have IO/Export ? if hasattr(vtk, 'vtkRIBExporter'): rib = vtk.vtkRIBExporter() rib.SetInput(renWin) rib.SetFilePrefix(dir + '/cells') rib.SetTexturePrefix(dir + '/cells') rib.Write() iv = vtk.vtkIVExporter() iv.SetInput(renWin) iv.SetFileName(dir + "/cells.iv") iv.Write() os.remove(dir + '/cells.iv') obj = vtk.vtkOBJExporter() obj.SetInput(renWin) obj.SetFilePrefix(dir + "/cells") obj.Write() os.remove(dir + '/cells.obj') os.remove(dir + '/cells.mtl') vrml = vtk.vtkVRMLExporter() vrml.SetInput(renWin) #vrml.SetStartWrite(vrml.SetFileName(dir + "/cells.wrl")) #vrml.SetEndWrite(vrml.SetFileName("/a/acells.wrl")) vrml.SetFileName(dir + "/cells.wrl") vrml.SetSpeed(5.5) vrml.Write() os.remove(dir + '/cells.wrl') oogl = vtk.vtkOOGLExporter() oogl.SetInput(renWin) oogl.SetFileName(dir + "/cells.oogl") oogl.Write() os.remove(dir + '/cells.oogl') # the UnRegister calls are because make object is the same as New, # and causes memory leaks. (Python does not treat NewInstance the same as New). def DeleteCopies(): bVoxel.UnRegister(None) bHexahedron.UnRegister(None) bTetra.UnRegister(None) bWedge.UnRegister(None) bPyramid.UnRegister(None) bPixel.UnRegister(None) bQuad.UnRegister(None) bTriangle.UnRegister(None) bPolygon.UnRegister(None) bTriangleStrip.UnRegister(None) bLine.UnRegister(None) bPolyLine.UnRegister(None) bVertex.UnRegister(None) bPolyVertex.UnRegister(None) bPenta.UnRegister(None) bHexa.UnRegister(None) DeleteCopies() # render and interact with data renWin.Render() img_file = "cells.png" vtk.test.Testing.compareImage( iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file)) vtk.test.Testing.interact()
def create3D(): points = [] ilgis = 0 for x in range(COUNT): ilgis, points = GetForma(ilgis, points) points.append([0, ilgis]) points.append([0, 0]) points.append([R / 2.0, 0]) rodData = "translate([0," + str(R / 4.0) + "," + str( R / 4.0 ) + "])rotate ([-90,0,0]) rotate_extrude($fn=200) polygon( points=" + str( points) + " );\n" rod = open("rod.scad", "w") rod.write(rodData) rod.close() call(["openscad", "-o", "rod.stl", "rod.scad"]) read = vtk.vtkSTLReader() read.SetFileName("rod.stl") read.Update() tran = vtk.vtkTransform() bounds = read.GetOutput().GetBounds() tran.Translate( -read.GetOutput().GetBounds()[0] - (bounds[1] - bounds[0]) / 2.0, -read.GetOutput().GetBounds()[2] - (bounds[3] - bounds[2]) / 2.0, -read.GetOutput().GetBounds()[4] - (bounds[5] - bounds[4]) / 2.0) tfilter = vtk.vtkTransformFilter() tfilter.SetInputData(read.GetOutput()) tfilter.SetTransform(tran) tfilter.Update() w = vtk.vtkSTLWriter() w.SetFileName("rod.stl") w.SetInputData(tfilter.GetOutput()) w.Update() plane1 = vtk.vtkPlane() plane1.SetNormal(1, 0, 0) plane1.SetOrigin(0, 0, 0) plane2 = vtk.vtkPlane() plane2.SetNormal(0, 0, 1) plane2.SetOrigin(0, 0, 0) coll = vtk.vtkPlaneCollection() coll.AddItem(plane1) coll.AddItem(plane2) clip1 = vtk.vtkClipClosedSurface() clip1.SetClippingPlanes(coll) clip1.GenerateFacesOn() clip1.SetInputConnection(tfilter.GetOutputPort()) clip1.Update() beton = vtk.vtkCubeSource() beton.SetBounds(-boxSize, boxSize, -ilgis / 2.0, ilgis / 2.0, -boxSize, boxSize) beton.Update() clip2 = vtk.vtkClipClosedSurface() clip2.SetClippingPlanes(coll) clip2.GenerateFacesOn() clip2.SetInputConnection(beton.GetOutputPort()) clip2.Update() box = vtk.vtkCubeSource() b = clip2.GetOutput().GetBounds() bbbb = clip1.GetOutput().GetBounds() box.SetBounds(b[0], b[1], bbbb[2] - (bbbb[3] - bbbb[2]) * CalcBoxSizeProc / 1000.0, bbbb[3] + (bbbb[3] - bbbb[2]) * CalcBoxSizeProc / 1000.0, b[4], b[5]) box.Update() SaveToSTL(box.GetOutput(), "box.stl") SaveToSTL(clip2.GetOutput(), "beton.stl") SaveToSTL(clip1.GetOutput(), "rod.stl") # create a rendering window and renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(clip1.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) ren.AddActor(actor) mapper1 = vtk.vtkPolyDataMapper() mapper1.SetInputConnection(clip2.GetOutputPort()) actor1 = vtk.vtkActor() actor1.SetMapper(mapper1) ren.AddActor(actor1)
def main(): count = 1 dirname = None opacityWindow = 4096.0 opacityLevel = 2048.0 blendType = 0 clip = 0 reductionFactor = 1.0 frameRate = 10.0 fileName = None fileType = 0 independentComponents = True while (count < len(sys.argv)): if (sys.argv[count] == "?"): PrintUsage() sys.exit(0) elif (sys.argv[count] == "-DICOM"): dirname = sys.argv[count + 1] count += 2 elif (sys.argv[count] == "-VTI"): fileType = VTI_FILETYPE fileName = sys.argv[count + 1] count += 2 elif (sys.argv[count] == "-MHA"): fileType = MHA_FILETYPE fileName = sys.argv[count + 1] count += 2 elif (sys.argv[count] == "-Clip"): clip = 1 count += 1 elif (sys.argv[count] == "-MIP"): opacityWindow = float(sys.argv[count + 1]) opacityLevel = float(sys.argv[count + 2]) blendType = 0 count += 3 elif (sys.argv[count] == "-CompositeRamp"): opacityWindow = float(sys.argv[count + 1]) opacityLevel = float(sys.argv[count + 2]) blendType = 1 count += 3 elif (sys.argv[count] == "-CompositeShadeRamp"): opacityWindow = float(sys.argv[count + 1]) opacityLevel = float(sys.argv[count + 2]) blendType = 2 count += 3 elif (sys.argv[count] == "-CT_Skin"): blendType = 3 count += 1 elif (sys.argv[count] == "-CT_Bone"): blendType = 4 count += 1 elif (sys.argv[count] == "-CT_Muscle"): blendType = 5 count += 1 elif (sys.argv[count] == "-RGB_Composite"): blendType = 6 count += 1 elif (sys.argv[count] == "-FrameRate"): frameRate = float(sys.argv[count + 1]) if (frameRate < 0.01 or frameRate > 60.0): print( "Invalid frame rate - use a number between 0.01 and 60.0") print("Using default frame rate of 10 frames per second.") frameRate = 10.0 count += 2 elif (sys.argv[count] == "-ReductionFactor"): reductionFactor = float(sys.argv[count + 1]) if (reductionFactor <= 0.0 or reductionFactor >= 1.0): print( "Invalid reduction factor - use a number between 0 and 1 (exclusive)" ) print("Using the default of no reduction.") reductionFactor = 1.0 count += 2 elif (sys.argv[count] == "-DependentComponents"): independentComponents = false count += 1 else: print("Unrecognized option: %s\n" % (sys.argv[count])) PrintUsage() sys.exit(-1) if (dirname is None and fileName is None): print( "Error: you must specify a directory of DICOM data or a .vti file or a .mha!" ) PrintUsage() sys.exit(-1) # Create the renderer, render window and interactor renderer = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(renderer) # Connect it all. Note that funny arithematic on the # SetDesiredUpdateRate - the vtkRenderWindow divides it # allocated time across all renderers, and the renderer # divides it time across all props. If clip is # true then there are two props iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.SetDesiredUpdateRate(frameRate / (1.0 + clip)) iren.GetInteractorStyle().SetDefaultRenderer(renderer) # Read the data reader = None _input = None if (dirname): dicomReader = vtk.vtkDICOMImageReader() dicomReader.SetDirectoryName(dirname) dicomReader.Update() _input = dicomReader.GetOutput() reader = dicomReader elif (fileType == VTI_FILETYPE): xmlReader = vtk.vtkXMLImageDataReader() xmlReader.SetFileName(fileName) xmlReader.Update() _input = xmlReader.GetOutput() reader = xmlReader elif (fileType == MHA_FILETYPE): metaReader = vtk.vtkMetaImageReader() metaReader.SetFileName(fileName) metaReader.Update() _input = metaReader.GetOutput() reader = metaReader else: print("Error! Not VTI or MHA!") exit(-1) # Verify that we actually have a volume dim = _input.GetDimensions() if (dim[0] < 2 or dim[1] < 2 or dim[2] < 2): print("Error loading data!") sys.exit(-1) resample = vtk.vtkImageResample() if (reductionFactor < 1.0): resample.SetInputConnection(reader.GetOutputPort()) resample.SetAxisMagnificationFactor(0, reductionFactor) resample.SetAxisMagnificationFactor(1, reductionFactor) resample.SetAxisMagnificationFactor(2, reductionFactor) # Create our volume and mapper volume = vtk.vtkVolume() mapper = vtk.vtkSmartVolumeMapper() # Add a box widget if the clip option was selected box = vtk.vtkBoxWidget() if (clip): box.SetInteractor(iren) box.SetPlaceFactor(1.01) if (reductionFactor < 1.0): box.SetInputConnection(resample.GetOutputPort()) else: box.SetInputData(_input) box.SetDefaultRenderer(renderer) box.InsideOutOn() box.PlaceWidget() callback = vtkBoxWidgetCallback() callback.SetMapper(mapper) box.AddObserver(vtk.vtkCommand.InteractionEvent, callback.onExecute) box.EnabledOn() box.GetSelectedFaceProperty().SetOpacity(0.0) if (reductionFactor < 1.0): mapper.SetInputConnection(resample.GetOutputPort()) else: mapper.SetInputConnection(reader.GetOutputPort()) # Set the sample distance on the ray to be 1/2 the average spacing spacing = None if (reductionFactor < 1.0): spacing = resample.GetOutput().GetSpacing() else: spacing = _input.GetSpacing() # mapper.SetSampleDistance( (spacing[0]+spacing[1]+spacing[2])/6.0 ) # mapper.SetMaximumImageSampleDistance(10.0) # Create our transfer function colorFun = vtk.vtkColorTransferFunction() opacityFun = vtk.vtkPiecewiseFunction() # Create the property and attach the transfer functions _property = vtk.vtkVolumeProperty() _property.SetIndependentComponents(independentComponents) _property.SetColor(colorFun) _property.SetScalarOpacity(opacityFun) _property.SetInterpolationTypeToLinear() # connect up the volume to the property and the mapper volume.SetProperty(_property) volume.SetMapper(mapper) # Depending on the blend type selected as a command line option, # adjust the transfer function if (blendType == 0): # MIP # Create an opacity ramp from the window and level values. # Color is white. Blending is MIP. colorFun.AddRGBSegment(0.0, 1.0, 1.0, 1.0, 255.0, 1.0, 1.0, 1.0) opacityFun.AddSegment(opacityLevel - 0.5 * opacityWindow, 0.0, opacityLevel + 0.5 * opacityWindow, 1.0) mapper.SetBlendModeToMaximumIntensity() elif blendType == 1: # CompositeRamp # Create a ramp from the window and level values. Use compositing # without shading. Color is a ramp from black to white. colorFun.AddRGBSegment(opacityLevel - 0.5 * opacityWindow, 0.0, 0.0, 0.0, opacityLevel + 0.5 * opacityWindow, 1.0, 1.0, 1.0) opacityFun.AddSegment(opacityLevel - 0.5 * opacityWindow, 0.0, opacityLevel + 0.5 * opacityWindow, 1.0) mapper.SetBlendModeToComposite() _property.ShadeOff() elif blendType == 2: # CompositeShadeRamp # Create a ramp from the window and level values. Use compositing # with shading. Color is white. colorFun.AddRGBSegment(0.0, 1.0, 1.0, 1.0, 255.0, 1.0, 1.0, 1.0) opacityFun.AddSegment(opacityLevel - 0.5 * opacityWindow, 0.0, opacityLevel + 0.5 * opacityWindow, 1.0) mapper.SetBlendModeToComposite() _property.ShadeOn() elif blendType == 3: # CT_Skin # Use compositing and functions set to highlight skin in CT data # Not for use on RGB data colorFun.AddRGBPoint(-3024, 0, 0, 0, 0.5, 0.0) colorFun.AddRGBPoint(-1000, .62, .36, .18, 0.5, 0.0) colorFun.AddRGBPoint(-500, .88, .60, .29, 0.33, 0.45) colorFun.AddRGBPoint(3071, .83, .66, 1, 0.5, 0.0) opacityFun.AddPoint(-3024, 0, 0.5, 0.0) opacityFun.AddPoint(-1000, 0, 0.5, 0.0) opacityFun.AddPoint(-500, 1.0, 0.33, 0.45) opacityFun.AddPoint(3071, 1.0, 0.5, 0.0) mapper.SetBlendModeToComposite() _property.ShadeOn() _property.SetAmbient(0.1) _property.SetDiffuse(0.9) _property.SetSpecular(0.2) _property.SetSpecularPower(10.0) _property.SetScalarOpacityUnitDistance(0.8919) elif blendType == 4: # CT_Bone # Use compositing and functions set to highlight bone in CT data # Not for use on RGB data colorFun.AddRGBPoint(-3024, 0, 0, 0, 0.5, 0.0) colorFun.AddRGBPoint(-16, 0.73, 0.25, 0.30, 0.49, .61) colorFun.AddRGBPoint(641, .90, .82, .56, .5, 0.0) colorFun.AddRGBPoint(3071, 1, 1, 1, .5, 0.0) opacityFun.AddPoint(-3024, 0, 0.5, 0.0) opacityFun.AddPoint(-16, 0, .49, .61) opacityFun.AddPoint(641, .72, .5, 0.0) opacityFun.AddPoint(3071, .71, 0.5, 0.0) mapper.SetBlendModeToComposite() _property.ShadeOn() _property.SetAmbient(0.1) _property.SetDiffuse(0.9) _property.SetSpecular(0.2) _property.SetSpecularPower(10.0) _property.SetScalarOpacityUnitDistance(0.8919) elif blendType == 5: # CT_Muscle # Use compositing and functions set to highlight muscle in CT data # Not for use on RGB data colorFun.AddRGBPoint(-3024, 0, 0, 0, 0.5, 0.0) colorFun.AddRGBPoint(-155, .55, .25, .15, 0.5, .92) colorFun.AddRGBPoint(217, .88, .60, .29, 0.33, 0.45) colorFun.AddRGBPoint(420, 1, .94, .95, 0.5, 0.0) colorFun.AddRGBPoint(3071, .83, .66, 1, 0.5, 0.0) opacityFun.AddPoint(-3024, 0, 0.5, 0.0) opacityFun.AddPoint(-155, 0, 0.5, 0.92) opacityFun.AddPoint(217, .68, 0.33, 0.45) opacityFun.AddPoint(420, .83, 0.5, 0.0) opacityFun.AddPoint(3071, .80, 0.5, 0.0) mapper.SetBlendModeToComposite() _property.ShadeOn() _property.SetAmbient(0.1) _property.SetDiffuse(0.9) _property.SetSpecular(0.2) _property.SetSpecularPower(10.0) _property.SetScalarOpacityUnitDistance(0.8919) elif blendType == 6: # RGB_Composite # Use compositing and functions set to highlight red/green/blue regions # in RGB data. Not for use on single component data opacityFun.AddPoint(0, 0.0) opacityFun.AddPoint(5.0, 0.0) opacityFun.AddPoint(30.0, 0.05) opacityFun.AddPoint(31.0, 0.0) opacityFun.AddPoint(90.0, 0.0) opacityFun.AddPoint(100.0, 0.3) opacityFun.AddPoint(110.0, 0.0) opacityFun.AddPoint(190.0, 0.0) opacityFun.AddPoint(200.0, 0.4) opacityFun.AddPoint(210.0, 0.0) opacityFun.AddPoint(245.0, 0.0) opacityFun.AddPoint(255.0, 0.5) mapper.SetBlendModeToComposite() _property.ShadeOff() _property.SetScalarOpacityUnitDistance(1.0) else: print("Unknown blend type.") # Set the default window size renWin.SetSize(600, 600) renWin.Render() # Add the volume to the scene renderer.AddVolume(volume) renderer.ResetCamera() # interact with data renWin.Render() iren.Start() return 0
def main(): sphereSource = vtk.vtkSphereSource() sphereSource.SetCenter(0.0, 0.0, 0.0) sphereSource.SetRadius(1.0) sphereSource.Update() sphereMapper = vtk.vtkPolyDataMapper() sphereMapper.SetInputConnection(sphereSource.GetOutputPort()) sphereMapper.ScalarVisibilityOff() sphereActor = vtk.vtkActor() sphereActor.SetMapper(sphereMapper) sphereActor.GetProperty().SetOpacity(.3) sphereActor.GetProperty().SetColor(1, 0, 0) implicitPolyDataDistance = vtk.vtkImplicitPolyDataDistance() implicitPolyDataDistance.SetInput(sphereSource.GetOutput()) # Setup a grid points = vtk.vtkPoints() step = 0.1 for x in np.arange(-2, 2, step): for y in np.arange(-2, 2, step): for z in np.arange(-2, 2, step): points.InsertNextPoint(x, y, z) # Add distances to each point signedDistances = vtk.vtkFloatArray() signedDistances.SetNumberOfComponents(1) signedDistances.SetName("SignedDistances") # Evaluate the signed distance function at all of the grid points for pointId in range(points.GetNumberOfPoints()): p = points.GetPoint(pointId) signedDistance = implicitPolyDataDistance.EvaluateFunction(p) signedDistances.InsertNextValue(signedDistance) polyData = vtk.vtkPolyData() polyData.SetPoints(points) polyData.GetPointData().SetScalars(signedDistances) vertexGlyphFilter = vtk.vtkVertexGlyphFilter() vertexGlyphFilter.SetInputData(polyData) vertexGlyphFilter.Update() signedDistanceMapper = vtk.vtkPolyDataMapper() signedDistanceMapper.SetInputConnection(vertexGlyphFilter.GetOutputPort()) signedDistanceMapper.ScalarVisibilityOn() signedDistanceActor = vtk.vtkActor() signedDistanceActor.SetMapper(signedDistanceMapper) renderer = vtk.vtkRenderer() renderer.AddViewProp(sphereActor) renderer.AddViewProp(signedDistanceActor) renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renWinInteractor = vtk.vtkRenderWindowInteractor() renWinInteractor.SetRenderWindow(renderWindow) renderWindow.Render() renWinInteractor.Start()
def RenderModel(model, textHeight=5): visNodes = [] for node in model.Nodes: visNodes.append(VisNode(node, textHeight)) visAuxNodes = [] for auxnode in model.auxNodes: visAuxNodes.append(VisNode(auxnode, textHeight, color='red')) visMembers = [] for member in model.Members: visMembers.append(VisMember(member, model.Nodes, textHeight)) visPlates = [] for plate in model.Plates: visPlates.append(VisPlate(plate, model.Nodes, textHeight)) # Create a window window = vtk.vtkRenderWindow() # Set the pixel width and length of the window window.SetSize(500, 500) # Set up the interactor # The interactor style determines how user interactions affect the view interactor = vtk.vtkRenderWindowInteractor() style = vtk.vtkInteractorStyleTrackballCamera( ) # The trackball camera style behaves a lot like most CAD programs interactor.SetInteractorStyle(style) interactor.SetRenderWindow(window) # Create a renderer renderer = vtk.vtkRenderer() window.AddRenderer(renderer) # Add actors for each member for visMember in visMembers: # Add the actor for the member renderer.AddActor(visMember.actor) # Add the actor for the member label renderer.AddActor(visMember.lblActor) # Set the text to follow the camera as the user interacts # This next line will require us to reset the camera when we're done (below) visMember.lblActor.SetCamera(renderer.GetActiveCamera()) # Add actors for each node for visNode in visNodes: # Add the actor for the node renderer.AddActor(visNode.actor) # Add the actor for the node label renderer.AddActor(visNode.lblActor) # Set the text to follow the camera as the user interacts # This next line will require us to reset the camera when we're done (below) visNode.lblActor.SetCamera(renderer.GetActiveCamera()) # Add actors for each plate for visPlate in visPlates: # Add the actors for the plate renderer.AddActor(visPlate.actor) # Add the actor for the plate label renderer.AddActor(visPlate.lblActor) # Set the text to follow the camera as the user interacts # This next line will require us to reset the camera when we're done (below) visPlate.lblActor.SetCamera(renderer.GetActiveCamera()) # Add actors for each auxnode for visAuxNode in visAuxNodes: # Add the actor for the node renderer.AddActor(visAuxNode.actor) # Add the actor for the node label renderer.AddActor(visAuxNode.lblActor) # Set the text to follow the camera as the user interacts # This next line will require us to reset the camera when we're done (below) visAuxNode.lblActor.SetCamera(renderer.GetActiveCamera()) # Setting the background to blue. renderer.SetBackground(0.1, 0.1, 0.4) # Reset the camera renderer.ResetCamera() window.Render() interactor.Start()
def main(): nx, ny, nz = get_program_parameters() colors = vtk.vtkNamedColors() angle = 0 r1 = 50 r2 = 30 centerX = 10.0 centerY = 5.0 points = vtk.vtkPoints() idx = 0 while angle <= 2.0 * vtk.vtkMath.Pi() + (vtk.vtkMath.Pi() / 60.0): points.InsertNextPoint(r1 * math.cos(angle) + centerX, r2 * math.sin(angle) + centerY, 0.0) angle = angle + (vtk.vtkMath.Pi() / 60.0) idx += 1 line = vtk.vtkPolyLine() line.GetPointIds().SetNumberOfIds(idx) for i in range(0, idx): line.GetPointIds().SetId(i, i) lines = vtk.vtkCellArray() lines.InsertNextCell(line) polyData = vtk.vtkPolyData() polyData.SetPoints(points) polyData.SetLines(lines) extrude = vtk.vtkLinearExtrusionFilter() extrude.SetInputData(polyData) extrude.SetExtrusionTypeToNormalExtrusion() extrude.SetVector(nx, ny, nz) extrude.Update() # Create an oriented arrow startPoint = [0.0] * 3 endPoint = [0.0] * 3 startPoint[0] = centerX startPoint[1] = centerY startPoint[2] = 0.0 for i in range(0, 3): endPoint[i] = startPoint[i] + extrude.GetVector()[i] # Compute a basis normalizedX = [0.0] * 3 normalizedY = [0.0] * 3 normalizedZ = [0.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) rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(8775070) max_r = 10.0 # The Z axis is an arbitrary vector cross X arbitrary = [0.0] * 3 for i in range(0, 3): arbitrary[i] = rng.GetRangeValue(-max_r, max_r) rng.Next() 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) transform.Concatenate(matrix) transform.Scale(length, length, length) arrowSource = vtk.vtkArrowSource() arrowSource.SetTipResolution(31) arrowSource.SetShaftResolution(21) # Transform the polydata transformPD = vtk.vtkTransformPolyDataFilter() transformPD.SetTransform(transform) transformPD.SetInputConnection(arrowSource.GetOutputPort()) # Create a mapper and actor for the arrow arrowMapper = vtk.vtkPolyDataMapper() arrowMapper.SetInputConnection(transformPD.GetOutputPort()) arrowActor = vtk.vtkActor() arrowActor.SetMapper(arrowMapper) arrowActor.GetProperty().SetColor(colors.GetColor3d("Tomato")) tubes = vtk.vtkTubeFilter() tubes.SetInputData(polyData) tubes.SetRadius(2.0) tubes.SetNumberOfSides(21) lineMapper = vtk.vtkPolyDataMapper() lineMapper.SetInputConnection(tubes.GetOutputPort()) lineActor = vtk.vtkActor() lineActor.SetMapper(lineMapper) lineActor.GetProperty().SetColor(colors.GetColor3d("Peacock")) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(extrude.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.GetColor3d("Banana")) actor.GetProperty().SetOpacity(.7) ren = vtk.vtkRenderer() ren.SetBackground(colors.GetColor3d("SlateGray")) ren.AddActor(actor) ren.AddActor(lineActor) ren.AddActor(arrowActor) renWin = vtk.vtkRenderWindow() renWin.SetWindowName("Elliptical Cylinder Demo") renWin.AddRenderer(ren) renWin.SetSize(600, 600) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) style = vtk.vtkInteractorStyleTrackballCamera() iren.SetInteractorStyle(style) camera = vtk.vtkCamera() camera.SetPosition(0, 1, 0) camera.SetFocalPoint(0, 0, 0) camera.SetViewUp(0, 0, 1) camera.Azimuth(30) camera.Elevation(30) ren.SetActiveCamera(camera) ren.ResetCamera() ren.ResetCameraClippingRange() renWin.Render() iren.Start()
mapper4.SetColorLevel(1000) mapper4.SetZSlice(0) actor1 = vtk.vtkActor2D() actor1.SetMapper(mapper1) actor2 = vtk.vtkActor2D() actor2.SetMapper(mapper2) actor3 = vtk.vtkActor2D() actor3.SetMapper(mapper3) actor4 = vtk.vtkActor2D() actor4.SetMapper(mapper4) imager1 = vtk.vtkRenderer() imager1.AddActor2D(actor1) imager1.SetViewport(0.5, 0.0, 1.0, 0.5) imager2 = vtk.vtkRenderer() imager2.AddActor2D(actor2) imager2.SetViewport(0.0, 0.0, 0.5, 0.5) imager3 = vtk.vtkRenderer() imager3.AddActor2D(actor3) imager3.SetViewport(0.5, 0.5, 1.0, 1.0) imager4 = vtk.vtkRenderer() imager4.AddActor2D(actor4) imager4.SetViewport(0.0, 0.5, 0.5, 1.0) imgWin = vtk.vtkRenderWindow() imgWin.AddRenderer(imager1) imgWin.AddRenderer(imager2) imgWin.AddRenderer(imager3) imgWin.AddRenderer(imager4) imgWin.SetSize(512, 512) imgWin.Render() # --- end of script --
def render_cam_view(CADModel, FitResults, filename=None, oversampling=1, AA=1, Edges=False, EdgeColour=(1, 0, 0), EdgeWidth=2, Transparency=False, ROI=None, ROIColour=(0.8, 0, 0), ROIOpacity=0.3, roi_oversize=0, NearestNeighbourRemap=False, Verbose=True, Coords='Display', ScreenSize=None): """ Make CAD model renders from the camera's point of view, including all distortion effects etc. INPUTS: Required: CADModel - CAD model object FitResults - Fit results for the camera from whose viewpoint to do the render Optional (keyword): filename - filename, including file extension, to save resulting image (if not specified, the image is not saved). oversampling - the size of the rendered image is <real camera image size> * oversampling AA - Anti-aliasing factor. Larger numbers look nicer but take more memory to render Edges - Bool, if set to True renders the CAD model in wireframe (but still with occlusion) EdgeColour - 3-element tuple of floats 0-1, If Edges=True, what colour to make the edges in the wireframe (R,G,B) EdgeWidth - If Edges=True, line width for edges Transparency - whether to make black areas (i.e. background) transparent. ROI - An ROI definition object: if supplied, the ROI will be rendered on the image. ROIColour - (R,G,B) colour to render the ROI ROIOpacity - Opacity to render ROI qt_avilable_geometry - If being called from a Qt app, this must be used. OUTPUTS: im - numpy array with RGB[A] image If filename is provided, saves the render with the specified filename """ if Coords.lower() == 'original' and oversampling != 1: raise Exception( 'Cannot render in original coordinates with oversampling!') logbase2 = np.log(oversampling) / np.log(2) if abs(int(logbase2) - logbase2) > 1e-5: raise ValueError('Oversampling must be a power of two!') if Verbose: tstart = time.time() print('[Calcam Renderer] Preparing...') # This will be our result. To start with we always render in display coords. OutputImage = np.zeros([ int(FitResults.image_display_shape[1] * oversampling), int(FitResults.image_display_shape[0] * oversampling), 3 + Transparency ], dtype='uint8') # The un-distorted FOV is over-rendered to allow for distortion. # FOV_factor is how much to do this by; too small and image edges might be cut off. models = [] for field in FitResults.fit_params: models.append(field.model) if np.any(np.array(models) == 'fisheye'): FOV_factor = 3. else: FOV_factor = 1.5 x_pixels = FitResults.image_display_shape[0] y_pixels = FitResults.image_display_shape[1] renWin = vtk.vtkRenderWindow() renWin.OffScreenRenderingOn() # Get the screen resolution - even using off screen rendering, if the VTK render window # doesn't fit on the screen it causes problems. # Maybe slightly hacky way of finding this out? But I don't know a better one. if ScreenSize is None: try: app = qt.QApplication(sys.argv) desktopinfo = app.desktop() dummydialog = qt.QDialog() qt_available_geometry = desktopinfo.availableGeometry(dummydialog) ScreenSize = (qt_available_geometry.width(), available_geometry.height()) del qt_available_geometry, dummydialog, desktopinfo, app except: ScreenSize = (800, 600) # Set up render window for initial, un-distorted window renderer = vtk.vtkRenderer() renWin.AddRenderer(renderer) Camera = renderer.GetActiveCamera() # Set the model face colour to black if we only want to see edges if Edges: CADModel.edges = True CADModel.edge_width = EdgeWidth # If rendering wireframe, set the CAD model colour to the desired edge colour. Before we do that, save the colours we started with. oldColours = [] for Feature in CADModel.features: oldColours.append((Feature[4], Feature[0])) CADModel.set_colour(EdgeColour) # This whole thing is in a try() except() because it is prone to memory errors, and I need to put the CAD model # colour back the way it started if we have a problem. try: # Add all the bits of the machine for Actor in CADModel.get_vtkActors(): renderer.AddActor(Actor) # Add the ROI if provided if ROI is not None: try: n_rois = len(ROI.rois) for roi in ROI.rois: ROIActor = roi.get_vtkActor(FitResults.get_pupilpos()) ROIActor.GetProperty().SetColor(ROIColour) ROIActor.GetProperty().SetOpacity(ROIOpacity) if roi_oversize > 0: ROIActor.GetProperty().EdgeVisibilityOn() ROIActor.GetProperty().SetLineWidth(roi_oversize * 2.) ROIActor.GetProperty().SetEdgeColor(ROIColour) renderer.AddActor(ROIActor) except AttributeError: ROIActor = ROI.get_vtkActor(FitResults.get_pupilpos(field=0)) ROIActor.GetProperty().SetColor(ROIColour) ROIActor.GetProperty().SetOpacity(ROIOpacity) if roi_oversize > 0: ROIActor.GetProperty().EdgeVisibilityOn() ROIActor.GetProperty().SetLineWidth(roi_oversize * 2.) ROIActor.GetProperty().SetEdgeColor(ROIColour) renderer.AddActor(ROIActor) # We need a field mask the same size as the output FieldMask = cv2.resize( FitResults.fieldmask, (int(x_pixels * oversampling), int(y_pixels * oversampling)), interpolation=cv2.INTER_NEAREST) for field in range(FitResults.nfields): Cx = FitResults.fit_params[field].cam_matrix[0, 2] Cy = FitResults.fit_params[field].cam_matrix[1, 2] Fy = FitResults.fit_params[field].cam_matrix[1, 1] vtk_win_im = vtk.vtkRenderLargeImage() vtk_win_im.SetInput(renderer) # Width and height - initial render will be put optical centre in the window centre wt = int(2 * FOV_factor * max(Cx, x_pixels - Cx)) ht = int(2 * FOV_factor * max(Cy, y_pixels - Cy)) # Make sure the intended render window will fit on the screen window_factor = 1 if wt > ScreenSize[0] or ht > ScreenSize[1]: window_factor = int( max(np.ceil(float(wt) / float(ScreenSize[0])), np.ceil(float(ht) / float(ScreenSize[1])))) vtk_win_im.SetMagnification( int(window_factor * AA * max(oversampling, 1))) width = int(wt / window_factor) height = int(ht / window_factor) renWin.SetSize(width, height) # Set up CAD camera FOV_y = 360 * np.arctan(ht / (2 * Fy)) / 3.14159 CamPos = FitResults.get_pupilpos(field=field) CamTar = FitResults.get_los_direction(Cx, Cy, ForceField=field) + CamPos UpVec = -1. * FitResults.get_cam_to_lab_rotation(field=field)[:, 1] Camera.SetPosition(CamPos) Camera.SetViewAngle(FOV_y) Camera.SetFocalPoint(CamTar) Camera.SetViewUp(UpVec) if Verbose: print( '[Calcam Renderer] Rendering (Field {:d}/{:d})...'.format( field + 1, FitResults.nfields)) # Do the render and grab an image renWin.Render() vtk_win_im.Update() vtk_image = vtk_win_im.GetOutput() if field == FitResults.nfields - 1: renWin.Finalize() if Edges: # Put the colour scheme back to how it was for Feature in oldColours: CADModel.set_colour(Feature[0], Feature[1]) Actor.GetProperty().EdgeVisibilityOff() vtk_array = vtk_image.GetPointData().GetScalars() dims = vtk_image.GetDimensions() im = np.flipud( vtk.util.numpy_support.vtk_to_numpy(vtk_array).reshape( dims[1], dims[0], 3)) if Transparency: alpha = 255 * np.ones( [np.shape(im)[0], np.shape(im)[1]], dtype='uint8') alpha[np.sum(im, axis=2) == 0] = 0 im = np.dstack((im, alpha)) im = cv2.resize(im, (int(dims[0] / AA * min(oversampling, 1)), int(dims[1] / AA * min(oversampling, 1))), interpolation=cv2.INTER_AREA) if Verbose: print( '[Calcam Renderer] Applying lens distortion (Field {:d}/{:d})...' .format(field + 1, FitResults.nfields)) # Pixel locations we want on the final image [xn, yn] = np.meshgrid( np.linspace(0, x_pixels - 1, x_pixels * oversampling), np.linspace(0, y_pixels - 1, y_pixels * oversampling)) xn, yn = FitResults.normalise(xn, yn, field) # Transform back to pixel coords where we want to sample the un-distorted render. # Both x and y are divided by Fy because the initial render always has Fx = Fy. xmap = ((xn * Fy) + (width * window_factor) / 2.) * oversampling ymap = ((yn * Fy) + (height * window_factor) / 2.) * oversampling xmap = xmap.astype('float32') ymap = ymap.astype('float32') # Actually apply distortion if NearestNeighbourRemap: interp_method = cv2.INTER_NEAREST else: interp_method = cv2.INTER_CUBIC im = cv2.remap(im, xmap, ymap, interp_method) OutputImage[FieldMask == field, :] = im[FieldMask == field, :] CADModel.edges = False if Coords.lower() == 'original': OutputImage = FitResults.transform.display_to_original_image( OutputImage) if Verbose: print( '[Calcam Renderer] Completed in {:.1f} s.'.format(time.time() - tstart)) # Save the image if given a filename if filename is not None: # If we have transparency, we can only save as PNG. if Transparency and filename[-3:].lower() != 'png': print( '[Calcam Renderer] Images with transparency can only be saved as PNG! Overriding output file type to PNG.' ) filename = filename[:-3] + 'png' # Re-shuffle the colour channels for saving (openCV needs BGR / BGRA) SaveIm = OutputImage SaveIm[:, :, :3] = OutputImage[:, :, 2::-1] cv2.imwrite(filename, SaveIm) if Verbose: print( '[Calcam Renderer] Result saved as {:s}'.format(filename)) except: if Edges: CADModel.edges = False # Put the colour scheme back to how it was for Feature in oldColours: CADModel.set_colour(Feature[0], Feature[1]) Actor.GetProperty().EdgeVisibilityOff() try: renWin.Finalize() except: pass raise return OutputImage
def main(): """ Visualization of 3D grid anchor generation, showing 2D projections in BEV and image space, and a 3D display of the anchors """ dataset_config = DatasetBuilder.copy_config(DatasetBuilder.KITTI_TRAIN) dataset_config.num_clusters[0] = 1 dataset = DatasetBuilder.build_kitti_dataset(dataset_config) label_cluster_utils = LabelClusterUtils(dataset) clusters, _ = label_cluster_utils.get_clusters() # Options img_idx = 1 # fake_clusters = np.array([[5, 4, 3], [6, 5, 4]]) # fake_clusters = np.array([[3, 3, 3], [4, 4, 4]]) fake_clusters = np.array([[4, 2, 3]]) fake_anchor_stride = [5.0, 5.0] ground_plane = [0, -1, 0, 1.72] anchor_3d_generator = grid_anchor_3d_generator.GridAnchor3dGenerator() area_extents = np.array([[-40, 40], [-5, 5], [0, 70]]) # Generate anchors for cars only start_time = time.time() anchor_boxes_3d = anchor_3d_generator.generate( area_3d=dataset.kitti_utils.area_extents, anchor_3d_sizes=fake_clusters, anchor_stride=fake_anchor_stride, ground_plane=ground_plane) all_anchors = box_3d_encoder.box_3d_to_anchor(anchor_boxes_3d) end_time = time.time() print("Anchors generated in {} s".format(end_time - start_time)) # Project into bev bev_boxes, bev_normalized_boxes = \ anchor_projector.project_to_bev(all_anchors, area_extents[[0, 2]]) bev_fig, (bev_axes, bev_normalized_axes) = \ plt.subplots(1, 2, figsize=(16, 7)) bev_axes.set_xlim(0, 80) bev_axes.set_ylim(70, 0) bev_normalized_axes.set_xlim(0, 1.0) bev_normalized_axes.set_ylim(1, 0.0) plt.show(block=False) for box in bev_boxes: box_w = box[2] - box[0] box_h = box[3] - box[1] rect = patches.Rectangle((box[0], box[1]), box_w, box_h, linewidth=2, edgecolor='b', facecolor='none') bev_axes.add_patch(rect) for normalized_box in bev_normalized_boxes: box_w = normalized_box[2] - normalized_box[0] box_h = normalized_box[3] - normalized_box[1] rect = patches.Rectangle((normalized_box[0], normalized_box[1]), box_w, box_h, linewidth=2, edgecolor='b', facecolor='none') bev_normalized_axes.add_patch(rect) rgb_fig, rgb_2d_axes, rgb_3d_axes = \ vis_utils.visualization(dataset.rgb_image_dir, img_idx) plt.show(block=False) image_path = dataset.get_rgb_image_path(dataset.sample_names[img_idx]) image_shape = np.array(Image.open(image_path)).shape stereo_calib_p2 = calib_utils.read_calibration(dataset.calib_dir, img_idx).p2 start_time = time.time() rgb_boxes, rgb_normalized_boxes = \ anchor_projector.project_to_image_space(all_anchors, stereo_calib_p2, image_shape) end_time = time.time() print("Anchors projected in {} s".format(end_time - start_time)) # Read the stereo calibration matrix for visualization stereo_calib = calib_utils.read_calibration(dataset.calib_dir, 0) p = stereo_calib.p2 # Overlay boxes on images anchor_objects = [] for anchor_idx in range(len(anchor_boxes_3d)): anchor_box_3d = anchor_boxes_3d[anchor_idx] obj_label = box_3d_encoder.box_3d_to_object_label(anchor_box_3d) # Append to a list for visualization in VTK later anchor_objects.append(obj_label) # Draw 3D boxes vis_utils.draw_box_3d(rgb_3d_axes, obj_label, p) # Draw 2D boxes rgb_box_2d = rgb_boxes[anchor_idx] box_x1 = rgb_box_2d[0] box_y1 = rgb_box_2d[1] box_w = rgb_box_2d[2] - box_x1 box_h = rgb_box_2d[3] - box_y1 rect = patches.Rectangle((box_x1, box_y1), box_w, box_h, linewidth=2, edgecolor='b', facecolor='none') rgb_2d_axes.add_patch(rect) if anchor_idx % 32 == 0: rgb_fig.canvas.draw() plt.show(block=False) # Create VtkGroundPlane for ground plane visualization vtk_ground_plane = VtkGroundPlane() vtk_ground_plane.set_plane(ground_plane, area_extents[[0, 2]]) # Create VtkAxes axes = vtk.vtkAxesActor() axes.SetTotalLength(5, 5, 5) # Create VtkBoxes for boxes vtk_boxes = VtkBoxes() vtk_boxes.set_objects(anchor_objects, vtk_boxes.COLOUR_SCHEME_KITTI) # Create Voxel Grid Renderer in bottom half vtk_renderer = vtk.vtkRenderer() vtk_renderer.AddActor(vtk_boxes.vtk_actor) vtk_renderer.AddActor(vtk_ground_plane.vtk_actor) vtk_renderer.AddActor(axes) vtk_renderer.SetBackground(0.2, 0.3, 0.4) # Setup Camera current_cam = vtk_renderer.GetActiveCamera() current_cam.Pitch(170.0) current_cam.Roll(180.0) # Zooms out to fit all points on screen vtk_renderer.ResetCamera() # Zoom in slightly current_cam.Zoom(2.5) # Reset the clipping range to show all points vtk_renderer.ResetCameraClippingRange() # Setup Render Window vtk_render_window = vtk.vtkRenderWindow() vtk_render_window.SetWindowName("Anchors") vtk_render_window.SetSize(900, 500) vtk_render_window.AddRenderer(vtk_renderer) # Setup custom interactor style, which handles mouse and key events vtk_render_window_interactor = vtk.vtkRenderWindowInteractor() vtk_render_window_interactor.SetRenderWindow(vtk_render_window) vtk_render_window_interactor.SetInteractorStyle( vtk.vtkInteractorStyleTrackballCamera()) # Render in VTK vtk_render_window.Render() vtk_render_window_interactor.Start() # Blocking
def __init__(self, element_color_mapping=None, show_unit_cell=True, show_bonds=False, show_polyhedron=True, poly_radii_tol_factor=0.5, excluded_bonding_elements=None): """ Args: element_color_mapping: Optional color mapping for the elements, as a dict of {symbol: rgb tuple}. For example, {"Fe": (255,123,0), ....} If None is specified, a default based on Jmol"s color scheme is used. show_unit_cell: Set to False to not show the unit cell boundaries. Defaults to True. show_bonds: Set to True to show bonds. Defaults to True. show_polyhedron: Set to True to show polyhedrons. Defaults to False. poly_radii_tol_factor: The polyhedron and bonding code uses the ionic radii of the elements or species to determine if two atoms are bonded. This specifies a tolerance scaling factor such that atoms which are (1 + poly_radii_tol_factor) * sum of ionic radii apart are still considered as bonded. excluded_bonding_elements: List of atom types to exclude from bonding determination. Defaults to an empty list. Useful when trying to visualize a certain atom type in the framework (e.g., Li in a Li-ion battery cathode material). Useful keyboard shortcuts implemented. h : Show help A/a : Increase/decrease cell by one unit vector in a-direction B/b : Increase/decrease cell by one unit vector in b-direction C/c : Increase/decrease cell by one unit vector in c-direction # : Toggle showing of polyhedrons - : Toggle showing of bonds [ : Decrease poly_radii_tol_factor by 0.05 ] : Increase poly_radii_tol_factor by 0.05 r : Reset camera direction o : Orthogonalize structure Up/Down : Rotate view along Up direction by 90 clock/anticlockwise Left/right : Rotate view along camera direction by 90 clock/anticlockwise """ # create a rendering window and renderer self.ren = vtk.vtkRenderer() self.ren_win = vtk.vtkRenderWindow() self.ren_win.AddRenderer(self.ren) self.ren.SetBackground(1, 1, 1) self.title = "Structure Visualizer" # create a renderwindowinteractor self.iren = vtk.vtkRenderWindowInteractor() self.iren.SetRenderWindow(self.ren_win) self.mapper_map = {} self.structure = None if element_color_mapping: self.el_color_mapping = element_color_mapping else: module_dir = os.path.dirname(os.path.abspath(__file__)) config = ConfigParser.SafeConfigParser() config.optionxform = str config.readfp(open(os.path.join(module_dir, "ElementColorSchemes.cfg"))) self.el_color_mapping = {} for (el, color) in config.items("VESTA"): self.el_color_mapping[el] = [int(i) for i in color.split(",")] self.show_unit_cell = show_unit_cell self.show_bonds = show_bonds self.show_polyhedron = show_polyhedron self.poly_radii_tol_factor = poly_radii_tol_factor self.excluded_bonding_elements = excluded_bonding_elements if \ excluded_bonding_elements else [] self.show_help = True self.supercell = [[1, 0, 0], [0, 1, 0], [0, 0, 1]] self.redraw() style = StructureInteractorStyle(self) self.iren.SetInteractorStyle(style)
def test_get_vtk_pane_type_from_render_window(): assert PaneBase.get_pane_type( vtk.vtkRenderWindow()) is VTKRenderWindowSynchronized assert PaneBase.get_pane_type( vtk.vtkRenderWindow(), serialize_on_instantiation=True) is VTKRenderWindow
# Setup right wing actor r_wing_actor = vtk.vtkActor() r_wing_actor.GetProperty().SetColor((0.6, 0.6, 0.6)) r_wing_actor.GetProperty().SetOpacity(0.7) r_wing_actor.GetProperty().SetInterpolationToGouraud() #r_wing_actor.GetProperty().SetAmbient(0.3) r_wing_actor.SetMapper(wing_mapper) # Read log file log_fid = open(log_file, 'r') log = cPickle.load(log_fid) log_fid.close() # Create the Renderer, RenderWindow, and RenderWindowInteractor ren = vtk.vtkRenderer() ren_win = vtk.vtkRenderWindow() ren_win.AddRenderer(ren) ren.SetBackground(0.0, 0.0, 0.0) ren_win.FullScreenOn() ren_win.SwapBuffersOn() # Create balls if 1: ball_grid = (4, 3) ball_spacing = 100 ball_z = -20.0 ball = vtk.vtkSphereSource() ball.SetRadius(10.0) ball.SetThetaResolution(25) ball.SetPhiResolution(25) mapBall = vtk.vtkPolyDataMapper()
def main(argc, argv): if (argc != 7): print("Usage: " + argv[0] + " Theta Phi MaximumPeels " + "OcclusionRatio ForceDepthSortingFlag " + "DoNotUseAnyDepthRelatedAlgorithmFlag" + "\n") print("100 100 50 0.1 0 0") return -1 colors = vtk.vtkNamedColors() theta = int(argv[1]) phi = int(argv[2]) maxPeels = int(argv[3]) occulusionRatio = float(argv[4]) forceDepthSort = int(argv[5]) == 1 withoutAnyDepthThings = (argv[6]) == 1 # Generate a translucent sphere poly data set that partially overlaps: translucentGeometry = GenerateOverlappingBunchOfSpheres(theta, phi) # generate a basic Mapper and Actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(translucentGeometry.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetOpacity(0.5) # translucent !!! actor.GetProperty().SetColor(colors.GetColor3d("Crimson")) actor.RotateX(-72) # put the objects in a position where it is easy to see # different overlapping regions # Create the RenderWindow, Renderer and RenderWindowInteractor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(600, 400) renderWindow.AddRenderer(renderer) renderWindow.SetWindowName("CorrectlyRenderTranslucentGeometry") renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Add the actors to the renderer, set the background and size renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d("SlateGray")) # Setup view geometry renderer.ResetCamera() renderer.GetActiveCamera().Zoom(2.2) # so the object is larger renderWindow.Render() # Answer the key question: Does this box support GPU Depth Peeling? useDepthPeeling = IsDepthPeelingSupported(renderWindow, renderer, True) print("DEPTH PEELING SUPPORT: " + {1: "YES", 0: "NO"}[useDepthPeeling]) success = 0 # Use depth peeling if available and not explicitly prohibited, otherwise we # use manual depth sorting print("\n" + "CHOSEN MODE: ") if (useDepthPeeling and ~forceDepthSort and ~withoutAnyDepthThings): # GPU print("*** DEPTH PEELING ***") # Setup GPU depth peeling with configured parameters success = ~SetupEnvironmentForDepthPeeling(renderWindow, renderer, maxPeels, occulusionRatio) elif (~withoutAnyDepthThings): print("*** DEPTH SORTING ***") # Setup CPU depth sorting filter depthSort = vtk.vtkDepthSortPolyData() depthSort.SetInputConnection(translucentGeometry.GetOutputPort()) depthSort.SetDirectionToBackToFront() depthSort.SetVector(1, 1, 1) depthSort.SetCamera(renderer.GetActiveCamera()) depthSort.SortScalarsOff() # do not really need this here # Bring it to the mapper's input mapper.SetInputConnection(depthSort.GetOutputPort()) depthSort.Update() else: print("*** NEITHER DEPTH PEELING NOR DEPTH SORTING ***") # Initialize interaction renderWindowInteractor.Initialize() # Check the average frame rate when rotating the actor endCount = 100 clock = vtk.vtkTimerLog() # Set a user transform for successively rotating the camera position transform = vtk.vtkTransform() transform.Identity() transform.RotateY(2.0) # rotate 2 degrees around Y-axis at each iteration camera = renderer.GetActiveCamera() # Start test clock.StartTimer() for i in range(endCount): camPos = camera.GetPosition() camPos = transform.TransformPoint(camPos) camera.SetPosition(camPos) renderWindow.Render() clock.StopTimer() frameRate = endCount / clock.GetElapsedTime() print("AVERAGE FRAME RATE: " + str(frameRate) + " fps") # Start interaction renderWindowInteractor.Start() return success
def testBug(self): # Uncomment the next line if you want to run this via # `gdb python`. #raw_input('Hit Ctrl-C') # Load some data. v16 = vtk.vtkVolume16Reader() v16.SetDataDimensions(64, 64) v16.SetDataByteOrderToLittleEndian() v16.SetFilePrefix( os.path.join(VTK_DATA_ROOT, "Data", "headsq", "quarter")) v16.SetImageRange(1, 93) v16.SetDataSpacing(3.2, 3.2, 1.5) v16.Update() xMin, xMax, yMin, yMax, zMin, zMax = v16.GetExecutive().GetWholeExtent( v16.GetOutputInformation(0)) img_data = v16.GetOutput() # ************************************************** # Look here for wierdness. # Lets create this data using the data from the reader. my_img_data = vtk.vtkImageData() my_img_data.SetDimensions(img_data.GetDimensions()) my_img_data.SetExtent(img_data.GetExtent()) my_img_data.SetSpacing(img_data.GetSpacing()) my_img_data.SetOrigin(img_data.GetOrigin()) my_img_data.SetScalarType(img_data.GetScalarType(), my_img_data.GetInformation()) my_img_data.GetPointData().SetScalars( img_data.GetPointData().GetScalars()) # hang on to original image data. orig_img_data = img_data # hijack img_data with our own. If you comment this out everything is # fine. img_data = my_img_data # ************************************************** spacing = img_data.GetSpacing() sx, sy, sz = spacing origin = img_data.GetOrigin() ox, oy, oz = origin # An outline is shown for context. outline = vtk.vtkOutlineFilter() outline.SetInputData(img_data) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) # The shared picker enables us to use 3 planes at one time # and gets the picking order right picker = vtk.vtkCellPicker() picker.SetTolerance(0.005) # The 3 image plane widgets are used to probe the dataset. planeWidgetX = vtk.vtkImagePlaneWidget() planeWidgetX.DisplayTextOn() planeWidgetX.SetInputData(img_data) planeWidgetX.SetPlaneOrientationToXAxes() planeWidgetX.SetSliceIndex(32) planeWidgetX.SetPicker(picker) planeWidgetX.SetKeyPressActivationValue("x") prop1 = planeWidgetX.GetPlaneProperty() prop1.SetColor(1, 0, 0) planeWidgetY = vtk.vtkImagePlaneWidget() planeWidgetY.DisplayTextOn() planeWidgetY.SetInputData(img_data) planeWidgetY.SetPlaneOrientationToYAxes() planeWidgetY.SetSliceIndex(32) planeWidgetY.SetPicker(picker) planeWidgetY.SetKeyPressActivationValue("y") prop2 = planeWidgetY.GetPlaneProperty() prop2.SetColor(1, 1, 0) planeWidgetY.SetLookupTable(planeWidgetX.GetLookupTable()) # for the z-slice, turn off texture interpolation: # interpolation is now nearest neighbour, to demonstrate # cross-hair cursor snapping to pixel centers planeWidgetZ = vtk.vtkImagePlaneWidget() planeWidgetZ.DisplayTextOn() planeWidgetZ.SetInputData(img_data) planeWidgetZ.SetPlaneOrientationToZAxes() planeWidgetZ.SetSliceIndex(46) planeWidgetZ.SetPicker(picker) planeWidgetZ.SetKeyPressActivationValue("z") prop3 = planeWidgetZ.GetPlaneProperty() prop3.SetColor(0, 0, 1) planeWidgetZ.SetLookupTable(planeWidgetX.GetLookupTable()) # Create the RenderWindow and Renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetMultiSamples(0) renWin.AddRenderer(ren) # Add the outline actor to the renderer, set the background # color and size ren.AddActor(outlineActor) renWin.SetSize(600, 600) ren.SetBackground(0.1, 0.1, 0.2) current_widget = planeWidgetZ mode_widget = planeWidgetZ # Set the interactor for the widgets iact = vtk.vtkRenderWindowInteractor() iact.SetRenderWindow(renWin) planeWidgetX.SetInteractor(iact) planeWidgetX.On() planeWidgetY.SetInteractor(iact) planeWidgetY.On() planeWidgetZ.SetInteractor(iact) planeWidgetZ.On() # Create an initial interesting view ren.ResetCamera() cam1 = ren.GetActiveCamera() cam1.Elevation(110) cam1.SetViewUp(0, 0, -1) cam1.Azimuth(45) ren.ResetCameraClippingRange() iact.Initialize() renWin.Render()
def render_window(actor, title, scalarBar, bounds): """ puts a vtk actor on the stage (renders an interactive window) @param actor a (single) actor, or a list of actors (ensemble) @param title window title @param scalarBar one or a list of vtkScalarBarActor (optional) @param bounds spatial bounds (to set axes actor, and camera position and focal point) @return a vtkRenderWindowInteractor use render_window(...).Start() to start interaction loop, or render_window(...).GetRenderWindow(), to write png (built in) Keypress j / Keypress t: toggle between joystick (position sensitive) and trackball (motion sensitive) styles. In joystick style, motion occurs continuously as long as a mouse button is pressed. In trackball style, motion occurs when the mouse button is pressed and the mouse pointer moves. Keypress c / Keypress a: toggle between camera and actor modes. In camera mode, mouse events affect the camera position and focal point. In actor mode, mouse events affect the actor that is under the mouse pointer. Button 1: rotate the camera around its focal point (if camera mode) or rotate the actor around its origin (if actor mode). The rotation is in the direction defined from the center of the renderer's viewport towards the mouse position. In joystick mode, the magnitude of the rotation is determined by the distance the mouse is from the center of the render window. Button 2: pan the camera (if camera mode) or translate the actor (if actor mode). In joystick mode, the direction of pan or translation is from the center of the viewport towards the mouse position. In trackball mode, the direction of motion is the direction the mouse moves. (Note: with 2-button mice, pan is defined as <Shift>-Button 1.) Button 3: zoom the camera (if camera mode) or scale the actor (if actor mode). Zoom in/increase scale if the mouse position is in the top half of the viewport; zoom out/decrease scale if the mouse position is in the bottom half. In joystick mode, the amount of zoom is controlled by the distance of the mouse pointer from the horizontal centerline of the window. Keypress 3: toggle the render window into and out of stereo mode. By default, red-blue stereo pairs are created. Some systems support Crystal Eyes LCD stereo glasses; you have to invoke SetStereoTypeToCrystalEyes() on the rendering window. Keypress e: exit the application. Keypress f: fly to the picked point Keypress p: perform a pick operation. The render window interactor has an internal instance of vtkCellPicker that it uses to pick. Keypress r: reset the camera view along the current view direction. Centers the actors and moves the camera so that all actors are visible. Keypress s: modify the representation of all actors so that they are surfaces. Keypress u: invoke the user-defined function. Typically, this keypress will bring up an interactor that you can type commands in. Typing u calls UserCallBack() on the vtkRenderWindowInteractor, which invokes a vtkCommand::UserEvent. In other words, to define a user-defined callback, just add an observer to the vtkCommand::UserEvent on the vtkRenderWindowInteractor object. Keypress w: modify the representation of all actors so that they are wireframe. (additional) Keypress g: save as png Keypress x,y,z,v: various views """ colors = vtk.vtkNamedColors() # Set the background color ren = vtk.vtkRenderer() # Set up window with interaction ren.SetBackground(colors.GetColor3d("Silver")) # Actors if isinstance(actor, list): actors = actor # plural else: actors = [actor] # army of one for a in actors: a.GetProperty().BackfaceCullingOff() # a.RotateX(-90) # x y z -> x z y ren.AddActor( a) # Add the actors to the renderer, set the background and size if scalarBar: # if isinstance(scalarBar, list): # c = 0. # for sb in scalarBar: # TODO looks awful # x = sb.GetPosition() # y = (x[0] + c, x[1]) # sb.SetPosition(y) # ren.AddActor2D(sb) # c -= 0.2 # else: ren.AddActor2D(scalarBar) axes = vtk.vtkAxesActor() axes.AxisLabelsOff() # because i am too lazy to change font size translate = vtk.vtkTransform() translate.Translate(bounds[0], bounds[2], bounds[4]) # minx, miny, minz axes.SetUserTransform(translate) ren.AddActor(axes) # Camera ren.ResetCamera() camera = ren.GetActiveCamera() camera.ParallelProjectionOn() camera.SetFocalPoint([0, 0, 0.5 * (bounds[4] + bounds[5])]) camera.SetPosition([200, 0, 0.5 * (bounds[4] + bounds[5])]) camera.SetViewUp(0, 0, 1) camera.Azimuth(30) camera.Elevation(30) camera.OrthogonalizeViewUp() camera.SetClippingRange(1, 1000) # Render Window renWin = vtk.vtkRenderWindow() # boss renWin.SetSize(1000, 1000) print("title", title) renWin.SetWindowName(title) renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) renWin.Render() iren.CreateRepeatingTimer( 50) # [ms] 0.5 s in case a timer event is interested iren.AddObserver('KeyPressEvent', lambda obj, ev: keypress_callback_(obj, ev, bounds), 1.0) iren.Initialize( ) # This allows the interactor to initalize itself. It has to be called before an event loop. for a in ren.GetActors(): a.Modified() # renWin.Render() return iren
def main(): grid = vtk.vtkUnstructuredGrid() grid_mapper = vtk.vtkDataSetMapper() if vtk.VTK_VERSION >= 6: grid_mapper.SetInputData(grid) else: grid_mapper.SetInput(grid) #if vtk.VTK_VERSION[0] <= 5: # grid_mapper.SetInputConnection(grid.GetProducerPort()) #else: # grid_mapper.SetInputData(grid) nodes = np.array([ [0., 0., 0.], [1., 0., 0.], [1., 1., 0.], [0., 2., 1.], ], dtype='float32') points = vtk.vtkPoints() points.SetNumberOfPoints(4) points_array = numpy_to_vtk( num_array=nodes, deep=True, array_type=vtk.VTK_FLOAT, ) nelements = 1 grid.Allocate(nelements, 1000) grid.SetPoints(points) elem = vtk.vtkQuad() pts = elem.GetPointIds() pts.SetId(0, 0) pts.SetId(1, 1) pts.SetId(2, 2) pts.SetId(3, 3) grid.InsertNextCell(elem.GetCellType(), pts) grid.Modified() forces = np.array([ [0., 0.1, 0.], [0., 0., 0.], [0., 0., 0.], [0., 0., .3], ], dtype='float32') rend = vtk.vtkRenderer() if 1: maskPts = vtk.vtkMaskPoints() if vtk.VTK_VERSION <= 5: maskPts.SetInputConnection(grid.GetProducerPort()) else: maskPts.SetInputData(grid) arrow = vtk.vtkArrowSource() arrow.SetTipResolution(16) arrow.SetTipLength(0.3) arrow.SetTipRadius(0.1) glyph = vtk.vtkGlyph3D() glyph.SetSourceConnection(arrow.GetOutputPort()) glyph.SetInputConnection(maskPts.GetOutputPort()) glyph.SetVectorModeToUseNormal() glyph.SetScaleFactor(1) glyph.SetColorModeToColorByVector() glyph.SetScaleModeToScaleByVector() glyph.OrientOn() glyph.Update() glyph_mapper = vtk.vtkPolyDataMapper() glyph_mapper.SetInputConnection(glyph.GetOutputPort()) glyph_mapper.SetScalarModeToUsePointFieldData() glyph_mapper.SetColorModeToMapScalars() glyph_mapper.ScalarVisibilityOn() glyph_mapper.SelectColorArray('Elevation') # Colour by scalars. #glyph_mapper.SetScalarRange(scalarRangeElevation) glyph_actor = vtk.vtkActor() glyph_actor.SetMapper(glyph_mapper) glyph_actor.RotateX(-45) glyph_actor.RotateZ(45) rend.AddViewProp(glyph_actor) #rend.AddActor(glyph_actor) geom_actor = vtk.vtkActor() geom_actor.SetMapper(grid_mapper) # ------------------------------------------------------------ # Create the RenderWindow, Renderer and Interactor # ------------------------------------------------------------ renWin = vtk.vtkRenderWindow() iren = vtk.vtkRenderWindowInteractor() renWin.AddRenderer(rend) iren.SetRenderWindow(renWin) # add actors #rend.AddViewProp(geom_actor) #rend.AddViewProp(edgeActor) rend.AddActor(geom_actor) #rend.AddViewProp(glyph_actor) #rend.AddActor2D(scalarBar) rend.SetBackground(0.7, 0.8, 1.0) renWin.SetSize(800, 800) renWin.Render() iren.Start()
def main(): colors = vtk.vtkNamedColors() # Verify input arguments fn = get_program_parameters() if fn: # Read the image jpeg_reader = vtk.vtkJPEGReader() if not jpeg_reader.CanReadFile(fn): print('Error reading file:', fn) return jpeg_reader.SetFileName(fn) jpeg_reader.Update() image_data = jpeg_reader.GetOutput() else: canvas_source = vtk.vtkImageCanvasSource2D() canvas_source.SetExtent(0, 100, 0, 100, 0, 0) canvas_source.SetScalarTypeToUnsignedChar() canvas_source.SetNumberOfScalarComponents(3) canvas_source.SetDrawColor(colors.GetColor4ub('warm_grey')) canvas_source.FillBox(0, 100, 0, 100) canvas_source.SetDrawColor(colors.GetColor4ub('DarkCyan')) canvas_source.FillTriangle(10, 10, 25, 10, 25, 25) canvas_source.SetDrawColor(colors.GetColor4ub('LightCoral')) canvas_source.FillTube(75, 75, 0, 75, 5.0) canvas_source.Update() image_data = canvas_source.GetOutput() # Create an image actor to display the image image_actor = vtk.vtkImageActor() image_actor.SetInputData(image_data) # Create a renderer to display the image in the background background_renderer = vtk.vtkRenderer() # Create a superquadric superquadric_source = vtk.vtkSuperquadricSource() superquadric_source.SetPhiRoundness(1.1) superquadric_source.SetThetaRoundness(.2) # Create a mapper and actor superquadric_mapper = vtk.vtkPolyDataMapper() superquadric_mapper.SetInputConnection(superquadric_source.GetOutputPort()) superquadric_actor = vtk.vtkActor() superquadric_actor.SetMapper(superquadric_mapper) superquadric_actor.GetProperty().SetColor(colors.GetColor3d('NavajoWhite')) scene_renderer = vtk.vtkRenderer() render_window = vtk.vtkRenderWindow() # Set up the render window and renderers such that there is # a background layer and a foreground layer background_renderer.SetLayer(0) background_renderer.InteractiveOff() scene_renderer.SetLayer(1) render_window.SetNumberOfLayers(2) render_window.AddRenderer(background_renderer) render_window.AddRenderer(scene_renderer) render_window.SetWindowName('BackgroundImage') render_window_interactor = vtk.vtkRenderWindowInteractor() render_window_interactor.SetRenderWindow(render_window) # Add actors to the renderers scene_renderer.AddActor(superquadric_actor) background_renderer.AddActor(image_actor) # Render once to figure out where the background camera will be render_window.Render() # Set up the background camera to fill the renderer with the image origin = image_data.GetOrigin() spacing = image_data.GetSpacing() extent = image_data.GetExtent() camera = background_renderer.GetActiveCamera() camera.ParallelProjectionOn() xc = origin[0] + 0.5 * (extent[0] + extent[1]) * spacing[0] yc = origin[1] + 0.5 * (extent[2] + extent[3]) * spacing[1] # xd = (extent[1] - extent[0] + 1) * spacing[0] yd = (extent[3] - extent[2] + 1) * spacing[1] d = camera.GetDistance() camera.SetParallelScale(0.5 * yd) camera.SetFocalPoint(xc, yc, 0.0) camera.SetPosition(xc, yc, d) # Render again to set the correct view render_window.Render() # Interact with the window render_window_interactor.Start()
def main(): # x = array of 8 3-tuples of float representing the vertices of a cube: x = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (1.0, 1.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0), (1.0, 0.0, 1.0), (1.0, 1.0, 1.0), (0.0, 1.0, 1.0)] # pts = array of 6 4-tuples of vtkIdType (int) representing the faces # of the cube in terms of the above vertices pts = [(0, 1, 2, 3), (4, 5, 6, 7), (0, 1, 5, 4), (1, 2, 6, 5), (2, 3, 7, 6), (3, 0, 4, 7)] # We'll create the building blocks of polydata including data attributes. cube = vtk.vtkPolyData() points = vtk.vtkPoints() polys = vtk.vtkCellArray() scalars = vtk.vtkFloatArray() # Load the point, cell, and data attributes. for i in range(8): points.InsertPoint(i, x[i]) for i in range(6): polys.InsertNextCell(mkVtkIdList(pts[i])) for i in range(8): scalars.InsertTuple1(i, i) # We now assign the pieces to the vtkPolyData. cube.SetPoints(points) del points cube.SetPolys(polys) del polys cube.GetPointData().SetScalars(scalars) del scalars # Now we'll look at it. cubeMapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: cubeMapper.SetInput(cube) else: cubeMapper.SetInputData(cube) cubeMapper.SetScalarRange(0, 7) cubeActor = vtk.vtkActor() cubeActor.SetMapper(cubeMapper) # The usual rendering stuff. camera = vtk.vtkCamera() camera.SetPosition(1, 1, 1) camera.SetFocalPoint(0, 0, 0) renderer = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(renderer) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) renderer.AddActor(cubeActor) renderer.SetActiveCamera(camera) renderer.ResetCamera() renderer.SetBackground(1, 1, 1) renWin.SetSize(300, 300) # interact with data renWin.Render() iren.Start() # Clean up del cube del cubeMapper del cubeActor del camera del renderer del renWin del iren
def Main(): global isovalues, contours, planeSource1, planeSource2, planeSource3, plane1, plane2, plane3, clipper1, clipper2, clipper3, clipX, clipY, clipZ, lut, renWin print "data: %s" % sys.argv[1] reader = vtk.vtkStructuredPointsReader() reader.SetFileName(sys.argv[1]) reader.Update() print "gradientmag: %s" % sys.argv[2] gmreader = vtk.vtkStructuredPointsReader() gmreader.SetFileName(sys.argv[2]) gmreader.Update() clipX = 0 clipY = 0 clipZ = 0 r = reader.GetOutput().GetScalarRange() datamin = r[0] datamax = r[1] print "isoval: %s" % sys.argv[3] isovalues = loadIsovalueFile(sys.argv[3]) lut = vtk.vtkColorTransferFunction() lut.SetColorSpaceToHSV() lut.AddHSVPoint(0,0,1,1) for i in range(4, len(sys.argv)): if sys.argv[i] == "--cmap": print "colors file: %s" % sys.argv[i+1] loadContinuousFile(sys.argv[i+1]) updateUI(0) if sys.argv[i] == "--clip": print "clip (%s,%s,%s)" % (sys.argv[i+1],sys.argv[i+2],sys.argv[i+3]) clipX = float(sys.argv[i+1]) clipY = float(sys.argv[i+2]) clipZ = float(sys.argv[i+3]) contours = vtk.vtkContourFilter() contours.SetInputConnection(reader.GetOutputPort()); contours.ComputeNormalsOn() for i in range(0, len(isovalues)): contours.SetValue(i, isovalues[i]) planeSource1 = vtk.vtkPlaneSource() planeSource1.SetNormal(1,0,0) planeSource1.SetOrigin(clipX,0,0) planeSource2 = vtk.vtkPlaneSource() planeSource2.SetNormal(0,1,0) planeSource2.SetOrigin(0,clipY,0) planeSource3 = vtk.vtkPlaneSource() planeSource3.SetNormal(0,0,1) planeSource3.SetOrigin(0,0,clipZ) plane1 = vtk.vtkPlane() plane1.SetNormal(planeSource1.GetNormal()) plane1.SetOrigin(planeSource1.GetOrigin()) clipper1 = vtk.vtkClipPolyData() clipper1.SetClipFunction(plane1) clipper1.SetInputConnection(contours.GetOutputPort()) clipper1.Update() plane2 = vtk.vtkPlane() plane2.SetNormal(planeSource2.GetNormal()) plane2.SetOrigin(planeSource2.GetOrigin()) clipper2 = vtk.vtkClipPolyData() clipper2.SetClipFunction(plane2) clipper2.SetInputConnection(clipper1.GetOutputPort()) clipper2.Update() plane3 = vtk.vtkPlane() plane3.SetNormal(planeSource3.GetNormal()) plane3.SetOrigin(planeSource3.GetOrigin()) clipper3 = vtk.vtkClipPolyData() clipper3.SetClipFunction(plane3) clipper3.SetInputConnection(clipper2.GetOutputPort()) clipper3.Update() probeFilter = vtk.vtkProbeFilter() probeFilter.SetInputConnection(0, clipper3.GetOutputPort()) probeFilter.SetInputConnection(1, gmreader.GetOutputPort()) probeFilter.Update() clipperMapper = vtk.vtkPolyDataMapper() clipperMapper.SetLookupTable(lut) clipperMapper.SetInputConnection(probeFilter.GetOutputPort()) clipperMapper.SetScalarRange(probeFilter.GetOutput().GetScalarRange()) colorBar = vtkScalarBarActor() colorBar.SetLookupTable(clipperMapper.GetLookupTable()) colorBar.SetTitle("gradient magnitude") colorBar.SetNumberOfLabels(6) colorBar.SetLabelFormat("%4.0f") colorBar.SetPosition(0.9, 0.1) colorBar.SetWidth(0.1) colorBar.SetHeight(0.7) clipperActor=vtk.vtkActor() clipperActor.GetProperty().SetRepresentationToWireframe() clipperActor.SetMapper(clipperMapper) backFaces = vtk.vtkProperty() backFaces.SetSpecular(0) backFaces.SetDiffuse(0) backFaces.SetAmbient(0) backFaces.SetAmbientColor(1,0,0) clipperActor.SetBackfaceProperty(backFaces) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.AddActor(clipperActor) ren.AddActor(colorBar) ren.ResetCamera() ren.SetBackground(0.2,0.3,0.4) ren.ResetCameraClippingRange() renWin.SetSize(1200, 600) clipXSlider = vtk.vtkSliderRepresentation2D() clipXSlider.SetMinimumValue(0) clipXSlider.SetMaximumValue(300) clipXSlider.SetValue(clipX) clipXSlider.SetTitleText("X") clipXSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay() clipXSlider.GetPoint1Coordinate().SetValue(0.0, 0.3) clipXSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay() clipXSlider.GetPoint2Coordinate().SetValue(0.2, 0.3) clipXSlider.SetSliderLength(0.02) clipXSlider.SetSliderWidth(0.03) clipXSlider.SetEndCapLength(0.01) clipXSlider.SetEndCapWidth(0.03) clipXSlider.SetTubeWidth(0.005) clipXSlider.SetLabelFormat("%1.2lf") clipXSlider.SetTitleHeight(0.02) clipXSlider.SetLabelHeight(0.02) SliderWidget2 = vtk.vtkSliderWidget() SliderWidget2.SetInteractor(iren) SliderWidget2.SetRepresentation(clipXSlider) SliderWidget2.KeyPressActivationOff() SliderWidget2.SetAnimationModeToAnimate() SliderWidget2.SetEnabled(True) SliderWidget2.AddObserver("InteractionEvent", clipXSliderHandler) clipYSlider = vtk.vtkSliderRepresentation2D() clipYSlider.SetMinimumValue(0) clipYSlider.SetMaximumValue(300) clipYSlider.SetValue(clipY) clipYSlider.SetTitleText("Y") clipYSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay() clipYSlider.GetPoint1Coordinate().SetValue(0.0, 0.2) clipYSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay() clipYSlider.GetPoint2Coordinate().SetValue(0.2, 0.2) clipYSlider.SetSliderLength(0.02) clipYSlider.SetSliderWidth(0.03) clipYSlider.SetEndCapLength(0.01) clipYSlider.SetEndCapWidth(0.03) clipYSlider.SetTubeWidth(0.005) clipYSlider.SetLabelFormat("%1.2lf") clipYSlider.SetTitleHeight(0.02) clipYSlider.SetLabelHeight(0.02) SliderWidget3 = vtk.vtkSliderWidget() SliderWidget3.SetInteractor(iren) SliderWidget3.SetRepresentation(clipYSlider) SliderWidget3.KeyPressActivationOff() SliderWidget3.SetAnimationModeToAnimate() SliderWidget3.SetEnabled(True) SliderWidget3.AddObserver("InteractionEvent", clipYSliderHandler) clipZSlider = vtk.vtkSliderRepresentation2D() clipZSlider.SetMinimumValue(0) clipZSlider.SetMaximumValue(300) clipZSlider.SetValue(clipZ) clipZSlider.SetTitleText("Z") clipZSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay() clipZSlider.GetPoint1Coordinate().SetValue(0.0, 0.1) clipZSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay() clipZSlider.GetPoint2Coordinate().SetValue(0.2, 0.1) clipZSlider.SetSliderLength(0.02) clipZSlider.SetSliderWidth(0.03) clipZSlider.SetEndCapLength(0.01) clipZSlider.SetEndCapWidth(0.03) clipZSlider.SetTubeWidth(0.005) clipZSlider.SetLabelFormat("%1.2lf") clipZSlider.SetTitleHeight(0.02) clipZSlider.SetLabelHeight(0.02) SliderWidget4 = vtk.vtkSliderWidget() SliderWidget4.SetInteractor(iren) SliderWidget4.SetRepresentation(clipZSlider) SliderWidget4.KeyPressActivationOff() SliderWidget4.SetAnimationModeToAnimate() SliderWidget4.SetEnabled(True) SliderWidget4.AddObserver("InteractionEvent", clipZSliderHandler) # Render iren.Initialize() renWin.Render() iren.Start()
def main(): red_ball = 0 blue_ball = 0 white_ball = 0 balls_coordinates = [] balls_coordinates_and_color = [] sphereSource = [] actor = [] mapper = [] balls_numbers = random.randint(3, 20) # Read STL reader1 = vtk.vtkSTLReader() reader1.SetFileName("golf_robot.stl") # Create a mapper and actor mapper111 = vtk.vtkPolyDataMapper() mapper111.SetInputConnection(reader1.GetOutputPort()) actor111 = vtk.vtkActor() actor111.SetMapper(mapper111) prop = actor111.GetProperty() for a in range(balls_numbers): b = "sphereSource" + str(a) sphereSource.append(b) c = "actor" + str(a) actor.append(c) d = "mapper" + str(a) mapper.append(d) balls_coordinates_x = random.randint(1, 10) * 20 balls_coordinates_y = random.randint(1, 10) * 20 balls_color = random.randint(1, 3) if balls_color == 1: red_ball = red_ball + 1 elif balls_color == 2: blue_ball = blue_ball + 1 elif balls_color == 3: white_ball = white_ball + 1 balls = [balls_coordinates_x, balls_coordinates_y, 0] balls_and_color = [ balls_coordinates_x, balls_coordinates_y, 0, balls_color ] balls_coordinates.append(balls) balls_coordinates_and_color.append(balls_and_color) print('balls =', balls_numbers, 'red balls =', red_ball, 'blue balls =', blue_ball, 'white balls =', white_ball) print(balls_coordinates_and_color) for i in range(balls_numbers): sphereSource[i] = vtk.vtkSphereSource() sphereSource[i].SetCenter(balls_coordinates[i][0:3]) sphereSource[i].SetRadius(10) sphereSource[i].SetThetaResolution(64) sphereSource[i].SetPhiResolution(64) # Create a mapper and actor mapper[i] = vtk.vtkPolyDataMapper() mapper[i].SetInputConnection(sphereSource[i].GetOutputPort()) actor[i] = vtk.vtkActor() actor[i].SetMapper(mapper[i]) if balls_coordinates_and_color[i][3] == 1: prop = actor[i].GetProperty().SetColor(1, 0, 0) #红 elif balls_coordinates_and_color[i][3] == 2: prop = actor[i].GetProperty().SetColor(0, 0, 1) #蓝 elif balls_coordinates_and_color[i][3] == 3: prop = actor[i].GetProperty() #白 # Setup a renderer, render window, and interactor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Add the actor to the scene for a in range(balls_numbers): # Add the actor to the scene renderer.AddActor(actor[a]) renderer.AddActor(actor111) renderer.SetBackground(0, 1, 0) # Background color white actor111.SetOrigin(0, 0, 0) # Render and interact renderWindow.Render() # Initialize must be called prior to creating timer events. renderWindowInteractor.Initialize() # Sign up to receive TimerEvent cb = vtkTimerCallback1() cb.actors.append(actor111) cb.actors.append(balls_numbers) for i in range(balls_numbers): cb.balls.append(balls_coordinates_and_color[i]) cb.mballs.append(actor[i]) renderWindowInteractor.AddObserver('TimerEvent', cb.execute) timerId = renderWindowInteractor.CreateRepeatingTimer(100) # start the interaction and timer renderWindowInteractor.Start()
def main(): colors = vtk.vtkNamedColors() fileName = get_program_parameters() # Create a rendering window, renderer and interactor. ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetSize(780, 780) renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Make an annotated cube actor with axes and then add it into an orientation marker widget. # Three of these need to be made. # Right Posterior Superior xyzLabels = ['X', 'Y', 'Z'] scale = [1.5, -1.5, 1.5] axes = MakeCubeActor(scale, xyzLabels, colors) om = vtk.vtkOrientationMarkerWidget() om.SetOrientationMarker(axes) # Position upper left in the viewport. om.SetViewport(0.0, 0.8, 0.2, 1.0) om.SetInteractor(iren) om.EnabledOn() om.InteractiveOn() # Right, Anterior, Superior. scale = [1.5, 1.5, 1.5] axes1 = MakeCubeActor(scale, xyzLabels, colors) om1 = vtk.vtkOrientationMarkerWidget() om1.SetOrientationMarker(axes1) # Position lower left in the viewport. om1.SetViewport(0, 0, 0.2, 0.2) om1.SetInteractor(iren) om1.EnabledOn() om1.InteractiveOn() # Left, Posterior, Superior. scale = (-1.5, -1.5, 1.5) axes2 = MakeCubeActor(scale, xyzLabels, colors) om2 = vtk.vtkOrientationMarkerWidget() om2.SetOrientationMarker(axes2) # Position lower right in the viewport. om2.SetViewport(0.8, 0, 1.0, 0.2) om2.SetInteractor(iren) om2.EnabledOn() om2.InteractiveOn() # Finally create an annotated cube actor adding it into an orientation marker widget. axes3 = MakeAnnotatedCubeActor(colors) om3 = vtk.vtkOrientationMarkerWidget() om3.SetOrientationMarker(axes3) # Position upper right in the viewport. om3.SetViewport(0.8, 0.8, 1.0, 1.0) om3.SetInteractor(iren) om3.EnabledOn() om3.InteractiveOn() # Read in the model. reader = vtk.vtkXMLPolyDataReader() reader.SetFileName(fileName) reader.Update() humanMapper = vtk.vtkPolyDataMapper() humanMapper.SetInputConnection(reader.GetOutputPort()) humanMapper.SetScalarModeToUsePointFieldData() humanMapper.SelectColorArray("Color") humanMapper.SetColorModeToDirectScalars() humanActor = vtk.vtkActor() humanActor.SetMapper(humanMapper) bounds = humanActor.GetBounds() # Scale the actor humanActor.SetScale(1.0 / max(bounds)) ren.AddActor(humanActor) # Make the planes. actors = MakePlanesActors(colors) for actor in actors: ren.AddViewProp(actor) # Label them. textActors = AddTextToPlanes() for actor in textActors: ren.AddViewProp(actor) # Interact ren.SetBackground2(colors.GetColor3d('OldLace')) ren.SetBackground(colors.GetColor3d('MistyRose')) ren.GradientBackgroundOn() ren.ResetCamera() ren.GetActiveCamera().Zoom(1.6) ren.GetActiveCamera().SetPosition(-2.3, 4.1, 4.2) # ren.GetActiveCamera().SetPosition(-3.4, 5.5, 0.0) ren.GetActiveCamera().SetViewUp(0.0, 0.0, 1.0) ren.ResetCameraClippingRange() renWin.Render() # Call SetWindowName after renWin.Render() is called. renWin.SetWindowName("Anatomical Orientation") iren.Initialize() iren.Start()
def DisplayCone(nc): ''' Create a cone, contour it using the banded contour filter and color it with the primary additive and subtractive colors. :param: nc: The vtkNamedColor class :return: The render window interactor. ''' # Create a cone coneSource = vtk.vtkConeSource() coneSource.SetCenter(0.0, 0.0, 0.0) coneSource.SetRadius(5.0) coneSource.SetHeight(10) coneSource.SetDirection(0,1,0) coneSource.Update() bounds = [1.0,-1.0,1.0,-1.0,1.0,-1.0] coneSource.GetOutput().GetBounds(bounds) elevation = vtk.vtkElevationFilter() elevation.SetInputConnection(coneSource.GetOutputPort()) elevation.SetLowPoint(0,bounds[2],0) elevation.SetHighPoint(0,bounds[3],0) bcf = vtk.vtkBandedPolyDataContourFilter() bcf.SetInputConnection(elevation.GetOutputPort()) bcf.SetScalarModeToValue() bcf.GenerateContourEdgesOn() bcf.GenerateValues(7,elevation.GetScalarRange()) # Build a simple lookup table of # primary additive and subtractive colors. lut = vtk.vtkLookupTable() lut.SetNumberOfTableValues(7) # Test setting and getting a color here. # We are also modifying alpha. # Convert to a list so that # SetColor(name,rgba) works. rgba = list(nc.GetColor4d("Red")) rgba[3] = 0.5 nc.SetColor("My Red",rgba) rgba = nc.GetColor4d("My Red") lut.SetTableValue(0,rgba) # Does "My Red" match anything? match = FindSynonyms(nc,"My Red") print "Matching colors to My Red:", match rgba = nc.GetColor4d("DarkGreen") rgba[3] = 0.3 lut.SetTableValue(1,rgba) # Alternatively we can use our wrapper functions: lut.SetTableValue(2,nc.GetColor4d("Blue")) lut.SetTableValue(3,nc.GetColor4d("Cyan")) lut.SetTableValue(4,nc.GetColor4d("Magenta")) lut.SetTableValue(5,nc.GetColor4d("Yellow")) lut.SetTableValue(6,nc.GetColor4d("White")) lut.SetTableRange(elevation.GetScalarRange()) lut.Build() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(bcf.GetOutputPort()) mapper.SetLookupTable(lut) mapper.SetScalarModeToUseCellData() contourLineMapper = vtk.vtkPolyDataMapper() contourLineMapper.SetInputData(bcf.GetContourEdgesOutput()) contourLineMapper.SetScalarRange(elevation.GetScalarRange()) contourLineMapper.SetResolveCoincidentTopologyToPolygonOffset() actor = vtk.vtkActor() actor.SetMapper(mapper) contourLineActor = vtk.vtkActor() actor.SetMapper(mapper) contourLineActor.SetMapper(contourLineMapper) contourLineActor.GetProperty().SetColor( nc.GetColor3d("black")) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(actor) renderer.AddActor(contourLineActor) renderer.SetBackground( nc.GetColor3d("SteelBlue")) renderWindow.Render() fnsave = "TestNamedColorsIntegration.png" renLgeIm = vtk.vtkRenderLargeImage() imgWriter = vtk.vtkPNGWriter() renLgeIm.SetInput(renderer) renLgeIm.SetMagnification(1) imgWriter.SetInputConnection(renLgeIm.GetOutputPort()) imgWriter.SetFileName(fnsave) imgWriter.Write() return renderWindowInteractor
def CurvaturesDemo(self): # 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() ctf.AddRGBPoint(0.0, 0.230, 0.299, 0.754) ctf.AddRGBPoint(1.0, 0.706, 0.016, 0.150) 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(10) textProperty.SetJustificationToCentered() names = [ 'Torus - Gaussian Curvature', 'Torus - Mean Curvature', 'Gaussian Curvature', '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(150, 16) renderers.append(vtk.vtkRenderer()) gridDimensions = 2 for idx in range(len(sources)): if idx < gridDimensions * gridDimensions: renderers.append(vtk.vtkRenderer) rendererSize = 300 # 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(sources) - 1): continue renderers[idx].SetViewport(viewport) renderWindow.AddRenderer(renderers[idx]) renderers[idx].AddActor(actors[idx]) renderers[idx].AddActor(textactors[idx]) renderers[idx].SetBackground(0.4, 0.3, 0.2) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
def main(): # Setting Paths cam = 2 # dataset_dir = '/media/bradenhurl/hd/gta/object/' data_set = 'training' dataset_dir = os.path.expanduser('~') + '/wavedata-dev/demos/gta' #dataset_dir = os.path.expanduser('~') + '/Kitti/object/' dataset_dir = os.path.expanduser( '~') + '/GTAData/TruPercept/object_tru_percept8/' #Set to true to see predictions (results) from all perspectives use_results = True altPerspective = False perspID = 48133 perspStr = '%07d' % perspID altPerspect_dir = os.path.join(dataset_dir, data_set + '/alt_perspective/') if altPerspective: data_set = data_set + '/alt_perspective/' + perspStr fromWiseWindows = False useEVE = False if fromWiseWindows: data_set = 'object' if useEVE: dataset_dir = '/media/bradenhurl/hd/data/eve/' else: dataset_dir = '/media/bradenhurl/hd/data/' image_dir = os.path.join(dataset_dir, data_set) + '/image_2' velo_dir = os.path.join(dataset_dir, data_set) + '/velodyne' calib_dir = os.path.join(dataset_dir, data_set) + '/calib' if use_results: label_dir = os.path.join(dataset_dir, data_set) + '/predictions' else: label_dir = os.path.join(dataset_dir, data_set) + '/label_2' base_dir = os.path.join(dataset_dir, data_set) comparePCs = False if comparePCs: velo_dir2 = os.path.join(dataset_dir, data_set) + '/velodyne' tracking = False if tracking: seq_idx = 1 data_set = '%04d' % seq_idx dataset_dir = '/media/bradenhurl/hd/GTAData/August-01/tracking' image_dir = os.path.join(dataset_dir, 'images', data_set) label_dir = os.path.join(dataset_dir, 'labels', data_set) velo_dir = os.path.join(dataset_dir, 'velodyne', data_set) calib_dir = os.path.join(dataset_dir, 'training', 'calib', '0000') #Used for visualizing inferences #label_dir = '/media/bradenhurl/hd/avod/avod/data/outputs/pyramid_people_gta_40k' #label_dir = label_dir + '/predictions/kitti_predictions_3d/test/0.02/154000/data/' closeView = False pitch = 170 pointSize = 3 zoom = 1 if closeView: pitch = 180.5 pointSize = 3 zoom = 35 image_list = os.listdir(image_dir) fulcrum_of_points = True use_intensity = False img_idx = 2 print('=== Loading image: {:06d}.png ==='.format(img_idx)) print(image_dir) image = cv2.imread(image_dir + '/{:06d}.png'.format(img_idx)) image_shape = (image.shape[1], image.shape[0]) if use_intensity: point_cloud, intensity = obj_utils.get_lidar_point_cloud( img_idx, calib_dir, velo_dir, ret_i=use_intensity) else: point_cloud = obj_utils.get_lidar_point_cloud(img_idx, calib_dir, velo_dir, im_size=image_shape) if comparePCs: point_cloud2 = obj_utils.get_lidar_point_cloud(img_idx, calib_dir, velo_dir2, im_size=image_shape) point_cloud = np.hstack((point_cloud, point_cloud2)) # Reshape points into N x [x, y, z] all_points = np.array(point_cloud).transpose().reshape((-1, 3)) # Define Fixed Sizes for the voxel grid x_min = -85 x_max = 85 y_min = -5 y_max = 5 z_min = 3 z_max = 85 x_min = min(point_cloud[0]) x_max = max(point_cloud[0]) y_min = min(point_cloud[1]) y_max = max(point_cloud[1]) #z_min = min(point_cloud[2]) z_max = max(point_cloud[2]) # Filter points within certain xyz range area_filter = (point_cloud[0] > x_min) & (point_cloud[0] < x_max) & \ (point_cloud[1] > y_min) & (point_cloud[1] < y_max) & \ (point_cloud[2] > z_min) & (point_cloud[2] < z_max) all_points = all_points[area_filter] #point_colours = np.zeros(point_cloud.shape[1],0) #print(point_colours.shape) if fulcrum_of_points: # Get point colours point_colours = vis_utils.project_img_to_point_cloud( all_points, image, calib_dir, img_idx) print("Point colours shape: ", point_colours.shape) print("Sample 0 of colour: ", point_colours[0]) elif use_intensity: adjusted = intensity == 65535 intensity = intensity > 0 intensity = np.expand_dims(intensity, -1) point_colours = np.hstack( (intensity * 255, intensity * 255 - adjusted * 255, intensity * 255 - adjusted * 255)) print("Intensity shape:", point_colours.shape) print("Intensity sample: ", point_colours[0]) # Create Voxel Grid voxel_grid = VoxelGrid() voxel_grid_extents = [[x_min, x_max], [y_min, y_max], [z_min, z_max]] print(voxel_grid_extents) start_time = time.time() voxel_grid.voxelize(all_points, 0.2, voxel_grid_extents) end_time = time.time() print("Voxelized in {} s".format(end_time - start_time)) # Get bounding boxes gt_detections = obj_utils.read_labels(label_dir, img_idx, results=use_results) if gt_detections is None: gt_detections = [] #perspective_utils.to_world(gt_detections, base_dir, img_idx) #perspective_utils.to_perspective(gt_detections, base_dir, img_idx) for entity_str in os.listdir(altPerspect_dir): if os.path.isdir(os.path.join(altPerspect_dir, entity_str)): perspect_detections = perspective_utils.get_detections( base_dir, altPerspect_dir, img_idx, perspID, entity_str, results=use_results) if perspect_detections != None: if use_results: stripped_detections = trust_utils.strip_objs( perspect_detections) gt_detections = gt_detections + stripped_detections else: gt_detections = gt_detections + perspect_detections # Create VtkPointCloud for visualization vtk_point_cloud = VtkPointCloud() if fulcrum_of_points or use_intensity: vtk_point_cloud.set_points(all_points, point_colours) else: vtk_point_cloud.set_points(all_points) vtk_point_cloud.vtk_actor.GetProperty().SetPointSize(pointSize) # Create VtkVoxelGrid for visualization vtk_voxel_grid = VtkVoxelGrid() vtk_voxel_grid.set_voxels(voxel_grid) COLOUR_SCHEME_PAPER = { "Car": (0, 0, 255), # Blue "Pedestrian": (255, 0, 0), # Red "Bus": (0, 0, 255), #Blue "Cyclist": (150, 50, 100), # Purple "Van": (255, 150, 150), # Peach "Person_sitting": (150, 200, 255), # Sky Blue "Truck": (0, 0, 255), # Light Grey "Tram": (150, 150, 150), # Grey "Misc": (100, 100, 100), # Dark Grey "DontCare": (255, 255, 255), # White } # Create VtkBoxes for boxes vtk_boxes = VtkBoxes() vtk_boxes.set_objects(gt_detections, COLOUR_SCHEME_PAPER) #vtk_boxes.COLOUR_SCHEME_KITTI) # Create Axes axes = vtk.vtkAxesActor() axes.SetTotalLength(5, 5, 5) # Create Voxel Grid Renderer in bottom half vtk_renderer = vtk.vtkRenderer() vtk_renderer.AddActor(vtk_point_cloud.vtk_actor) vtk_renderer.AddActor(vtk_voxel_grid.vtk_actor) vtk_renderer.AddActor(vtk_boxes.vtk_actor) #vtk_renderer.AddActor(axes) vtk_renderer.SetBackground(0.2, 0.3, 0.4) # Setup Camera current_cam = vtk_renderer.GetActiveCamera() current_cam.Pitch(pitch) current_cam.Roll(180.0) # Zooms out to fit all points on screen vtk_renderer.ResetCamera() # Zoom in slightly current_cam.Zoom(zoom) # Reset the clipping range to show all points vtk_renderer.ResetCameraClippingRange() # Setup Render Window vtk_render_window = vtk.vtkRenderWindow() vtk_render_window.SetWindowName( "Point Cloud and Voxel Grid, Image {}".format(img_idx)) vtk_render_window.SetSize(1920, 1080) vtk_render_window.AddRenderer(vtk_renderer) # Setup custom interactor style, which handles mouse and key events vtk_render_window_interactor = vtk.vtkRenderWindowInteractor() vtk_render_window_interactor.SetRenderWindow(vtk_render_window) # Add custom interactor to toggle actor visibilities vtk_render_window_interactor.SetInteractorStyle( vis_utils.ToggleActorsInteractorStyle([ vtk_point_cloud.vtk_actor, vtk_voxel_grid.vtk_actor, vtk_boxes.vtk_actor, ])) # Show image image = cv2.imread(image_dir + "/%06d.png" % img_idx) cv2.imshow("Press any key to continue", image) cv2.waitKey() # Render in VTK vtk_render_window.Render() vtk_render_window_interactor.Start() # Blocking
def main(): inputFilename = 'element_labels_input.vtk' # read file reader = vtk.vtkUnstructuredGridReader() reader.SetFileName(inputFilename) reader.ReadAllScalarsOn() reader.SetScalarsName(reader.GetScalarsNameInFile(0)) reader.Update() ncells = reader.GetOutput().GetNumberOfCells() npoints = reader.GetOutput().GetNumberOfPoints() # get attributes ugrid = reader.GetOutput() cell_data = ugrid.GetCellData() point_data = ugrid.GetPointData() cell_scalars = cell_data.GetScalars(reader.GetScalarsNameInFile(0)) # validate that attributes are read correctly print('name0:') for i in range(ncells): print(i, ": ", cell_scalars.GetComponent(i, 0)) cell_scalars = cell_data.GetScalars(reader.GetScalarsNameInFile(1)) print('\nname1:') for i in range(ncells): print(i, ": ", cell_scalars.GetComponent(i, 0)) point_scalars = point_data.GetScalars(reader.GetScalarsNameInFile(0)) print(point_scalars) print('\nname2:') for i in range(npoints): print(i, ": ", point_scalars.GetComponent(i, 0)) #point_scalars = cell_data.GetScalars(reader.GetScalarsNameInFile(2)) #print(point_scalars) # geometry filter geometry_filter = vtk.vtkUnstructuredGridGeometryFilter() geometry_filter.SetInputConnection(reader.GetOutputPort()) geometry_filter.Update() # Generate data arrays containing point and cell ids ids = vtk.vtkIdFilter() ids.SetInputConnection(geometry_filter.GetOutputPort()) ids.PointIdsOff() ids.CellIdsOff() ids.FieldDataOn() # Create labels for cells cell_centers = vtk.vtkCellCenters() cell_centers.SetInputConnection(ids.GetOutputPort()) node_points = vtk.vtkVertexGlyphFilter() node_points.SetInputConnection(ids.GetOutputPort()) node_points.Update() #node_points = vtk.vtkPointCentered() #node_points.SetInputConnection(ids.GetOutputPort()) # lut lut = vtk.vtkLookupTable() lut.SetNumberOfTableValues(ncells) lut.Build() lut.SetTableValue(0, 1, 0, 0, 1) # red. lut.SetTableValue(1, 0, 1, 0, 1) # green. lut.SetTableValue(2, 0, 0, 1, 1) # blue. # mapper mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(geometry_filter.GetOutputPort()) mapper.SetScalarVisibility(1) if apply_colors: mapper.SetLookupTable(lut) mapper.SetScalarModeToUseCellData() mapper.SetScalarRange(11, 13) mapper.GetInput().GetCellData().SetActiveScalars("cell_tag") # label mapper cell_label_mapper = vtk.vtkLabeledDataMapper() cell_label_mapper.SetInputConnection(cell_centers.GetOutputPort()) cell_label_mapper.SetLabelModeToLabelScalars() #point_label_mapper = vtk.vtkLabeledDataMapper() #point_label_mapper.SetInputConnection(node_points.GetOutputPort()) #point_label_mapper.SetLabelModeToLabelScalars() # actor actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetRepresentationToWireframe() # label actor cell_label_actor = vtk.vtkActor2D() cell_label_actor.SetMapper(cell_label_mapper) #point_label_actor = vtk.vtkActor2D() #point_label_actor.SetMapper(point_label_mapper) # renderer renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(actor) renderer.AddActor(cell_label_actor) #renderer.AddActor(point_label_actor) renderWindow.Render() renderWindowInteractor.Start()
def main(): xyzFn, qFn = get_program_parameters() colors = vtk.vtkNamedColors() pl3d = vtk.vtkMultiBlockPLOT3DReader() pl3d.SetXYZFileName(xyzFn) pl3d.SetQFileName(qFn) pl3d.SetScalarFunctionNumber(100) pl3d.SetVectorFunctionNumber(202) pl3d.Update() pl3dOutput = pl3d.GetOutput().GetBlock(0) plane = vtk.vtkStructuredGridGeometryFilter() plane.SetInputData(pl3dOutput) plane.SetExtent(1, 100, 1, 100, 7, 7) lut = vtk.vtkLookupTable() planeMapper = vtk.vtkPolyDataMapper() planeMapper.SetLookupTable(lut) planeMapper.SetInputConnection(plane.GetOutputPort()) planeMapper.SetScalarRange(pl3dOutput.GetScalarRange()) planeActor = vtk.vtkActor() planeActor.SetMapper(planeMapper) # This creates an outline around the data. outline = vtk.vtkStructuredGridOutlineFilter() outline.SetInputData(pl3dOutput) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) # Much of the following is commented out. To try different lookup tables, # uncomment the appropriate portions. # # This creates a black to white lut. # lut.SetHueRange(0, 0) # lut.SetSaturationRange(0, 0) # lut.SetValueRange(0.2, 1.0) # This creates a red to blue lut. # lut.SetHueRange(0.0, 0.667) # This creates a blue to red lut. # lut.SetHueRange(0.667, 0.0) # This creates a weird effect. The Build() method causes the lookup table # to allocate memory and create a table based on the correct hue, saturation, # value, and alpha (transparency) range. Here we then manually overwrite the # values generated by the Build() method. lut.SetNumberOfColors(256) lut.SetHueRange(0.0, 0.667) lut.Build() # Create the RenderWindow, Renderer and both Actors. # 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) ren1.AddActor(planeActor) ren1.SetBackground(colors.GetColor3d("SlateGray")) ren1.TwoSidedLightingOff() renWin.SetSize(512, 512) iren.Initialize() cam1 = ren1.GetActiveCamera() cam1.SetClippingRange(3.95297, 50) cam1.SetFocalPoint(8.88908, 0.595038, 29.3342) cam1.SetPosition(-12.3332, 31.7479, 41.2387) cam1.SetViewUp(0.060772, -0.319905, 0.945498) iren.Start()
renderer0 = vtk.vtkRenderer() renderer0.SetViewport(0., 0., 0.5, 1.) renderer1 = vtk.vtkRenderer() renderer1.SetViewport(0.5, 0., 1., 1.) mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(CreateCross(20.0)) global _Cross _Cross = vtk.vtkActor() _Cross.GetProperty().SetLineWidth(5) _Cross.SetPosition(0.0, 50.006, 0.0) _Cross.SetMapper(mapper) global renderWindow renderWindow = vtk.vtkRenderWindow() renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) camera = vtk.vtkCamera() renderWindow.AddRenderer(renderer1) renderWindow.AddRenderer(renderer0) # This the active renderer imageStyle = vtk.vtkInteractorStyleImage() imageStyle.SetDefaultRenderer(renderer1) switchStyle = vtk.vtkInteractorStyleSwitch() switchStyle.SetDefaultRenderer(renderer0) renderWindowInteractor.SetInteractorStyle(switchStyle)
def main(): colors = vtk.vtkNamedColors() # Create the RenderWindow, Renderer and Interactor. # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Generate the tensors. ptLoad = vtk.vtkPointLoad() ptLoad.SetLoadValue(100.0) ptLoad.SetSampleDimensions(20, 20, 20) ptLoad.ComputeEffectiveStressOn() ptLoad.SetModelBounds(-10, 10, -10, 10, -10, 10) ptLoad.Update() # Generate the hyperstreamlines. s1 = vtk.vtkHyperStreamline() s1.SetInputData(ptLoad.GetOutput()) s1.SetStartPosition(9, 9, -9) s1.IntegrateMinorEigenvector() s1.SetMaximumPropagationDistance(18.0) s1.SetIntegrationStepLength(0.1) s1.SetStepLength(0.01) s1.SetRadius(0.25) s1.SetNumberOfSides(18) s1.SetIntegrationDirectionToIntegrateBothDirections() s1.Update() # Map the hyperstreamlines. lut = vtk.vtkLogLookupTable() lut.SetHueRange(.6667, 0.0) s1Mapper = vtk.vtkPolyDataMapper() s1Mapper.SetInputConnection(s1.GetOutputPort()) s1Mapper.SetLookupTable(lut) s1Mapper.SetScalarRange(ptLoad.GetOutput().GetScalarRange()) s1Actor = vtk.vtkActor() s1Actor.SetMapper(s1Mapper) s2 = vtk.vtkHyperStreamline() s2.SetInputData(ptLoad.GetOutput()) s2.SetStartPosition(-9, -9, -9) s2.IntegrateMinorEigenvector() s2.SetMaximumPropagationDistance(18.0) s2.SetIntegrationStepLength(0.1) s2.SetStepLength(0.01) s2.SetRadius(0.25) s2.SetNumberOfSides(18) s2.SetIntegrationDirectionToIntegrateBothDirections() s2.Update() s2Mapper = vtk.vtkPolyDataMapper() s2Mapper.SetInputConnection(s2.GetOutputPort()) s2Mapper.SetLookupTable(lut) s2Mapper.SetScalarRange(ptLoad.GetOutput().GetScalarRange()) s2Actor = vtk.vtkActor() s2Actor.SetMapper(s2Mapper) s3 = vtk.vtkHyperStreamline() s3.SetInputData(ptLoad.GetOutput()) s3.SetStartPosition(9, -9, -9) s3.IntegrateMinorEigenvector() s3.SetMaximumPropagationDistance(18.0) s3.SetIntegrationStepLength(0.1) s3.SetStepLength(0.01) s3.SetRadius(0.25) s3.SetNumberOfSides(18) s3.SetIntegrationDirectionToIntegrateBothDirections() s3.Update() s3Mapper = vtk.vtkPolyDataMapper() s3Mapper.SetInputConnection(s3.GetOutputPort()) s3Mapper.SetLookupTable(lut) s3Mapper.SetScalarRange(ptLoad.GetOutput().GetScalarRange()) s3Actor = vtk.vtkActor() s3Actor.SetMapper(s3Mapper) s4 = vtk.vtkHyperStreamline() s4.SetInputData(ptLoad.GetOutput()) s4.SetStartPosition(-9, 9, -9) s4.IntegrateMinorEigenvector() s4.SetMaximumPropagationDistance(18.0) s4.SetIntegrationStepLength(0.1) s4.SetStepLength(0.01) s4.SetRadius(0.25) s4.SetNumberOfSides(18) s4.SetIntegrationDirectionToIntegrateBothDirections() s4.Update() s4Mapper = vtk.vtkPolyDataMapper() s4Mapper.SetInputConnection(s4.GetOutputPort()) s4Mapper.SetLookupTable(lut) s4Mapper.SetScalarRange(ptLoad.GetOutput().GetScalarRange()) s4Actor = vtk.vtkActor() s4Actor.SetMapper(s4Mapper) # A plane for context. # g = vtk.vtkImageDataGeometryFilter() g.SetInputData(ptLoad.GetOutput()) g.SetExtent(0, 100, 0, 100, 0, 0) g.Update() # for scalar range gm = vtk.vtkPolyDataMapper() gm.SetInputConnection(g.GetOutputPort()) gm.SetScalarRange(g.GetOutput().GetScalarRange()) ga = vtk.vtkActor() ga.SetMapper(gm) # Create an outline around the data. # outline = vtk.vtkOutlineFilter() outline.SetInputData(ptLoad.GetOutput()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(colors.GetColor3d('Black')) # Create a cone indicating the application of the load. # coneSrc = vtk.vtkConeSource() coneSrc.SetRadius(0.5) coneSrc.SetHeight(2) coneMap = vtk.vtkPolyDataMapper() coneMap.SetInputConnection(coneSrc.GetOutputPort()) coneActor = vtk.vtkActor() coneActor.SetMapper(coneMap) coneActor.SetPosition(0, 0, 11) coneActor.RotateY(90) coneActor.GetProperty().SetColor(colors.GetColor3d('Tomato')) camera = vtk.vtkCamera() camera.SetFocalPoint(0.113766, -1.13665, -1.01919) camera.SetPosition(-29.4886, -63.1488, 26.5807) camera.SetViewAngle(24.4617) camera.SetViewUp(0.17138, 0.331163, 0.927879) camera.SetClippingRange(1, 100) ren1.AddActor(s1Actor) ren1.AddActor(s2Actor) ren1.AddActor(s3Actor) ren1.AddActor(s4Actor) ren1.AddActor(outlineActor) ren1.AddActor(coneActor) ren1.AddActor(ga) ren1.SetBackground(colors.GetColor3d('SlateGray')) ren1.SetActiveCamera(camera) renWin.SetSize(640, 480) renWin.SetWindowName('HyperStreamline') renWin.Render() iren.Start()