def output_screenshot(self, screenshot_fname): """ Saves scene rendered in the renderer to the image :param ren: {vtkRenderer} renderer :param screenshot_fname: {str} screenshot filename :return: None """ ren = self.get_renderer() renWin = vtk.vtkRenderWindow() renWin.SetOffScreenRendering(1) renWin.AddRenderer(ren) renWin.Render() windowToImageFilter = vtk.vtkWindowToImageFilter() windowToImageFilter.SetInput(renWin) windowToImageFilter.Update() writer = vtk.vtkPNGWriter() # writer.SetFileName('D:/CC3D_GIT/CompuCell3D/player5/GraphicsOffScreen/{screenshot_name}.png'.format( # screenshot_name=screenshot_fname)) writer.SetFileName(screenshot_fname) writer.SetInputConnection(windowToImageFilter.GetOutputPort()) writer.Write()
def OnExport(self, event): """Export to graphics filetype with extension ext.""" renWin = self.widget.GetRenderWindow() wif = vtk.vtkWindowToImageFilter() wif.SetInput(renWin) wildcard = "PNG (*.png)|*.png|" \ "Postscript (*.ps)|*.ps|" \ "JPEG (*.jpg)|*.jpg" # "TIFF (*.tif)|*.tif" dialog = wx.FileDialog(None, "Export Graphics", os.getcwd(), "", wildcard, wx.SAVE|wx.OVERWRITE_PROMPT) if dialog.ShowModal() == wx.ID_OK: path = dialog.GetPath() base, ext = os.path.splitext(path) if ext in ['.png', '.ps', '.jpg']: pass else: i = dialog.GetFilterIndex() ext = ['.png', '.ps', '.jpg'][i] # cases if ext == '.png': psw = vtk.vtkPNGWriter() elif ext == '.ps': psw = vtk.vtkPostScriptWriter() elif ext == '.jpg': psw = vtk.vtkJPEGWriter() psw.SetFileName(base + ext) psw.SetInput(wif.GetOutput()) psw.Write()
def get_image(self): converter = vtk.vtkWindowToImageFilter() converter.SetInput(self.render_window) converter.ReadFrontBufferOff() converter.Update() im = vtk_to_numpy(converter.GetOutput().GetPointData().GetScalars()) return np.flipud(im.reshape(self.height, self.width, im.shape[-1]))
def save(self, frames, outfile='animated.mp4'): ''' takes a snapshot of the frames at given t, and returns the paths ''' windowToImage = vtk.vtkWindowToImageFilter() windowToImage.SetInput(self.renWin) writer = vtk.vtkPNGWriter() writer.SetInput(windowToImage.GetOutput()) slide_paths = [] for t in frames: # f = NamedTemporaryFile(suffix='.png', delete=False) f = open("img{:0>3}.png".format(t), 'w') self.update_all(t=t) windowToImage.Modified() writer.SetFileName(f.name) writer.Write() slide_paths.append( f.name ) if len(slide_paths)==1: if not outfile.endswith('.png'): raise Exception("Cannot save single snapshot videos") call(["mv","img000.png",outfile]) elif outfile.endswith('.mp4'): call(["rm","-f", outfile]) call(["/usr/local/bin/ffmpeg", "-i","img%03d.png", "-c:v","libx264","-r","30", "-pix_fmt","yuv420p", outfile]) call(["rm"]+slide_paths)
def png(self, file, width=None,height=None,units=None,draw_white_background = 0): if self.renWin is None: raise Exception,"Nothing to dump aborting" if not file.split('.')[-1].lower() in ['png']: file+='.png' try: os.remove(file) except: pass if width is not None and height is not None: self.renWin.SetSize(width,height) #self.renWin.Render() imgfiltr = vtk.vtkWindowToImageFilter() imgfiltr.SetInput(self.renWin) # imgfiltr.SetMagnification(3) imgfiltr.SetInputBufferTypeToRGBA() imgfiltr.Update() writer = vtk.vtkPNGWriter() writer.SetInputConnection(imgfiltr.GetOutputPort()) writer.SetFileName(file) writer.Write()
def renWriteJPEG(ren,args): #@c Save the current window image to a file #@c in jpeg format. If no filename is specified, #@c then an interactive window is popped up asking #@c for a name to be given. #@a ren: renderer #@a args: filename if (args ==""): filename = raw_input("Please enter image name to save") else: filename = args if (filename ==""): return jwriter = vtk.vtkJPEGWriter() jwriter.ProgressiveOff() jwriter.SetQuality(95) ren.GetRenderWindow().Render() w2i = vtk.vtkWindowToImageFilter() w2i.SetInput(ren.GetRenderWindow()) w2i.Update() jwriter.SetInput(w2i.GetOutput()) jwriter.SetFileName(filename) jwriter.Write() del w2i del jwriter return
def save_png (self, file_name=""): """Requires VTK 4 to work.""" debug ("In RenderWindow::save_png ()") try: ex = vtk.vtkPNGWriter () except AttributeError: msg = "Saving to a PNG file is not supported by your "\ "version of VTK. Versions 4.0 and above support this." Common.print_err (msg) return if not file_name: file_name = tk_fsave (title="Export to PNG image", initialdir=Common.config.initial_dir, defaultextension=".png", filetypes=[("PNG images", "*.png"), ("All files", "*")]) if len (file_name) != 0: Common.state.busy () w2if = vtk.vtkWindowToImageFilter () w2if.SetMagnification (Common.config.magnification) self.lift () w2if.SetInput (self.renwin) ex = vtk.vtkPNGWriter () ex.SetFileName (file_name) ex.SetInput (w2if.GetOutput ()) ex.Write () Common.state.idle ()
def drawLineLineTest(): myscreen = ovdvtk.VTKScreen() myscreen.camera.SetPosition(0.01, 0, 1000 ) myscreen.camera.SetFocalPoint(0, 0, 0) myscreen.camera.SetClippingRange(-100,3000) w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(myscreen.renWin) lwr = vtk.vtkPNGWriter() lwr.SetInput( w2if.GetOutput() ) l1 = Line( math.cos(1), math.sin(1) , 1 , +1) # first line-site drawLine(myscreen, l1, ovdvtk.yellow ) l2 = Line( math.cos(3), math.sin(3) , 1 , -1) # second line-site drawLine(myscreen, l2, ovdvtk.orange ) l1l2 = LineLine( l1, l2 ) # bisectors l2l1 = LineLine( l2, l1 ) # it should not matter if we call with (l1,l2) or (l2,l1) (?) print l1l2 print l2l1 b1= Bisector( l1l2 ) b2= Bisector( l2l1 ) drawBisector( myscreen, b1 ) drawBisector( myscreen, b2 ) myscreen.render() myscreen.iren.Start()
def writeJPEG(self, fn): filter = vtk.vtkWindowToImageFilter() filter.SetInput(self.ren_win) writer = vtk.vtkJPEGWriter() writer.SetInput(filter.GetOutput()) writer.SetFileName(fn) writer.Write()
def Keypress(self,obj, event): key = obj.GetKeySym() if key =="l": #load with keyboard shortcut self.get_input_data(None) if key =="1": xyview_post(self.ren, self.ren.GetActiveCamera(),self.cp,self.fp) elif key =="2": yzview(self.ren, self.ren.GetActiveCamera(),self.cp,self.fp) elif key =="3": xzview(self.ren, self.ren.GetActiveCamera(),self.cp,self.fp) elif key == "Up": self.ren.GetActiveCamera().Roll(90) self.ren.ResetCamera() elif key=="i": im = vtk.vtkWindowToImageFilter() writer = vtk.vtkPNGWriter() im.SetInput(self.ui.vtkWidget._RenderWindow) im.Update() writer.SetInputConnection(im.GetOutputPort()) writer.SetFileName("postprocessed.png") writer.Write() self.ui.statLabel.setText("Screen output saved to %s" %os.path.join(os.getcwd(),'postprocessed.png')) elif key=="r": flip_visible(self.ax3D) elif key =="f": #flip color scheme for printing flip_colors(self.ren,self.ax3D) self.ui.vtkWidget.update()
def save_image(self): from vtk import vtkJPEGWriter, vtkJPEGWriter, vtkPNGWriter from vtk import vtkPNMWriter, vtkWindowToImageFilter from os import path sourcebase, _ = path.splitext(self.source) fname = sourcebase+'%05g.png' % self.frameNumber #print fname extmap = {'.jpg' : vtkJPEGWriter, '.jpeg' : vtkJPEGWriter, '.png' : vtkPNGWriter, '.pnm' : vtkPNMWriter, } basename, ext = path.splitext(fname) try: Writer = extmap[ext.lower()] except KeyError: error_msg("Don't know how to handle %s files" % ext, parent=self) return renWin = self.vtk_renderer.GetRenderWindow() w2i = vtkWindowToImageFilter() writer = Writer() w2i.SetInput(renWin) w2i.Update() writer.SetInput(w2i.GetOutput()) writer.SetFileName(fname) renWin.Render() writer.Write()
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 writeImage(): # Look for any file names matching the pattern and auto-increment ending number import glob, re existingFiles = glob.glob('BezierFiberJunctions*.png') if (len(existingFiles) == 0): outName = 'BezierFiberJunctions1.png' else: pat = re.compile('BezierFiberJunctions(\d+).png') numList = [] for name in existingFiles: match = re.search(pat,name) if match: numList.append(int(match.group(1))) numList.sort() outName = 'BezierFiberJunctions' + str(numList[-1]+1) + '.png' wif = vtk.vtkWindowToImageFilter() wif.SetInput(renWin) wif.Modified() png = vtk.vtkPNGWriter() png.SetInputConnection(wif.GetOutputPort(0)) png.SetFileName(outName) png.Write()
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 save_rendered(self, image_file_name): "Output snapshot to image file" image_file_type = os.path.splitext(image_file_name)[1] # Remove existing image file if os.path.exists(image_file_name): if os.path.isfile(image_file_name): os.remove(image_file_name) else: raise VisualizerError \ ('Cannot overwrite image file: ' + image_file_name) if image_file_type == '.bmp': writer = vtk.vtkBMPWriter() elif image_file_type == '.jpg': writer = vtk.vtkJPEGWriter() elif image_file_type == '.png': writer = vtk.vtkPNGWriter() elif image_file_type == '.tif': writer = vtk.vtkTIFFWriter() else: error_info = 'Illegal image-file type: ' + image_file_type + '\n' error_info += 'Please choose from "bmp","jpg","png","tif".' raise VisualizerError(error_info) w2i = vtk.vtkWindowToImageFilter() w2i.SetInput(self.window) self.window.Render() writer.SetInput(w2i.GetOutput()) writer.SetFileName(image_file_name) writer.Write()
def saveToPNG(self, filename): """ saveToPNG(filename: str) -> filename or vtkUnsignedCharArray Save the current widget contents to an image file. If str==None, then it returns the vtkUnsignedCharArray containing the PNG image. Otherwise, the filename is returned. """ w2i = vtk.vtkWindowToImageFilter() w2i.ReadFrontBufferOff() w2i.SetInput(self.mRenWin) # Render twice to get a clean image on the back buffer if self.mRenWin.GetInteractor(): self.mRenWin.GetInteractor().Render() self.mRenWin.GetInteractor().Render() else: self.mRenWin.Render() self.mRenWin.Render() w2i.Update() writer = vtk.vtkPNGWriter() writer.SetInputConnection(w2i.GetOutputPort()) if filename!=None: writer.SetFileName(filename) else: writer.WriteToMemoryOn() writer.Write() if filename: return filename else: return writer.GetResult()
def SavePNG(): png_number=__main__.png_number option_verbose=__main__.option_verbose option_prefix=__main__.option_prefix renwin=__main__.renwin rtTimer=vtk.vtkTimerLog my_print(option_verbose,'----------------------------') my_print(option_verbose,'Saving PNG') rtStartCPU=rtTimer.GetCPUTime() w2i = vtk.vtkWindowToImageFilter() w2i.SetInput(renwin) w2i.Update() filepng=option_prefix+'_%03d.png' %png_number my_print(option_verbose,'Start writing PNG file', filepng) pngw = vtk.vtkPNGWriter() pngw.SetInputConnection(w2i.GetOutputPort()) pngw.SetFileName(filepng) pngw.Write() rtEndCPU=rtTimer.GetCPUTime() my_print(option_verbose,'End writing PNG file') my_print(option_verbose,'CPU time:', rtEndCPU-rtStartCPU) __main__.png_number=png_number+1
def flush_render_buffer(): '''When running as a single process use the WindowToImage filter to force a framebuffer read. This bypasses driver optimizations that perform lazy rendering and allows you to get actual frame rates for a single process with a GPU. Multi-process doesn't need this since compositing forces the frame buffer read. ''' # If we're not using off-screen rendering then we can bypass this since # the frame buffer display will force a GL flush w = GetRenderView().SMProxy.GetRenderWindow() if not w.GetOffScreenRendering(): return import vtk # If we're using MPI we can also bypass this since compositing will # for a GL flush controller = vtk.vtkMultiProcessController.GetGlobalController() if controller.GetNumberOfProcesses() > 1: return # Force a GL flush by retrieving the frame buffer image w2i = vtk.vtkWindowToImageFilter() w2i.ReadFrontBufferOff() w2i.ShouldRerenderOff() w2i.SetInput(w) w2i.Modified() w2i.Update()
def show(window, name=None, magnification=2): interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(window) interactor.Initialize() window.Render() interactor.Start() windowToImageFilter = vtk.vtkWindowToImageFilter() windowToImageFilter.SetInput(window) windowToImageFilter.SetMagnification(magnification) windowToImageFilter.SetInputBufferTypeToRGBA() windowToImageFilter.ReadFrontBufferOff() windowToImageFilter.Update() writer = vtk.vtkPNGWriter() if name is None: filehandler = NamedTemporaryFile(delete=False) else: filehandler = open(name, 'w') writer.SetFileName(filehandler.name) writer.SetInputConnection(windowToImageFilter.GetOutputPort()) writer.Write() window.Finalize() interactor.TerminateApp() del interactor axes = plt.subplot() axes.imshow(img.imread(filehandler.name)) axes.axis('off') if name is None: os.unlink(filehandler.name)
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 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 captureImageFromView(self, view, filename): view.forceRender() # qt.QPixmap().grabWidget(...) would not grab the background rw = view.renderWindow() wti = vtk.vtkWindowToImageFilter() wti.SetInput(rw) wti.Update() writer = vtk.vtkPNGWriter() writer.SetFileName(filename) outputImage = wti.GetOutput() imageSize = outputImage.GetDimensions() if imageSize[0]<2 or imageSize[1]<2: # image is too small, most likely it is invalid raise ValueError('Capture image from view failed') # Make sure image witdth and height is even, otherwise encoding may fail imageWidthOdd = (imageSize[0] & 1 == 1) imageHeightOdd = (imageSize[1] & 1 == 1) if imageWidthOdd or imageHeightOdd: imageClipper = vtk.vtkImageClip() imageClipper.SetInputConnection(wti.GetOutputPort()) extent = outputImage.GetExtent() imageClipper.SetOutputWholeExtent(extent[0], extent[1]-1 if imageWidthOdd else extent[1], extent[2], extent[3]-1 if imageHeightOdd else extent[3], extent[4], extent[5]) writer.SetInputConnection(imageClipper.GetOutputPort()) else: writer.SetInputConnection(wti.GetOutputPort()) writer.Write()
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkWindowToImageFilter(), 'Processing.', (), ('vtkImageData',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def testEncodings(self): # Render something cylinder = vtk.vtkCylinderSource() cylinder.SetResolution(8) cylinderMapper = vtk.vtkPolyDataMapper() cylinderMapper.SetInputConnection(cylinder.GetOutputPort()) cylinderActor = vtk.vtkActor() cylinderActor.SetMapper(cylinderMapper) cylinderActor.RotateX(30.0) cylinderActor.RotateY(-45.0) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) ren.AddActor(cylinderActor) renWin.SetSize(200, 200) ren.ResetCamera() ren.GetActiveCamera().Zoom(1.5) renWin.Render() # Get a vtkImageData with the rendered output w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(renWin) w2if.SetShouldRerender(1) w2if.SetReadFrontBuffer(0) w2if.Update() imgData = w2if.GetOutput() # Use vtkDataEncoder to convert the image to PNG format and Base64 encode it encoder = vtk.vtkDataEncoder() base64String = encoder.EncodeAsBase64Png(imgData).encode('ascii') # Now Base64 decode the string back to PNG image data bytes outputBuffer = bytearray(120000) inputArray = array.array('B', base64String) utils = vtk.vtkIOCore.vtkBase64Utilities() actualLength = utils.Decode(inputArray, 120000, outputBuffer) outputArray = bytearray(actualLength) outputArray[:] = outputBuffer[0:actualLength] # And write those bytes to the disk as an actual PNG image file with open('TestDataEncoder.png', 'wb') as fd: fd.write(outputArray) # Create a vtkTesting object and specify a baseline image rtTester = vtk.vtkTesting() for arg in sys.argv[1:]: rtTester.AddArgument(arg) rtTester.AddArgument("-V") rtTester.AddArgument("TestDataEncoder.png") # Perform the image comparison test and print out the result. result = rtTester.RegressionTest("TestDataEncoder.png", 0.0) if result == 0: raise Exception("TestDataEncoder failed.")
def getAsImage(self): """ Render the scene to a vtkImageData """ filter = vtk.vtkWindowToImageFilter() filter.SetInput(self.renWin) filter.Update() return filter.GetOutput()
def startMovie(self): self.w = vtk.vtkWindowToImageFilter() self.w.SetInput(self.GetRenderWindow()) self.movie = vtk.vtkMPEG2Writer() # Check is it is available. self.movie.SetInput(self.w.GetOutput()) self.movie.SetFileName("cellsort2D.mpg") self.movie.Start()
def __init__(self, cinema_store, arguments, engines, rw): super(ImageExplorer, self).__init__(cinema_store, arguments, engines) self.rw = rw self.w2i = vtk.vtkWindowToImageFilter() self.w2i.SetInput(self.rw) self.pw = vtk.vtkPNGWriter() self.pw.SetInputConnection(self.w2i.GetOutputPort()) self.pw.WriteToMemoryOn()
def __init__(self, cinema_store, parameters, engines, rw): super(ImageExplorer, self).__init__(cinema_store, parameters, engines) self.rw = rw self.w2i = vtk.vtkWindowToImageFilter() #self.w2i.ReadFrontBufferOff() self.w2i.SetInput(self.rw) self.vp = None self.lp = None
def generate_png(win, fnm): win.Render() out_filter = vtk.vtkWindowToImageFilter() out_filter.SetInput(win) png_writer = vtk.vtkPNGWriter() png_writer.SetFileName(fnm) png_writer.SetInputConnection(out_filter.GetOutputPort()) png_writer.Write()
def capture_image(self,obj,eve): self.renWin.Render() self.w2i = vtk.vtkWindowToImageFilter() self.w2i.SetInput(self.renWin) self.writer = vtk.vtkJPEGWriter() self.writer.SetInputConnection(self.w2i.GetOutputPort()) self.writer.SetFileName(`self.print_counter` + "vectorscreen.jpg"); self.print_counter =1 + self.print_counter self.writer.Write()
def main(): myscreen = camvtk.VTKScreen() focal = cam.Point(50, 0, 0) r = 300 theta = (float(45) / 360) * 2 * math.pi fi = 45 campos = cam.Point(r * math.sin(theta) * math.cos(fi), r * math.sin(theta) * math.sin(fi), r * math.cos(theta)) myscreen.camera.SetPosition(campos.x, campos.y, campos.z) myscreen.camera.SetFocalPoint(focal.x, focal.y, focal.z) t = camvtk.Text() t.SetPos((myscreen.width - 450, myscreen.height - 30)) myscreen.addActor(t) t2 = camvtk.Text() ytext = "kd-tree debug" #"Y: %3.3f" % (ycoord) t2.SetText(ytext) t2.SetPos((50, myscreen.height - 50)) myscreen.addActor(t2) w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(myscreen.renWin) lwr = vtk.vtkPNGWriter() lwr.SetInput(w2if.GetOutput()) epos = cam.Epos() epos.setS(0, 1) t.SetText("OpenCAMLib 10.03-beta, " + datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")) #ycoord = 1.1 stl = camvtk.STLSurf(filename="../stl/demo.stl") #stl = camvtk.STLSurf(filename="../stl/demo2.stl") print "STL surface read" #myscreen.addActor(stl) #stl.SetWireframe() #stl.SetColor((0.5,0.5,0.5)) polydata = stl.src.GetOutput() s = cam.STLSurf() camvtk.vtkPolyData2OCLSTL(polydata, s) print "STLSurf with ", s.size(), " triangles" myscreen.addActor( camvtk.Sphere(center=(0, 0, 0), radius=0.2, color=camvtk.yellow)) s.build_kdtree() print "built kd-tree" s.jump_kd_reset() tlist = s.get_kd_triangles() print "got", len(tlist), " triangles" while (s.jump_kd_hi()): lotris = s.get_kd_triangles() s.jump_kd_up() cut = s.get_kd_cut() s.jump_kd_lo() hitris = s.get_kd_triangles() lev = s.get_kd_level() print "l=", lev, " hi=", len(hitris), " lo=", len(lotris), " cut=", cut if (cut[0] < 2): print "x cut ", if (cut[0] == 0): print "max" myscreen.addActor( camvtk.Line(p1=(cut[1], 100, 0), p2=(cut[1], -100, 0), color=camvtk.green)) else: print "min" myscreen.addActor( camvtk.Line(p1=(cut[1], 100, 0), p2=(cut[1], -100, 0), color=camvtk.lgreen)) #myscreen.addActor( camvtk.Line( p1=(100,cut[1],0), p2=(-100,cut[1],0), color = camvtk.red ) ) else: print "y cut ", if (cut[0] == 2): print "max" myscreen.addActor( camvtk.Line(p1=(100, cut[1], 0), p2=(-100, cut[1], 0), color=camvtk.red)) else: print "min" myscreen.addActor( camvtk.Line(p1=(100, cut[1], 0), p2=(-100, cut[1], 0), color=camvtk.pink)) slo = camvtk.STLSurf(triangleList=lotris) slo.SetColor(camvtk.pink) slo.SetWireframe() shi = camvtk.STLSurf(triangleList=hitris) shi.SetColor(camvtk.lgreen) shi.SetWireframe() myscreen.addActor(slo) myscreen.addActor(shi) myscreen.render() myscreen.iren.Start() raw_input("Press Enter to terminate") time.sleep(1) myscreen.removeActor(slo) myscreen.removeActor(shi) print "done." myscreen.render() #lwr.SetFileName(filename) #raw_input("Press Enter to terminate") time.sleep(0.2) lwr.Write() myscreen.iren.Start()
def drawScreen(a, b, c, filename, write_flag): print ocl.revision() myscreen = camvtk.VTKScreen() #a = ocl.Point(0,1,0.3) myscreen.addActor(camvtk.Point(center=(a.x, a.y, a.z), color=(1, 0, 1))) #b = ocl.Point(1,0.5,0.3) myscreen.addActor(camvtk.Point(center=(b.x, b.y, b.z), color=(1, 0, 1))) #c = ocl.Point(-0.1,0.3,0.0) myscreen.addActor(camvtk.Point(center=(c.x, c.y, c.z), color=(1, 0, 1))) myscreen.addActor(camvtk.Line(p1=(a.x, a.y, a.z), p2=(c.x, c.y, c.z))) myscreen.addActor(camvtk.Line(p1=(c.x, c.y, c.z), p2=(b.x, b.y, b.z))) myscreen.addActor(camvtk.Line(p1=(a.x, a.y, a.z), p2=(b.x, b.y, b.z))) t = ocl.Triangle(b, c, a) s = ocl.STLSurf() s.addTriangle(t) # a one-triangle STLSurf zheights = [ -0.3, -0.2, -0.1, -0.05, 0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.26, 0.27, 0.28, 0.29 ] # the z-coordinates for the waterlines zheights = [ -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, -0.05, 0.0, 0.05, 0.1, 0.15, 0.2, 0.28 ] zheights = [ -0.35, -0.3, -0.25, -0.2, -0.15, -0.1, -0.05, 0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.28 ] zheights = [] Nmax = 20 zmin = -0.5 zmax = -0.05 dz = (zmax - zmin) / float(Nmax - 1) z = zmin for n in xrange(Nmax): zheights.append(z) z = z + dz zheights = [] zheights.append(-0.25) #zheights=[ -0.35, -0.25, -0.15, -0.05, 0.05, 0.15, 0.25] #zheights=[ 0.1] length = 10 diam = 0.6 cutter1 = ocl.CylCutter(diam, length) cutter2 = ocl.BallCutter(diam, length) cutter3 = ocl.BullCutter(diam, diam / 5, length) cutter4 = ocl.ConeCutter(diam, math.pi / 5, length) for zh in zheights: #loops = calcWaterline(zh, cutter1, s) #drawLoops(myscreen, loops[0], camvtk.yellow) #loops = calcWaterline(zh, cutter2, s) #drawLoops(myscreen, loops[0], camvtk.green) #loops = calcWaterline(zh, cutter3, s) #drawLoops(myscreen, loops[0], camvtk.yellow) loops = calcWaterline(zh, cutter4, s) drawLoops(myscreen, loops[0], camvtk.pink) #for f in loops[1]: # drawFiber(myscreen, f, camvtk.red) #for f in loops[2]: # drawFiber(myscreen, f, camvtk.lblue) print "done." myscreen.camera.SetPosition(1, -1, 3) myscreen.camera.SetFocalPoint(0.5, 0.5, 0) camvtk.drawArrows(myscreen, center=(-0.5, -0.5, -0.5)) camvtk.drawOCLtext(myscreen) myscreen.render() w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(myscreen.renWin) lwr = vtk.vtkPNGWriter() lwr.SetInput(w2if.GetOutput()) w2if.Modified() lwr.SetFileName(filename) if write_flag: lwr.Write() print "wrote ", filename time.sleep(1)
def keypress(self, obj, event): key = obj.GetKeyCode() if key == "1": XYView(self.ren, self.ren.GetActiveCamera(), self.cp, self.fp) elif key == "2": YZView(self.ren, self.ren.GetActiveCamera(), self.cp, self.fp) elif key == "3": XZView(self.ren, self.ren.GetActiveCamera(), self.cp, self.fp) elif key == "z": self.Zaspect = self.Zaspect * 2 s, nl, axs = self.get_scale() if hasattr(self, 'splineActor'): self.splineActor.SetScale(s) self.splineActor.Modified() if hasattr(self, 'pointActor'): self.pointActor.SetScale(s) self.pointActor.Modified() self.ren.RemoveActor(self.axisActor) self.axisActor = add_axis(self.ren, nl, axs) elif key == "x": self.Zaspect = self.Zaspect * 0.5 s, nl, axs = self.get_scale() if hasattr(self, 'splineActor'): self.splineActor.SetScale(s) self.splineActor.Modified() if hasattr(self, 'pointActor'): self.pointActor.SetScale(s) self.pointActor.Modified() self.ren.RemoveActor(self.axisActor) self.axisActor = add_axis(self.ren, nl, axs) elif key == "c": self.Zaspect = 1.0 s, _, _, = self.get_scale() if hasattr(self, 'splineActor'): self.splineActor.SetScale(s) self.splineActor.Modified() if hasattr(self, 'pointActor'): self.pointActor.SetScale(s) self.pointActor.Modified() self.ren.RemoveActor(self.axisActor) self.axisActor = add_axis(self.ren, self.limits, [1, 1, 1]) self.ren.ResetCamera() elif key == "i": im = vtk.vtkWindowToImageFilter() writer = vtk.vtkPNGWriter() im.SetInput(self.ui.vtkWidget._RenderWindow) im.Update() writer.SetInputConnection(im.GetOutputPort()) writer.SetFileName("spline_fit.png") writer.Write() print("Screen output saved to %s" % os.path.join(os.getcwd(), 'spline_fit.png')) elif key == "a": FlipVisible(self.axisActor) elif key == "f": #flip color scheme for printing FlipColors(self.ren, self.axisActor, None) FlipColors(self.ren, self.pointActor, 1) if hasattr(self, 'splineActor'): FlipColors(self.ren, self.splineActor, 0) elif key == "o": FlipVisible(self.outlineActor) elif key == "Z": self.PointSize = updatePointSize(self.pointActor, self.PointSize * 2) if hasattr(self, 'splineActor'): self.LineWidth = updateLineWidth(self.splineActor, self.LineWidth * 2) elif key == "X": self.PointSize = updatePointSize(self.pointActor, self.PointSize * 0.5) if hasattr(self, 'splineActor'): self.LineWidth = updateLineWidth(self.splineActor, self.LineWidth * 0.5) elif key == "C": self.PointSize = updatePointSize(self.pointActor, 1) if hasattr(self, 'splineActor'): self.LineWidth = updateLineWidth(self.splineActor, 1) elif key == "e": self.write() elif key == "q": if sys.stdin.isatty(): sys.exit("Surface fitting complete.") else: print("Surface fitting completed.") return elif key == "l": self.get_input_data(None) elif key == "r": if self.picking == True: self.picking = False self.show_picking() else: self.picking = True self.show_picking() self.start_pick() self.ui.vtkWidget.update()
def vtkcontourf_obj(cutMapper, pl3d_output, src_output, var_name, levels, snapshot_dir, plane_normal, scalarRange, i_d): # if not X_is_running(): # return #off-screen rendering #gfac = vtk.vtkGraphicsFactory #gfac.SetOffScreenOnlyMode(1) #gfac.SetUseMesaClasses(1) #im_fac = vtk.vtkImagingFactory #im_fac.SetUseMesaClasses(1) pl3d_output.GetPointData().SetActiveScalars(var_name) if (scalarRange == (0, 0)): #print scalarRange # this prevents zero values from setting colourbar scalarnump = VN.vtk_to_numpy( src_output.GetOutput().GetPointData().GetScalars(var_name)) minval = np.amin(scalarnump) try: if (minval >= 0.0): minval = np.amin(scalarnump[scalarnump > 0.0]) except Exception: pass maxval = np.amax(scalarnump) scalarRange = (minval, maxval) #print scalarRange # set bounds to be symmetric if requested if i_d.symmetric: if (np.abs(minval) > np.abs(maxval)): maxval = -minval else: minval = -maxval scalarRange = (minval, maxval) #set minval/maxval to zero if very small if (np.abs(minval) < np.finfo(np.float64).eps): minval = 0.0 if (np.abs(maxval) < np.finfo(np.float64).eps): minval = 0.0 scalarRange = (minval, maxval) #scalarRange =pl3d_output.GetPointData().GetScalars(var_name).GetRange() else: minval = scalarRange[0] maxval = scalarRange[1] cutMapper.SetScalarRange(scalarRange) cutActor = vtk.vtkActor() cutActor.SetMapper(cutMapper) #cutActor.SetMapper(src_output) lut = vtk.vtkLookupTable() #MakeLUT() lut.SetNumberOfTableValues(levels) if (i_d.colourmap == 'jet'): lut.SetHueRange(0.667, 0.0) elif (i_d.colourmap == 'viridis'): lut.SetHueRange(0.801282320, 0.149576098) lut.SetSaturationRange(0.985203081, 0.855085320) lut.SetValueRange(0.329415190, 0.993247890) lut.SetNanColor(1, 0, 0, 1) lut.Build() cutMapper.SetLookupTable(lut) scalarBar = vtk.vtkScalarBarActor() scalarBar.SetLookupTable(lut) scalarBar.SetTitle(var_name) absmax = np.amax([np.abs(minval), np.abs(maxval)]) if (absmax < 1000 and absmax > .1): scalarBar.SetLabelFormat("%-#3.2f") elif (absmax < .1): scalarBar.SetLabelFormat("%-#3.2e") tprop = vtk.vtkTextProperty() tprop.SetColor(0, 0, 0) #if i_d.non_dimensionalise: tprop.SetFontSize(10) scalarBar.SetTitleTextProperty(tprop) scalarBar.SetLabelTextProperty(tprop) scalarBar.SetTextPad(1) # Add the actors to the renderer, set the background and size #ren.AddActor(outlineActor) #ren.AddActor(planeActor) # Create the RenderWindow, Renderer and both Actors ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetOffScreenRendering(1) #off-screen render renWin.AddRenderer(ren) #iren = vtk.vtkRenderWindowInteractor() #iren.SetRenderWindow(renWin) ren.AddActor(cutActor) ren.AddActor2D(scalarBar) ren.SetBackground(1, 1, 1) renWin.SetSize(i_d.render_size[0], i_d.render_size[1]) camera = vtk.vtkCamera() camera.SetPosition(plane_normal) ren.SetActiveCamera(camera) #zoom ren.ResetCamera() ren.GetActiveCamera().Zoom(0.9) ren.GetActiveCamera().Dolly(1.4) ren.ResetCameraClippingRange() #off-screen renWin.Render() win2im = vtk.vtkWindowToImageFilter() win2im.SetInput(renWin) win2im.Update() writer = vtk.vtkPNGWriter() writer.SetFileName(snapshot_dir + '.png') writer.SetInputConnection(win2im.GetOutputPort()) writer.Write()
import gzip if __name__ == "__main__": # size of viewport in pixels #w=2500 #h=1500 #w=1920 #h=1080 w = 1024 h = 800 myscreen = ovdvtk.VTKScreen(width=w, height=h) ovdvtk.drawOCLtext(myscreen, rev_text=ovd.version()) w2if = vtk.vtkWindowToImageFilter() # for screenshots w2if.SetInput(myscreen.renWin) lwr = vtk.vtkPNGWriter() lwr.SetInput(w2if.GetOutput()) #w2if.Modified() #lwr.SetFileName("tux1.png") scale = 1 myscreen.render() random.seed(42) far = 1 camPos = far zmult = 3 # camPos/float(1000) myscreen.camera.SetPosition(0, -camPos / float(1000), zmult * camPos) myscreen.camera.SetClippingRange(-(zmult + 1) * camPos,
outlineActor.SetMapper(outlineMapper) # the actors property defines color, shading, line width,... outlineActor.GetProperty().SetColor(0.8, 0.8, 0.8) outlineActor.GetProperty().SetLineWidth(2.0) # add the actors renderer.AddActor(outlineActor) renderer.AddActor(liverActor) renderer.AddActor(showInfoTextActor) renderer.AddActor(showInfoTextActor2) render_window.Render() # Create a window-to-image filter and a PNG writer that can be used # for taking screenshots window2image_filter = vtk.vtkWindowToImageFilter() window2image_filter.SetInput(render_window) png_writer = vtk.vtkPNGWriter() png_writer.SetInput(window2image_filter.GetOutput()) # Set up the keyboard interface keyboard_interface = KeyboardInterface() keyboard_interface.render_window = render_window keyboard_interface.window2image_filter = window2image_filter keyboard_interface.png_writer = png_writer keyboard_interface.renderer = renderer # Connect the keyboard interface to the interactor interactor.AddObserver("KeyPressEvent", keyboard_interface.keypress) # Initialize the interactor and start the rendering loop
def get_screenshot(path, view, center=False): reader = vtk.vtkPolyDataReader() reader.SetFileName(path) reader.Update() fow = vtk.vtkFileOutputWindow() fow.SetFileName('ow.txt') ow = vtk.vtkOutputWindow() ow.SetInstance(fow) surf = reader.GetOutput() # surf.ColorCells(1, 0, 0) # create a rendering window and renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) WIDTH = 640 HEIGHT = 500 renWin.SetSize(WIDTH, HEIGHT) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # mapper surfMapper = vtk.vtkPolyDataMapper() surfMapper.SetInputData(surf) # actor surfActor = vtk.vtkActor() surfActor.SetMapper(surfMapper) # surfActor.GetProperty().SetColor(1, 0, 0) if not center: centerOfMassFilter = vtk.vtkCenterOfMass() centerOfMassFilter.SetInputData(surf) centerOfMassFilter.SetUseScalarsAsWeights(False) centerOfMassFilter.Update() center = centerOfMassFilter.GetCenter() print(center) camera = vtk.vtkCamera() dist_x = 0 dist_z = 300 if view == 'posterior': pos = (center[0] - dist_x, center[1] + 400, center[2] - dist_z) elif view == 'anterior': pos = (center[0] + dist_x, center[1] + 0, center[2] + dist_z) else: raise ValueError('view is not supported: {}'.format(view)) camera.SetPosition(pos) camera.SetFocalPoint(center[0], center[1], center[2]) # assign actor to the renderer ren.AddActor(surfActor) ren.SetActiveCamera(camera) ren.SetBackground(1, 1, 1) renWin.Render() # screenshot code: w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(renWin) w2if.Update() writer = vtk.vtkPNGWriter() writer.SetFileName("screenshots/screenshot.png") writer.SetInputData(w2if.GetOutput()) writer.Write() # iren.Initialize() # renWin.Render() # iren.Start() im = sitk.GetArrayFromImage(sitk.ReadImage('screenshots/screenshot.png')) return im[100:400, 25:605], center
def rotation_series(render_window, rotations=3, rotation_axis="azimuth", append_ID=True, series_name='', label_background=[0, 1, 0], label_font_size=10, label_color=[1, 0, 0], label_orientation='vertical'): ''' Collect a series of images as a camera rotates around an object. Parameters ---------- renderWindow : vtk.vtkRenderWindow Window to manipulate and grab images from rotationAxis : str accepts azimuth or elevation rotationNumber : int number of images to generate ''' iren = render_window.GetInteractor() if iren.GetInitialized() == 0: iren.Initialize() render_window.OffScreenRenderingOn() renderer = render_window.GetRenderers().GetFirstRenderer() camera = renderer.GetActiveCamera() images = [] if append_ID: text_actor = vtk.vtkCaptionActor2D() text_actor.SetAttachmentPoint( (0.0, -0.15, 0.0)) #position relative to center of screen text_actor.SetPosition(0, 0) #position relative to attachment point text_actor.SetCaption(str(series_name)) text_actor.GetCaptionTextProperty().SetJustificationToLeft() text_actor.GetCaptionTextProperty().SetFontSize(24) text_actor.GetCaptionTextProperty().SetVerticalJustificationToCentered( ) text_actor.GetCaptionTextProperty().UseTightBoundingBoxOn() # # text_actor.GetTextActor().SetTextScaleModeToProp() text_actor.GetTextActor().SetTextScaleModeToViewport( ) #This seems to work best? # text_actor.GetTextActor().SetTextScaleModeToNone() text_actor.BorderOff() text_actor.GetCaptionTextProperty().SetVerticalJustificationToCentered( ) text_actor.GetCaptionTextProperty().SetOrientation(90) #build renderwindow size = render_window.GetSize( ) #I might make it so it is smaller in one dimension label_dimensions = [] if label_orientation == 'vertical': label_dimensions = [int(0.1 * size[0]), size[1]] else: label_dimensions = [size[0], int(0.1 * size[1])] label_renWin = simple_vtkRenderWindow( actors=[text_actor], render_dimensions=label_dimensions, background_color=[0, 0, 1], display_window=False) label_iren = label_renWin.GetInteractor() if label_iren.GetInitialized() == 0: label_iren.Initialize() label_renderer = label_renWin.GetRenderers().GetFirstRenderer() label_renWin.OffScreenRenderingOn() #grab and append image image_filter = vtk.vtkWindowToImageFilter() image_filter.SetInput(label_renWin) image_filter.Modified() image_filter.Update() images.append(image_filter.GetOutput()) #clean up resources del image_filter label_renWin.Finalize() label_iren.TerminateApp() del label_renWin, label_iren #rotation images for x in range(rotations): image_filter = vtk.vtkWindowToImageFilter() image_filter.SetInput(render_window) image_filter.Modified() image_filter.Update() images.append(image_filter.GetOutput()) if rotation_axis == 'azimuth': camera.Azimuth(360 / rotations) elif rotation_axis == 'elevation': camera.Elevation(360 / rotations) del image_filter return images
def volume_render(field, outfile, maxopacity=1.0, cmap='bone', size=600, elevation=45, azimuth=45, bkg=(0.0, 0.0, 0.0), opacitycut=0.35, offscreen=False, rayfunction='smart'): """ Uses vtk to make render an image of a field, with control over the camera angle and colormap. Input Parameters ---------------- field : np.ndarray 3D array of the field to render. outfile : string The save name of the image. maxopacity : Float Default is 1.0 cmap : matplotlib colormap string Passed to cmap2colorfunc. Default is bone. size : 2-element list-like of ints or Int The size of the final rendered image. elevation : Numeric The elevation of the camera angle, in degrees. Default is 45 azimuth : Numeric The azimuth of the camera angle, in degrees. Default is 45 bkg : Tuple of floats 3-element tuple of floats on [0,1] of the background image color. Default is (0., 0., 0.). """ sh = field.shape dataImporter = vtk.vtkImageImport() dataImporter.SetDataScalarTypeToUnsignedChar() data_string = field.tostring() dataImporter.SetNumberOfScalarComponents(1) dataImporter.CopyImportVoidPointer(data_string, len(data_string)) dataImporter.SetDataExtent(0, sh[2] - 1, 0, sh[1] - 1, 0, sh[0] - 1) dataImporter.SetWholeExtent(0, sh[2] - 1, 0, sh[1] - 1, 0, sh[0] - 1) alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(0, 0.0) alphaChannelFunc.AddPoint(int(255 * opacitycut), maxopacity) volumeProperty = vtk.vtkVolumeProperty() colorFunc = cmap2colorfunc(cmap) volumeProperty.SetColor(colorFunc) volumeProperty.SetScalarOpacity(alphaChannelFunc) volumeMapper = vtk.vtkVolumeRayCastMapper() if rayfunction == 'mip': comp = vtk.vtkVolumeRayCastMIPFunction() comp.SetMaximizeMethodToOpacity() elif rayfunction == 'avg': comp = vtk.vtkVolumeRayCastCompositeFunction() elif rayfunction == 'iso': comp = vtk.vtkVolumeRayCastIsosurfaceFunction() comp.SetIsoValue(maxopacity / 2) else: comp = vtk.vtkVolumeRayCastIsosurfaceFunction() volumeMapper.SetSampleDistance(0.1) volumeMapper.SetVolumeRayCastFunction(comp) if rayfunction == 'smart': volumeMapper = vtk.vtkSmartVolumeMapper() volumeMapper.SetInputConnection(dataImporter.GetOutputPort()) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) light = vtk.vtkLight() light.SetLightType(vtk.VTK_LIGHT_TYPE_HEADLIGHT) light.SetIntensity(5.5) light.SwitchOn() renderer = vtk.vtkRenderer() renderWin = vtk.vtkRenderWindow() renderWin.AddRenderer(renderer) renderWin.SetOffScreenRendering(1) if not hasattr(size, '__iter__'): size = (size, size) renderer.AddVolume(volume) renderer.AddLight(light) renderer.SetBackground(*bkg) renderWin.SetSize(*size) if offscreen: renderWin.SetOffScreenRendering(1) def exitCheck(obj, event): if obj.GetEventPending() != 0: obj.SetAbortRender(1) renderWin.AddObserver("AbortCheckEvent", exitCheck) renderInteractor = vtk.vtkRenderWindowInteractor() renderInteractor.Initialize() renderWin.Render() renderInteractor.Start() #writer = vtk.vtkFFMPEGWriter() #writer.SetQuality(2) #writer.SetRate(24) #w2i = vtk.vtkWindowToImageFilter() #w2i.SetInput(renderWin) #writer.SetInputConnection(w2i.GetOutputPort()) #writer.SetFileName('movie.avi') #writer.Start() #writer.End() writer = vtk.vtkPNGWriter() w2i = vtk.vtkWindowToImageFilter() w2i.SetInput(renderWin) writer.SetInputConnection(w2i.GetOutputPort()) renderWin.Render() ac = renderer.GetActiveCamera() ac.Elevation(elevation) ac.Azimuth(azimuth) renderer.ResetCameraClippingRange() renderWin.Render() w2i.Modified() writer.SetFileName(outfile) writer.Write()
def view(self, color=[0.5,1,0.5], opacity=1.0, save_png=False, camera_pos=[50,50,50], interact=True): '''Function to view the mesh using the VTK library Parameters: color : list, optional VTK color specification for the mesh opackty : float, optional VTK opacity for the mesh. Must be between 0. and 1. save_png : bool Boolean operater that determines if a .png image of the mesh is saved. interact : bool, optional Boolean operater that determines if the user can interact with the geometry (e.g. zoom and rotate) after it is displayed camera_pos : list, optional Examples: This example assumes that a mesh has been read by bemio and mesh data is contained in a `PanelMesh` object called `mesh` >>> mesh.view() The mesh view window must be closed in order to return command to the Python shell ''' if self.VTK_installed is False: raise VTK_Exception('VTK must be installed to use the view function') # Create a mapper and load VTP data into the mapper mapper=vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION >= 6: mapper.SetInputData(self.vtp_mesh) else: mapper.SetInput(self.vtp_mesh) # Create an actor that contains the data in the mapper actor=vtk.vtkActor() actor.GetProperty().SetColor(color) actor.GetProperty().SetOpacity(opacity) actor.SetMapper(mapper) actor.GetProperty().EdgeVisibilityOn() # Camera camera = vtk.vtkCamera(); camera.SetPosition(camera_pos) camera.SetFocalPoint(0, 0, 0) # Add axes axes = vtk.vtkAxesActor() # Render the data ren = vtk.vtkRenderer() ren.AddActor(actor) ren.AddActor(axes) ren.SetActiveCamera(camera) # Create a render window renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(800, 800) # Start the visiuilization iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.SetBackground(0,0,0) renWin.Render() vtk.vtkPolyDataMapper().SetResolveCoincidentTopologyToPolygonOffset() if save_png is True: w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(renWin) w2if.Update() writer = vtk.vtkPNGWriter() writer.SetFileName(self.files['png']) writer.SetInputDataObject(w2if.GetOutput()) writer.Write() print('Wrote mesh image to: ' + self.files['png']) if interact is True: iren.Start()
def view_points_and_vectors(self, point_show=True, point_size=7.5, point_color=[1., 0., 0.], point_opacity=1., point_colorByScalar=False, point_scalar=[], normal_show=True, normal_length=0.3, normal_tip_radius=0.1, normal_scaleByPointScalar=False, normal_scale=1, normal_color=[0., 0., 1.], normal_opacity=1., normal_reverse=False, normal_arrowAtPoint=False, normal_colorByPointScalar=False, mesh_show=True, mesh_color=[1., 1., 1.], mesh_opacity=1, mesh_colorByScalar=False, mesh_scalar=[], camera_pos=[50,50,50], save_png=False, interact=True): '''Function to view the mesh using the VTK library. Allows for visualization of mesh, points (centroids), and normal vectors, as well as scalar fields. prior to scaling Parameters: point_show : bool Boolean operator that determines if the points are shown. point_size : float Size of points point_color : list, float VTK color specification for points [r,g,b]. point_opacity : float VTK opacity for the points. Must be between 0. and 1. point_colorByScalar : bool Boolean operator that determines if the points are colored by a scalar field 'point_scalar' rather than by constant 'point_color' point_scalar : np.array scalar value at each point. normal_show : bool Boolean operator that determines if the normals are shown. normal_length : float length of the arrows (glyphs) prior to scaling normal_tip_radius: float Tip radius of the arrows (glyphs) prior to scaling normal_scaleByPointScalar : bool Boolean operator that determines if the normal vectors are scaled by the scalar field 'point_scalar' normal_scale : float Value to scale the size of the normal glyphs by normal_color : list, float VTK color specification for the normals [r,g,b]. normal_opacity : float VTK opacity for the normals. Must be between 0. and 1. normal_reverse : bool Boolean operator that determines if the direction of the normal vectors is reversed normal_arrowAtPoint: bool Boolean operator that determines if the arrow is at the point or at the opposite edge of the glyph normal_colorByPointScalar : bool Boolean operator that determines if the normals are colored by a scalar field 'point_scalar' rather than by constant 'normal_color' mesh_show : bool Boolean operator that determines if the points are shown. mesh_color : list, float VTK color specification for the mesh [r,g,b]. mesh_opacity : float VTK opacity for the mesh. Must be between 0. and 1. mesh_colorByScalar : bool Boolean operator that determines if the mesh is colored by a scalar field 'mesh_scalar' rather than by a constant 'mesh_color' mesh_scalar : np.array scalar value at each mesh cell. camera_pos : list, floats Position of camera [X Y Z]. save_png : bool Boolean operater that determines if a .png image of the mesh is saved. interact : bool, optional Boolean operater that determines if the user can interact with the geometry (e.g. zoom and rotate) after it is displayed Examples: This example assumes that a mesh has been read by bemio and mesh data is contained in a `PanelMesh` object called `mesh` >>> mesh.view_points_and_vectors() The mesh view window must be closed in order to return command to the Python shell ''' if self.VTK_installed is False: raise VTK_Exception('VTK must be installed to use the view function') # Centroid centroid_points = vtk.vtkPoints() vertices = vtk.vtkCellArray() for ip in range(len(self.centroid)): id = centroid_points.InsertNextPoint(list(self.centroid[ip])) vertices.InsertNextCell(1) vertices.InsertCellPoint(id) centroid = vtk.vtkPolyData() centroid.SetPoints(centroid_points) centroid.SetVerts(vertices) n=np.array(list(self.normals.values())) nv = vtk.util.numpy_support.numpy_to_vtk(n) pv =centroid.GetPointData() _ = pv.SetNormals(nv) if point_colorByScalar or normal_colorByPointScalar: point_scalar = point_scalar.astype('double') vpoint_scalar = vtk.util.numpy_support.numpy_to_vtk(np.ascontiguousarray(point_scalar)) _ = pv.SetScalars(vpoint_scalar) point_scalarRange = centroid.GetScalarRange() centroid.Modified() centroidMapper=vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION >= 6: centroidMapper.SetInputData(centroid) else: centroidMapper.SetInput(centroid) if point_colorByScalar: centroidMapper.SetScalarModeToUsePointData centroidMapper.SetColorModeToMapScalars() centroidMapper.SetScalarRange(point_scalarRange) else: centroidMapper.SetColorModeToDefault() centroidMapper.SetScalarVisibility(0) centroidActor = vtk.vtkActor() centroidActor.SetMapper(centroidMapper) centroidActor.GetProperty().SetPointSize(point_size) centroidActor.GetProperty().SetOpacity(point_opacity) if not point_colorByScalar: centroidActor.GetProperty().SetColor(point_color) # Normals def MakeGlyphs(src, normal_reverse, normal_arrowAtPoint): reverse = vtk.vtkReverseSense() maskPts = vtk.vtkMaskPoints() maskPts.SetOnRatio(1) if normal_reverse: reverse.SetInputData(src) reverse.ReverseCellsOn() reverse.ReverseNormalsOn() maskPts.SetInputConnection(reverse.GetOutputPort()) else: maskPts.SetInputData(src) arrow = vtk.vtkArrowSource() if normal_arrowAtPoint: arrow.SetInvert(1) else: arrow.SetInvert(0) arrow.SetTipResolution(16) arrow.SetTipLength(normal_length) arrow.SetTipRadius(normal_tip_radius) glyph = vtk.vtkGlyph3D() glyph.SetSourceConnection(arrow.GetOutputPort()) glyph.SetInputConnection(maskPts.GetOutputPort()) glyph.SetVectorModeToUseNormal() glyph.SetScaleFactor(normal_scale) if normal_scaleByPointScalar: glyph.SetScaleModeToScaleByScalar() else: glyph.SetScaleModeToScaleByVector() glyph.SetColorModeToColorByScalar() glyph.OrientOn() return glyph glyph = MakeGlyphs(centroid,normal_reverse,normal_arrowAtPoint) glyphMapper = vtk.vtkPolyDataMapper() glyphMapper.SetInputConnection(glyph.GetOutputPort()) glyphActor = vtk.vtkActor() glyphActor.SetMapper(glyphMapper) glyphActor.GetProperty().SetOpacity(normal_opacity) if not normal_colorByPointScalar: glyphActor.GetProperty().SetColor(normal_color) if normal_colorByPointScalar: glyphMapper.SetScalarModeToUsePointData() glyphMapper.SetScalarVisibility(1) glyphMapper.SetColorModeToMapScalars() normal_scalarRange = centroid.GetScalarRange() glyphMapper.SetScalarRange(normal_scalarRange) else: glyphMapper.SetScalarVisibility(0) glyphMapper.SetColorModeToDefault() # Mesh if mesh_colorByScalar: cv = self.vtp_mesh.GetCellData() mesh_scalar = mesh_scalar.astype('double') vmesh_scalar = vtk.util.numpy_support.numpy_to_vtk(np.ascontiguousarray(mesh_scalar)) _ = cv.SetScalars(vmesh_scalar) meshMapper=vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION >= 6: meshMapper.SetInputData(self.vtp_mesh) else: meshMapper.SetInput(self.vtp_mesh) if mesh_colorByScalar: meshMapper.SetScalarModeToUseCellData meshMapper.SetColorModeToMapScalars() mesh_scalarRange = self.vtp_mesh.GetScalarRange() meshMapper.SetScalarRange(mesh_scalarRange) else: meshMapper.SetScalarVisibility(0) meshActor=vtk.vtkActor() meshActor.SetMapper(meshMapper) meshActor.GetProperty().EdgeVisibilityOn() meshActor.GetProperty().SetOpacity(mesh_opacity) if not mesh_colorByScalar: meshActor.GetProperty().SetColor(mesh_color) # bars if point_colorByScalar or normal_colorByPointScalar: lut = centroidMapper.GetLookupTable() lut.SetNumberOfTableValues(256) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.SetColorSpaceToDiverging() colorTransferFunction.AddRGBPoint(0,0.231373,0.298039,0.752941) colorTransferFunction.AddRGBPoint(0.5,0.865003,0.865003,0.865003) colorTransferFunction.AddRGBPoint(1.0,0.705882,0.0156863,0.14902) for ii,ss in enumerate([float(xx)/float(256) for xx in range(256)]): cc = colorTransferFunction.GetColor(ss) lut.SetTableValue(ii,cc[0],cc[1],cc[2],1.0) lut.Build() centroidMapper.SetLookupTable(lut) glyphMapper.SetLookupTable(lut) point_bar = vtk.vtkScalarBarActor() point_bar.SetLookupTable(lut) point_bar.SetTitle('Point Scalar') if mesh_colorByScalar: mesh_lut = meshMapper.GetLookupTable() mesh_lut.SetNumberOfTableValues(256) mesh_colorTransferFunction = vtk.vtkColorTransferFunction() mesh_colorTransferFunction.SetColorSpaceToDiverging() mesh_colorTransferFunction.AddRGBPoint(0,0.231373,0.298039,0.752941) mesh_colorTransferFunction.AddRGBPoint(0.5,0.865003,0.865003,0.865003) mesh_colorTransferFunction.AddRGBPoint(1.0,0.705882,0.0156863,0.14902) for ii,ss in enumerate([float(xx)/float(256) for xx in range(256)]): mesh_cc = mesh_colorTransferFunction.GetColor(ss) mesh_lut.SetTableValue(ii,mesh_cc[0],mesh_cc[1],mesh_cc[2],1.0) mesh_lut.Build() meshMapper.SetLookupTable(mesh_lut) mesh_bar = vtk.vtkScalarBarActor() mesh_bar.SetLookupTable(mesh_lut) mesh_bar.SetTitle('Mesh Scalar') # Camera camera = vtk.vtkCamera(); camera.SetPosition(camera_pos) camera.SetFocalPoint(0, 0, 0) # Add axes axes = vtk.vtkAxesActor() # Render the data ren = vtk.vtkRenderer() if mesh_show: ren.AddActor(meshActor) if point_show: ren.AddActor(centroidActor) if normal_show: ren.AddActor(glyphActor) ren.AddActor(axes) ren.SetActiveCamera(camera) ren.SetBackground(0,0,0) # Create a render window renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(800, 800) # Create interactive renderer iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Start the bar widgets if point_colorByScalar or normal_colorByPointScalar: point_bar_widget = vtk.vtkScalarBarWidget() point_bar_widget.SetInteractor(iren) point_bar_widget.SetScalarBarActor(point_bar) point_bar_widget.On() if mesh_colorByScalar: mesh_bar_widget = vtk.vtkScalarBarWidget() mesh_bar_widget.SetInteractor(iren) mesh_bar_widget.SetScalarBarActor(mesh_bar) mesh_bar_widget.On() # Render renWin.Render() vtk.vtkPolyDataMapper().SetResolveCoincidentTopologyToPolygonOffset() # Save image if save_png is True: w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(renWin) w2if.Update() writer = vtk.vtkPNGWriter() writer.SetFileName(self.files['png']) writer.SetInputDataObject(w2if.GetOutput()) writer.Write() print('Wrote mesh image to: ' + self.files['png']) # Set interaction mode if interact is True: iren.Start()
# camMatrix = camMatrix # Assume camera matrix has no offset # dims = (camMatrix[0,2] * 2, camMatrix[1,2]*2) # camera = vtktools.cameraFromMatrix(camMatrix, dims, (imgDims[0],imgDims[1])) # ren.SetActiveCamera(camera) camera = ren.GetActiveCamera() camera.SetPosition(camPos) camera.SetViewUp(camUpVector) camera.SetFocalPoint(camTargetPos) camera.SetViewAngle(fov) # Set camera to look forward from center w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(renWin) w2if.SetInputBufferTypeToRGBA() actors = {} poses = {} # https://stackoverflow.com/questions/19448078/python-opencv-access-webcam-maximum-resolution def set_res(cap, x, y): cap.set(cv2.CAP_PROP_FRAME_WIDTH, int(x)) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, int(y)) return int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int( cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
def main(filename="frame/f.png"): print(ocl.revision()) myscreen = camvtk.VTKScreen() myscreen.camera.SetPosition(-15, -8, 15) myscreen.camera.SetFocalPoint(5, 5, 0) # axis arrows camvtk.drawArrows(myscreen, center=(-1, -1, 0)) # screenshot writer w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(myscreen.renWin) lwr = vtk.vtkPNGWriter() lwr.SetInput(w2if.GetOutput()) c = ocl.CylCutter(2) # cutter c.length = 3 print("cutter length=", c.length) # generate CL-points stl = camvtk.STLSurf("../stl/demo.stl") polydata = stl.src.GetOutput() s = ocl.STLSurf() camvtk.vtkPolyData2OCLSTL(polydata, s) print("STL surface read,", s.size(), "triangles") print(s.getBounds()) #exit() minx = 0 dx = 0.1 / 6 maxx = 10 miny = 0 dy = 1 maxy = 10 z = -17 # this generates a list of CL-points in a grid clpoints = pyocl.CLPointGridZigZag(minx, dx, maxx, miny, dy, maxy, z) print("generated grid with", len(clpoints), " CL-points") # batchdropcutter bdc = ocl.BatchDropCutter() bdc.setSTL(s, 1) bdc.setCutter(c) for p in clpoints: bdc.appendPoint(p) t_before = time.time() print("threads=", bdc.nthreads) bdc.dropCutter4() t_after = time.time() calctime = t_after - t_before print(" done in ", calctime, " s") clpoints = bdc.getCLPoints() # filter print("filtering. before filter we have", len(clpoints), "cl-points") f = ocl.LineCLFilter() f.setTolerance(0.001) for p in clpoints: f.addCLPoint(p) f.run() clpts = f.getCLPoints() print("after filtering we have", len(clpts), "cl-points") #exit() # stupid init code f = ocl.Ocode() tree_maxdepth = 8 f.set_depth(tree_maxdepth) # depth and scale set here. f.set_scale(10) # cube stockvol = ocl.BoxOCTVolume() stockvol.corner = ocl.Point(0, 0, -0.5) stockvol.v1 = ocl.Point(10, 0, 0) stockvol.v2 = ocl.Point(0, 10, 0) stockvol.v3 = ocl.Point(0, 0, 3) stockvol.calcBB() #cube1.side=10.0 #cube1.center = ocl.Point(0,0,0) #cube1.calcBB() t_before = time.time() stock = ocl.LinOCT() stock.init(3) stock.build(stockvol) calctime = time.time() - t_before print(" stock built in ", calctime, " s, stock.size()=", stock.size()) # draw initial octree #tlist = pyocl.octree2trilist(stock) #surf = camvtk.STLSurf(triangleList=tlist) #myscreen.addActor(surf) # draw initial cutter #startp = ocl.Point(0,0,0) #cyl = camvtk.Cylinder(center=(startp.x,startp.y,startp.z), radius=c.radius, # height=c.length, # rotXYZ=(90,0,0), color=camvtk.grey) #cyl.SetWireframe() #myscreen.addActor(cyl) timetext = camvtk.Text() timetext.SetPos((myscreen.width - 300, myscreen.height - 30)) myscreen.addActor(timetext) ocltext = camvtk.Text() ocltext.SetPos((myscreen.width - 300, myscreen.height - 60)) myscreen.addActor(ocltext) ocltext.SetText("OpenCAMLib") octtext = camvtk.Text() octtext.SetPos((myscreen.width - 300, myscreen.height - 90)) myscreen.addActor(octtext) octtext.SetText("Octree cutting-simulation") infotext = camvtk.Text() infotext.SetPos((myscreen.width - 300, myscreen.height - 180)) myscreen.addActor(infotext) Nmoves = len(clpts) print(Nmoves, "CL-points to process") for n in range(0, Nmoves - 1): timetext.SetText(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")) #if n<Nmoves-1: print(n, " to ", n + 1) startp = clpts[n] # start of move endp = clpts[n + 1] # end of move t_before = time.time() sweep = ocl.LinOCT() sweep.init(0) calctime = time.time() - t_before print(" sweep-init done in ", calctime, " s, sweep.size()=", sweep.size()) g1vol = ocl.CylMoveOCTVolume(c, ocl.Point(startp.x, startp.y, startp.z), ocl.Point(endp.x, endp.y, endp.z)) t_before = time.time() sweep.build(g1vol) calctime = time.time() - t_before print(" sweep-build done in ", calctime, " s, sweep.size()=", sweep.size()) # draw cutter cyl1 = camvtk.Cylinder(center=(startp.x, startp.y, startp.z), radius=c.radius, height=c.length, rotXYZ=(90, 0, 0), color=camvtk.lgreen) cyl1.SetWireframe() #myscreen.addActor(cyl1) cyl2 = camvtk.Cylinder(center=(endp.x, endp.y, endp.z), radius=c.radius, height=c.length, rotXYZ=(90, 0, 0), color=camvtk.pink) cyl2.SetWireframe() #myscreen.addActor(cyl2) #camvtk.drawCylCutter(myscreen, c, startp) #camvtk.drawCylCutter(myscreen, c, endp) myscreen.addActor( camvtk.Line(p1=(startp.x, startp.y, startp.z), p2=(endp.x, endp.y, endp.z), color=camvtk.red)) #camvtk.drawTree2(myscreen,sweep,color=camvtk.red,opacity=0.5) t_before = time.time() stock.diff(sweep) calctime = time.time() - t_before print(" diff done in ", calctime, " s, stock.size()", stock.size()) info = "tree-depth:%i \nmove: %i \nstock-nodes: %i \nsweep-nodes: %i" % ( tree_maxdepth, n, stock.size(), sweep.size()) infotext.SetText(info) if (n % 1 == 0 or n == Nmoves - 2): # draw only every m:th frame # sweep surface t_before = time.time() #sweep_tlist = pyocl.octree2trilist(sweep) sweep_tlist = sweep.get_triangles() sweepsurf = camvtk.STLSurf(triangleList=sweep_tlist) sweepsurf.SetColor(camvtk.red) sweepsurf.SetOpacity(0.1) myscreen.addActor(sweepsurf) calctime = time.time() - t_before print(" sweepsurf-render ", calctime, " s") # stock surface t_before = time.time() #tlist = pyocl.octree2trilist(stock) tlist = stock.get_triangles() stocksurf = camvtk.STLSurf(triangleList=tlist) stocksurf.SetColor(camvtk.cyan) stocksurf.SetOpacity(1.0) myscreen.addActor(stocksurf) calctime = time.time() - t_before print(" stocksurf-render ", calctime, " s") #time.sleep(1.1) # write screenshot to disk lwr.SetFileName("frames/cutsim_frame" + ('%03d' % n) + ".png") #lwr.SetFileName(filename) t_before = time.time() # time the render process myscreen.render() w2if.Modified() lwr.Write() calctime = time.time() - t_before print(" render ", calctime, " s") #myscreen.render() #time.sleep(0.1) myscreen.removeActor(sweepsurf) if n != (Nmoves - 2): myscreen.removeActor(stocksurf) #myscreen.removeActor(cyl1) #myscreen.removeActor(cyl2) #myscreen.render() #time.sleep(0.1) print(" render()...", ) myscreen.render() print("done.") #time.sleep(0.2) myscreen.iren.Start()
def writeMovie(self): self.movie.Write() self.w = vtk.vtkWindowToImageFilter() self.w.SetInput(self.GetRenderWindow()) self.movie.SetInput(self.w.GetOutput())
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(256, 256) ren.SetBackground(0.0, 0.0, 0.0) ren.ResetCamera() camera = vtkCamera() #camera.SetPosition(128, 128, 128); #camera.SetFocalPoint(0, 0, -1); center = [128, 128, 128] camera.SetFocalPoint(center[0], center[1], center[2]) camera.SetPosition(center[0], center[1] - 512, center[2]) camera.SetViewUp(0, 0, -1) ren.SetActiveCamera(camera) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) for a in actors: # assign actor to the renderer ren.AddActor(a) # render # renWin.Render() # # Set up the camera # camera = ren.GetActiveCamera() # #center = volume.GetCenter() # camera.SetFocalPoint(128, 128, 128) # camera.SetPosition(128, 0, 128) # camera.SetViewUp(0, 0, -1) # enable user interface interactor # iren.Initialize() renWin.Render() # iren.Start() # Get the image vtk_win_im = vtk.vtkWindowToImageFilter() vtk_win_im.SetInput(renWin) vtk_win_im.Update() vtk_image = vtk_win_im.GetOutput() width, height, _ = vtk_image.GetDimensions() vtk_array = vtk_image.GetPointData().GetScalars() components = vtk_array.GetNumberOfComponents() img2d = vtk_to_numpy(vtk_array).reshape(height, width, components) # Close the render # render_window = iren.GetRenderWindow() # render_window.Finalize() # iren.GetRenderWindow().Finalize() # iren.TerminateApp() renWin.Finalize() # def close_window(iren): # render_window = iren.GetRenderWindow() # render_window.Finalize() # iren.TerminateApp() # #del render_window, iren # #import keyboard # #keyboard.write('E',delay=0) # close_window(iren) del renWin, iren return img2d
def View(self, filename): ''' Nastavení interaktoru pro pohyb s objektem. Třída vtkInteractorStyleTrackballCamera(), nám umožní nastavit na levé tlačítko myši funkce pohybu s vizualizovaným objektem a na pravé možnost zoomu ''' self.iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) ''' Nastavení readeru pro čtení vtk souboru v podobě nestrukturované mřížky ''' reader = vtk.vtkUnstructuredGridReader() reader.SetFileName(filename) reader.Update() ''' Jako filtr je použit objekt třídy vtkDataSetSurfaceFilter(), který nám z dat vyextrahuje vnější povrch ''' surface.SetInput(reader.GetOutput()) surface.Update() ''' Dále použijeme třídu vtkClipPolyData(), ta nám při pohybu roviny způsobí, že za ní bude nechávat pouze obrysy spojení buněk bez vyplnění povrchu, tím snadno poznáme kde jsme s rovinou po objektu již přejeli a kde ne ''' clipper = vtk.vtkClipPolyData() clipper.SetInput(surface.GetOutput()) clipper.SetClipFunction(plane) clipper.GenerateClippedOutputOn() clipMapper = vtk.vtkPolyDataMapper() clipMapper.SetInput(clipper.GetOutput()) clipActor = vtk.vtkActor() clipActor.SetMapper(clipMapper) mapper = vtk.vtkDataSetMapper() mapper.SetInput(surface.GetOutput()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().EdgeVisibilityOn() # nastavuje šířku linek ohraničující buňky actor.GetProperty().SetLineWidth(0.1) actor.GetProperty().SetRepresentationToWireframe() self.ren.AddActor(clipActor) self.ren.AddActor(actor) self.iren.Initialize() self.iren.Start() ''' Třídu vtkWindowToImageFilter použijeme pro uložení vizualizace z prohlížecího režimu ve formátu tif ''' try: w2i = vtk.vtkWindowToImageFilter() writer = vtk.vtkTIFFWriter() w2i.SetInput(self.renWin) w2i.Update() writer.SetInputConnection(w2i.GetOutputPort()) writer.SetFileName("image.tif") self.renWin.Render() writer.Write() self.renWin.Render() self.renWin.Finalize() except (AttributeError): print()
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()
def main(): SHOW_AXES = True SHOW_SCENE_AXES = True SHOW_COIL_AXES = True SHOW_SKIN = True SHOW_BRAIN = True SHOW_COIL = True SHOW_MARKERS = True TRANSF_COIL = True SHOW_PLANE = False SELECT_LANDMARKS = 'scalp' # 'all', 'mri' 'scalp' SAVE_ID = False AFFINE_IMG = True NO_SCALE = True SCREENSHOT = False reorder = [0, 2, 1] flipx = [True, False, False] # reorder = [0, 1, 2] # flipx = [False, False, False] # default folder and subject # subj = 's03' subj = 'EEGTA04' id_extra = False # 8, 9, 10, 12, False # data_dir = os.environ['OneDriveConsumer'] + '\\data\\nexstim_coord\\' data_dir = r'P:\tms_eeg\mTMS\projects\2019 EEG-based target automatization\Analysis\EEG electrode transformation' # filenames # coil_file = data_dir + 'magstim_fig8_coil.stl' coil_file = os.environ[ 'OneDrive'] + '\\data\\nexstim_coord\\magstim_fig8_coil.stl' if id_extra: coord_file = data_dir + 'ppM1_eximia_%s_%d.txt' % (subj, id_extra) else: coord_file = nav_dir + 'ppM1_eximia_%s.txt' % subj # img_file = data_subj + subj + '.nii' img_file = data_dir + 'mri\\ppM1_%s\\ppM1_%s.nii' % (subj, subj) brain_file = simnibs_dir + "wm.stl" skin_file = simnibs_dir + "skin.stl" if id_extra: output_file = nav_dir + 'transf_mat_%s_%d' % (subj, id_extra) else: output_file = nav_dir + 'transf_mat_%s' % subj coords = lc.load_nexstim(coord_file) # red, green, blue, maroon (dark red), # olive (shitty green), teal (petrol blue), yellow, orange col = [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.], [1., .0, 1.], [.5, .5, 0.], [0., .5, .5], [1., 1., 0.], [1., .4, .0]] # extract image header shape and affine transformation from original nifti file imagedata = nb.squeeze_image(nb.load(img_file)) imagedata = nb.as_closest_canonical(imagedata) imagedata.update_header() pix_dim = imagedata.header.get_zooms() img_shape = imagedata.header.get_data_shape() print("Pixel size: \n") print(pix_dim) print("\nImage shape: \n") print(img_shape) affine_aux = imagedata.affine.copy() if NO_SCALE: scale, shear, angs, trans, persp = tf.decompose_matrix( imagedata.affine) affine_aux = tf.compose_matrix(scale=None, shear=shear, angles=angs, translate=trans, perspective=persp) if AFFINE_IMG: affine = affine_aux # if NO_SCALE: # scale, shear, angs, trans, persp = tf.decompose_matrix(imagedata.affine) # affine = tf.compose_matrix(scale=None, shear=shear, angles=angs, translate=trans, perspective=persp) else: affine = np.identity(4) # affine_I = np.identity(4) # create a camera, render window and renderer camera = vtk.vtkCamera() camera.SetPosition(0, 1000, 0) camera.SetFocalPoint(0, 0, 0) camera.SetViewUp(0, 0, 1) camera.ComputeViewPlaneNormal() camera.Azimuth(90.0) camera.Elevation(10.0) ren = vtk.vtkRenderer() ren.SetActiveCamera(camera) ren.ResetCamera() camera.Dolly(1.5) ren_win = vtk.vtkRenderWindow() ren_win.AddRenderer(ren) ren_win.SetSize(800, 800) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(ren_win) if SELECT_LANDMARKS == 'mri': # MRI landmarks coord_mri = [['Nose/Nasion'], ['Left ear'], ['Right ear'], ['Coil Loc'], ['EF max']] pts_ref = [1, 2, 3, 7, 10] elif SELECT_LANDMARKS == 'all': # all coords coord_mri = [['Nose/Nasion'], ['Left ear'], ['Right ear'], ['Nose/Nasion'], ['Left ear'], ['Right ear'], ['Coil Loc'], ['EF max']] pts_ref = [1, 2, 3, 5, 4, 6, 7, 10] elif SELECT_LANDMARKS == 'scalp': # scalp landmarks coord_mri = [['Nose/Nasion'], ['Left ear'], ['Right ear'], ['Coil Loc'], ['EF max']] hdr_mri = [ 'Nose/Nasion', 'Left ear', 'Right ear', 'Coil Loc', 'EF max' ] pts_ref = [5, 4, 6, 7, 10] coords_np = np.zeros([len(pts_ref), 3]) for n, pts_id in enumerate(pts_ref): # to keep in the MRI space use the identity as the affine # coord_aux = n2m.coord_change(coords[pts_id][1:], img_shape, affine_I, flipx, reorder) # affine_trans = affine_I.copy() # affine_trans = affine.copy() # affine_trans[:3, -1] = affine[:3, -1] coord_aux = n2m.coord_change(coords[pts_id][1:], img_shape, affine, flipx, reorder) coords_np[n, :] = coord_aux [coord_mri[n].append(s) for s in coord_aux] if SHOW_MARKERS: marker_actor = add_marker(coord_aux, ren, col[n]) if id_extra: # compare coil locations in experiments with 8, 9, 10 and 12 mm shifts # MRI Nexstim space: 8, 9, 10, 12 mm coil locations # coord_others = [[122.2, 198.8, 99.7], # [121.1, 200.4, 100.1], # [120.5, 200.7, 98.2], # [117.7, 202.9, 96.6]] if AFFINE_IMG: # World space: 8, 9, 10, 12 mm coil locations coord_others = [ [-42.60270233154297, 28.266497802734378, 81.02450256347657], [-41.50270233154296, 28.66649780273437, 82.62450256347657], [-40.90270233154297, 26.766497802734378, 82.92450256347655], [-38.10270233154297, 25.16649780273437, 85.12450256347657] ] else: # MRI space reordered and flipped: 8, 9, 10, 12 mm coil locations coord_others = [[27.8, 99.7, 198.8], [28.9, 100.1, 200.4], [29.5, 98.2, 200.7], [32.3, 96.6, 202.9]] col_others = [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.], [0., 0., 0.]] for n, c in enumerate(coord_others): marker_actor = add_marker(c, ren, col_others[n]) print('\nOriginal coordinates from Nexstim: \n') [print(s) for s in coords] print('\nMRI coordinates flipped and reordered: \n') [print(s) for s in coords_np] print('\nTransformed coordinates to MRI space: \n') [print(s) for s in coord_mri] # coil location, normal vector and direction vector coil_loc = coord_mri[-2][1:] coil_norm = coords[8][1:] coil_dir = coords[9][1:] # creating the coil coordinate system by adding a point in the direction of each given coil vector # the additional vector is just the cross product from coil direction and coil normal vectors # origin of the coordinate system is the coil location given by Nexstim # the vec_length is to allow line creation with visible length in VTK scene vec_length = 75 p1 = coords[7][1:] p2 = [x + vec_length * y for x, y in zip(p1, coil_norm)] p2_norm = n2m.coord_change(p2, img_shape, affine, flipx, reorder) p2 = [x + vec_length * y for x, y in zip(p1, coil_dir)] p2_dir = n2m.coord_change(p2, img_shape, affine, flipx, reorder) coil_face = np.cross(coil_norm, coil_dir) p2 = [x - vec_length * y for x, y in zip(p1, coil_face.tolist())] p2_face = n2m.coord_change(p2, img_shape, affine, flipx, reorder) # Coil face unit vector (X) u1 = np.asarray(p2_face) - np.asarray(coil_loc) u1_n = u1 / np.linalg.norm(u1) # Coil direction unit vector (Y) u2 = np.asarray(p2_dir) - np.asarray(coil_loc) u2_n = u2 / np.linalg.norm(u2) # Coil normal unit vector (Z) u3 = np.asarray(p2_norm) - np.asarray(coil_loc) u3_n = u3 / np.linalg.norm(u3) transf_matrix = np.identity(4) if TRANSF_COIL: transf_matrix[:3, 0] = u1_n transf_matrix[:3, 1] = u2_n transf_matrix[:3, 2] = u3_n transf_matrix[:3, 3] = coil_loc[:] # the absolute value of the determinant indicates the scaling factor # the sign of the determinant indicates how it affects the orientation: if positive maintain the # original orientation and if negative inverts all the orientations (flip the object inside-out)' # the negative determinant is what makes objects in VTK scene to become black print('Transformation matrix: \n', transf_matrix, '\n') print('Determinant: ', np.linalg.det(transf_matrix)) if SAVE_ID: coord_dict = { 'm_affine': transf_matrix, 'coords_labels': hdr_mri, 'coords': coords_np } io.savemat(output_file + '.mat', coord_dict) hdr_names = ';'.join( ['m' + str(i) + str(j) for i in range(1, 5) for j in range(1, 5)]) np.savetxt(output_file + '.txt', transf_matrix.reshape([1, 16]), delimiter=';', header=hdr_names) if SHOW_BRAIN: if AFFINE_IMG: brain_actor = load_stl(brain_file, ren, colour=[0., 1., 1.], opacity=1.) else: # to visualize brain in MRI space brain_actor = load_stl(brain_file, ren, colour=[0., 1., 1.], opacity=1., user_matrix=np.linalg.inv(affine_aux)) if SHOW_SKIN: if AFFINE_IMG: skin_actor = load_stl(skin_file, ren, colour="SkinColor", opacity=.4) else: # to visualize skin in MRI space skin_actor = load_stl(skin_file, ren, colour="SkinColor", opacity=.4, user_matrix=np.linalg.inv(affine_aux)) if SHOW_COIL: # reposition STL object prior to transformation matrix # [translation_x, translation_y, translation_z, rotation_x, rotation_y, rotation_z] # old translation when using Y as normal vector # repos = [0., -6., 0., 0., -90., 90.] # Translate coil loc coordinate to coil bottom # repos = [0., 0., 5.5, 0., 0., 180.] repos = [0., 0., 0., 0., 0., 180.] act_coil = load_stl(coil_file, ren, replace=repos, user_matrix=transf_matrix, opacity=.3) if SHOW_PLANE: act_plane = add_plane(ren, user_matrix=transf_matrix) # Add axes to scene origin if SHOW_AXES: add_line(ren, [0, 0, 0], [150, 0, 0], color=[1.0, 0.0, 0.0]) add_line(ren, [0, 0, 0], [0, 150, 0], color=[0.0, 1.0, 0.0]) add_line(ren, [0, 0, 0], [0, 0, 150], color=[0.0, 0.0, 1.0]) # Add axes to object origin if SHOW_COIL_AXES: add_line(ren, coil_loc, p2_norm, color=[.0, .0, 1.0]) add_line(ren, coil_loc, p2_dir, color=[.0, 1.0, .0]) add_line(ren, coil_loc, p2_face, color=[1.0, .0, .0]) # Add interactive axes to scene if SHOW_SCENE_AXES: axes = vtk.vtkAxesActor() widget = vtk.vtkOrientationMarkerWidget() widget.SetOutlineColor(0.9300, 0.5700, 0.1300) widget.SetOrientationMarker(axes) widget.SetInteractor(iren) # widget.SetViewport(0.0, 0.0, 0.4, 0.4) widget.SetEnabled(1) widget.InteractiveOn() if SCREENSHOT: # screenshot of VTK scene w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(ren_win) w2if.Update() writer = vtk.vtkPNGWriter() writer.SetFileName("screenshot.png") writer.SetInput(w2if.GetOutput()) writer.Write() # Enable user interface interactor # ren_win.Render() ren.ResetCameraClippingRange() iren.Initialize() iren.Start()
def __init__(self, ren, runAsync=True, **kwargs): if ren in PVDisplay.instances: raise RuntimeError( f"A PVDisplay instance already exists for this renderer. Use PVDisplay.GetOrCreate() to avoid this error." ) super(PVDisplay, self).__init__(**kwargs) #must call super class init # regular vars self.pvs, self.renv, self.w2i = None, None, None #used for Jupyter kernel rendering self.master, self.renderers = None, [] #used for Dask rendering self.mode = 'Jupyter' self.tp = time.time() #time of latest render self.fps = 10.0 self.fpsOut = [] #FPS output ipywidgets; passed in from Jupyter self.intyld = [0.05, 0.01] #interaction yield--period and duration self.tiy = time.time() #time of last interaction yield # see if we can import Dask.distributed, then try guessing the render # mode based on the type of ren. Fallback to regular Jupyter rendering # otherwise try: import dask.distributed as distributed if (type(ren) == list and type(ren[0]) == distributed.actor.Actor): self.mode = 'Dask' else: self.mode = 'Jupyter' except ImportError: self.mode = 'Jupyter' if self.mode == 'Dask': self.renderers = ren self.master = [r for r in self.renderers if r.rank == 0][0] self.resolution = tuple( self.master.run(lambda self: list(self.renv.ViewSize), []).result()) cf = self.master.run(lambda self: list(self.renv.CameraFocalPoint), []).result() cp = self.master.run(lambda self: list(self.renv.CameraPosition), []).result() self.camf = (cf[0], cf[1], cf[2]) self.camp = (cp[0], cp[1], cp[2]) else: import paraview.simple as pvs self.pvs = pvs self.renv = ren self.resolution = tuple(self.renv.ViewSize) cf = self.renv.CameraFocalPoint cp = self.renv.CameraPosition self.camf = (cf[0], cf[1], cf[2]) self.camp = (cp[0], cp[1], cp[2]) import vtk from vtk import vtkWindowToImageFilter self.w2i = vtkWindowToImageFilter() self.w2i.ReadFrontBufferOff() self.w2i.ShouldRerenderOff() self.w2i.SetInput(self.renv.SMProxy.GetRenderWindow()) self.frameNum = 0 self.FRBufSz = 10 self.FRBuf = np.zeros(self.FRBufSz, dtype=np.float32) self.runAsync = runAsync if runAsync: self.renderThread = threading.Thread(target=self.__renderLoop) self.renderThread.start()
def keypress(self,obj,event): key = obj.GetKeyCode() if key =="1": xyview(self.ren, self.ren.GetActiveCamera(),self.cp,self.fp) elif key =="2": yzview(self.ren, self.ren.GetActiveCamera(),self.cp,self.fp) elif key =="3": xzview(self.ren, self.ren.GetActiveCamera(),self.cp,self.fp) elif key=="z": self.Zaspect=self.Zaspect*2 s,nl,axs=self.get_scale() if hasattr(self,'pointActor'): self.pointActor.SetScale(s) self.pointActor.Modified() if hasattr(self,'rActor'): self.rActor.SetScale(s) self.rActor.Modified() if hasattr(self,'fActor'): self.fActor.SetScale(s) self.fActor.Modified() if hasattr(self,'aActor'): self.aActor.SetScale(s) self.aActor.Modified() self.ren.RemoveActor(self.axisActor) self.axisActor = add_axis(self.ren,nl,axs) elif key=="x": self.Zaspect=self.Zaspect*0.5 s,nl,axs=self.get_scale() if hasattr(self,'pointActor'): self.pointActor.SetScale(s) if hasattr(self,'rActor'): self.rActor.SetScale(s) self.rActor.Modified() if hasattr(self,'fActor'): self.fActor.SetScale(s) self.fActor.Modified() if hasattr(self,'aActor'): self.aActor.SetScale(s) self.aActor.Modified() self.ren.RemoveActor(self.axisActor) self.axisActor = add_axis(self.ren,nl,axs) elif key=="c": self.Zaspect=1.0 s,_,_,=self.get_scale() if hasattr(self,'pointActor'): self.pointActor.SetScale(s) if hasattr(self,'rActor'): self.rActor.SetScale(s) self.rActor.Modified() if hasattr(self,'fActor'): self.fActor.SetScale(s) self.fActor.Modified() if hasattr(self,'aActor'): # self.fActor.SetScale(1,1,self.Zaspect) self.aActor.SetScale(s) self.aActor.Modified() self.ren.RemoveActor(self.axisActor) self.axisActor = add_axis(self.ren,self.limits,[1,1,1]) self.ren.ResetCamera() elif key=="i": im = vtk.vtkWindowToImageFilter() writer = vtk.vtkPNGWriter() im.SetInput(self.ui.vtkWidget._RenderWindow) im.Update() writer.SetInputConnection(im.GetOutputPort()) writer.SetFileName("Avg_aligned.png") writer.Write() print("Screen output saved to %s" %os.path.join(os.getcwd(),'Avg_aligned.png')) elif key=="a": flip_visible(self.axisActor) elif key == "o": flip_visible(self.outlineActor) elif key == "f": flip_colors(self.ren,self.axisActor) elif key=="l": self.get_input_data(None) self.ui.vtkWidget.update() self.ui.vtkWidget.setFocus()
def main(): print(ocl.revision()) myscreen = camvtk.VTKScreen() myscreen.camera.SetPosition(-8, -4, 25) myscreen.camera.SetFocalPoint(4.5, 6, 0) # axis arrows camvtk.drawArrows(myscreen, center=(-1, -1, 0)) camvtk.drawOCLtext(myscreen) octtext = camvtk.Text() octtext.SetPos((70, myscreen.height - 600)) myscreen.addActor(octtext) cltext = camvtk.Text() cltext.SetPos((70, myscreen.height - 100)) myscreen.addActor(cltext) stl = camvtk.STLSurf("../../stl/gnu_tux_mod.stl") #myscreen.addActor(stl) #stl.SetWireframe() stl.SetColor((0.5, 0.5, 0.5)) polydata = stl.src.GetOutput() s = ocl.STLSurf() camvtk.vtkPolyData2OCLSTL(polydata, s) print("STL surface read,", s.size(), "triangles") #angle = math.pi/4 radius = 0.4 length = 5 cutter = ocl.BallCutter(2 * radius, length) #cutter = ocl.CylCutter(2*radius, length) # generate CL-points minx = 0 dx = 0.1 / 0.4 maxx = 9 miny = 0 dy = cutter.getRadius() / 1.5 maxy = 12 z = -1 # this generates a list of CL-points in a grid clpoints = pyocl.CLPointGrid(minx, dx, maxx, miny, dy, maxy, z) # batchdropcutter bdc = ocl.BatchDropCutter() bdc.bucketSize = 7 bdc.setSTL(s) bdc.setCutter(cutter) #bdc.setThreads(1) # explicitly setting one thread is better for debugging for p in clpoints: bdc.appendPoint(p) t_before = time.time() bdc.run() t_after = time.time() calctime = t_after - t_before print(" BDC4 done in ", calctime, " s") dropcutter_time = calctime clpoints = bdc.getCLPoints() #camvtk.drawCLPointCloud(myscreen, clpoints) print(" clpts= ", len(clpoints)) myscreen.render() #myscreen.iren.Start() #exit() s = ocl.BallCutterVolume() #s = ocl.CylCutterVolume() #s.center = ocl.Point(-2.50,-0.6,0) s.radius = cutter.getRadius() s.length = cutter.getLength() # screenshot writer w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(myscreen.renWin) lwr = vtk.vtkPNGWriter() lwr.SetInput(w2if.GetOutput()) cp = ocl.Point(5, 5, -3) # center of octree #depths = [3, 4, 5, 6, 7, 8] max_depth = 7 root_scale = 7 t = ocl.Octree(root_scale, max_depth, cp) t.init(5) n = 0 # the frame number stockbox = ocl.PlaneVolume(1, 0, 0.1) t.diff_negative(stockbox) stockbox = ocl.PlaneVolume(0, 0, 8.9) t.diff_negative(stockbox) stockbox = ocl.PlaneVolume(1, 1, 0.1) t.diff_negative(stockbox) stockbox = ocl.PlaneVolume(0, 1, 11.9) t.diff_negative(stockbox) stockbox = ocl.PlaneVolume(1, 2, -0.5) t.diff_negative(stockbox) stockbox = ocl.PlaneVolume(0, 2, 3) t.diff_negative(stockbox) mc = ocl.MarchingCubes() print("mc()...", ) tris = mc.mc_tree(t) #.mc_triangles() print(" mc() got ", len(tris), " triangles") mc_surf = camvtk.STLSurf(triangleList=tris, color=camvtk.red) mc_surf.SetColor(camvtk.cyan) print(" STLSurf()...", ) myscreen.addActor(mc_surf) print("done.") cl = ocl.Point(0, 0, 5) cactors = camvtk.drawBallCutter(myscreen, cutter, cl) myscreen.render() #myscreen.iren.Start() #exit() myscreen.removeActor(mc_surf) renderinterleave = len(clpoints) / 100 step_time = 0 #render_time = 0 while (n < len(clpoints)): cl = ocl.Point(clpoints[n].x, clpoints[n].y, clpoints[n].z) s.setPos(cl) # move the cutter t_before = time.time() t.diff_negative(s) # subtract cutter from stock t_after = time.time() build_time = t_after - t_before step_time = step_time + build_time n = n + 1 if n < (len(clpoints) - renderinterleave): myscreen.removeActor(mc_surf) for c in cactors: myscreen.removeActor(c) if ((n % renderinterleave) == 0): cactors = camvtk.drawBallCutter(myscreen, cutter, cl) t_before = time.time() print("mc()...", ) tris = mc.mc_tree(t) #.mc_triangles() mc_time = time.time() - t_before print("done in ", mc_time, " s") print(" mc() got ", len(tris), " triangles") print(" STLSurf()...", ) t_before = time.time() mc_surf = camvtk.STLSurf(triangleList=tris, color=camvtk.red) #mc_surf.SetWireframe() mc_surf.SetColor(camvtk.cyan) myscreen.addActor(mc_surf) print("done.") print(" render()...", ) myscreen.render() render_time = time.time() - t_before myscreen.camera.Azimuth(0.1) lwr.SetFileName("frames/cutsim_d10_frame" + ('%06d' % n) + ".png") w2if.Modified() call_ms = step_time / renderinterleave print(renderinterleave, " diff() calls in", step_time, " = ", call_ms, " ms/call") infotext = "Octree max_depth=%i \nCL-point %i of %i \n%i CL-pts/frame\ndiff()-time: %1.3f s/CL-point\nmc()-time: %1.3f s/frame\nrender()-time: %1.3f s/frame\n%i Triangles" % ( max_depth, n, len(clpoints), renderinterleave, call_ms, mc_time, render_time, len(tris)) octtext.SetText(infotext) postext = "X: %f\nY: %f\nZ: %f" % (cl.x, cl.y, cl.z) cltext.SetText(postext) #lwr.Write() # uncomment to actually write files to disk print("done.") step_time = 0 #lwr.SetFileName("frames/mc8_frame"+ ('%06d' % n)+".png") #myscreen.camera.Azimuth( 2 ) #myscreen.render() #w2if.Modified() #lwr.Write() #mc_surf.SetWireframe() #print "sleep...", #time.sleep(1.02) #print "done." print(" clpts= ", len(clpoints)) print("All done.") myscreen.iren.Start()
def vtkcontourfgrid(cutMapper, pl3d_output, src_output, var_name, levels, snapshot_dir, plane_normal, scalarRange): # if not X_is_running(): # return #off-screen rendering #gfac = vtk.vtkGraphicsFactory #gfac.SetOffScreenOnlyMode(1) #gfac.SetUseMesaClasses(1) #im_fac = vtk.vtkImagingFactory #im_fac.SetUseMesaClasses(1) pl3d_output.GetPointData().SetActiveScalars(var_name) if (scalarRange == (0, 0)): #print scalarRange # this prevents zero values from setting colourbar scalarnump = VN.vtk_to_numpy( src_output.GetPointData().GetScalars(var_name)) minval = np.amin(scalarnump) try: if (minval >= 0.0): minval = np.amin(scalarnump[scalarnump > 0.0]) except Exception: pass maxval = np.amax(scalarnump) scalarRange = (minval, maxval) #print scalarRange #scalarRange =pl3d_output.GetPointData().GetScalars(var_name).GetRange() cutMapper.SetScalarRange(scalarRange) cutActor = vtk.vtkActor() cutActor.SetMapper(cutMapper) lut = vtk.vtkLookupTable() #MakeLUT() lut.SetNumberOfTableValues(levels) lut.SetHueRange(0.667, 0.0) lut.SetNanColor(1, 0, 0, 1) lut.Build() cutMapper.SetLookupTable(lut) scalarBar = vtk.vtkScalarBarActor() scalarBar.SetLookupTable(lut) scalarBar.SetTitle(var_name) # Add the actors to the renderer, set the background and size #ren.AddActor(outlineActor) #ren.AddActor(planeActor) # Create the RenderWindow, Renderer and both Actors ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetOffScreenRendering(1) #off-screen render renWin.AddRenderer(ren) #iren = vtk.vtkRenderWindowInteractor() #iren.SetRenderWindow(renWin) ren.AddActor(cutActor) ren.AddActor2D(scalarBar) ren.SetBackground(0, 0, 0) renWin.SetSize(2800, 1600) camera = vtk.vtkCamera() camera.SetPosition(plane_normal) ren.SetActiveCamera(camera) #zoom ren.ResetCamera() ren.GetActiveCamera().Zoom(0.9) ren.GetActiveCamera().Dolly(1.4) ren.ResetCameraClippingRange() #off-screen renWin.Render() win2im = vtk.vtkWindowToImageFilter() win2im.SetInput(renWin) win2im.Update() writer = vtk.vtkPNGWriter() writer.SetFileName(snapshot_dir + '.png') writer.SetInputConnection(win2im.GetOutputPort()) writer.Write()
xform.SetInputData(pd) xform.SetTransform(transform) # Rasterize through the renderer mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(xform.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(1, 0, 0) renWin.SetSize(50, 50) ren1.AddActor(actor) renWin.Render() renSource = vtk.vtkWindowToImageFilter() renSource.SetInput(renWin) renSource.Update() # This trick decouples the pipeline so that updates # do not affect the renSource. output = renSource.GetOutput() img = vtk.vtkImageData() img.DeepCopy(output) ren1.RemoveActor(actor) # Now process the test image. Smooth out the aliasing. # Next filter can only handle RGB extract = vtk.vtkImageExtractComponents() extract.SetInputData(img)
def main(argv): #Just get something working for testing... try: opts, args = getopt.getopt(argv, "hi:", ["ifile="]) except getopt.GetoptError as err: print 'tviewer.py -i <inputfile.vtk>' print(str(err)) for opt, arg in opts: if opt == '-h': print 'tviewer.py -i <inputfile.vtk>' sys.exit() elif opt in ("-i", "--ifile"): inputfile = arg print("Going to load and view ", inputfile) #Read data reader = vtk.vtkXMLImageDataReader() reader.SetFileName(inputfile) reader.Update() #lut = vtk.vtkLookupTable() #lut.SetNumberOfColors(65535) #lut.SetHueRange(0.0, 2.667) #lut.SetVectorMode(vtk.vtkScalarsToColors.MAGNITUDE) #lut.Build() #Setup offscreen rendering graphics_factory = vtk.vtkGraphicsFactory() graphics_factory.SetOffScreenOnlyMode(1) graphics_factory.SetUseMesaClasses(1) #imaging_factory = vtk.vtkImagingFactory() #imaging_factory.SetUseMesaClasses(1) #Get image from reader image = reader.GetOutput() #image.SetSpacing(1,1,1) #image.GetPointData().SetScalars(image.GetPointData().GetVectors()) #Compute Q Criterion for texture mapping vorticity = vtk.vtkGradientFilter() vorticity.SetInputData(image) vorticity.SetInputScalars(image.FIELD_ASSOCIATION_POINTS, "Velocity") vorticity.ComputeQCriterionOn() #vorticity.SetComputeGradient(0) vorticity.Update() #Generate contour for comparison c = vtk.vtkContourFilter() #c.SetValue(0,1128) c.SetValue(0, 450) image.GetPointData().SetScalars( vorticity.GetOutput().GetPointData().GetVectors("Q-criterion")) c.SetInputData(image) c.Update() contour = c.GetOutput() #contour.GetCellData().SetScalars(image.GetPointData().GetVectors("Velocity")) normals = vtk.vtkPolyDataNormals() normals.SetInputData(contour) normals.SetFeatureAngle(45) #? normals.Update() #print normals.GetOutput() mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(normals.GetOutput()) mapper.ScalarVisibilityOn() mapper.SetScalarRange(-1, 1) mapper.SetScalarModeToUsePointFieldData() mapper.ColorByArrayComponent("Velocity", 0) #print image #print contour #mapper.SelectColorArray("Q-criterion") #mapper.SetLookupTable(lut) #print mapper actor = vtk.vtkActor() actor.SetMapper(mapper) ren = vtk.vtkRenderer() ren.AddActor(actor) ren.SetBackground(1, 1, 1) ren.ResetCamera() renWin = vtk.vtkRenderWindow() renWin.SetSize(400, 400) renWin.SetOffScreenRendering(1) renWin.AddRenderer(ren) renWin.Render() windowToImageFilter = vtk.vtkWindowToImageFilter() windowToImageFilter.SetInput(renWin) windowToImageFilter.Update() w = vtk.vtkPNGWriter() w.SetFileName("cube.png") w.SetInputConnection(windowToImageFilter.GetOutputPort()) w.Write()
# ren.SetActiveCamera(camera2) # camera2.SetFocalPoint(0.0, 0.0, 0.0) # camera2.SetPosition(0.0, 0.0, 50.0) # print camera2.GetPosition() # print camera2.GetFocalPoint() # print camera2.GetViewUp() # print camera2.GetViewAngle() # print camera2.GetClippingRange() # print camera2.GetEyeAngle() # print volume.GetBounds() # (0.0, 255.0, 0.0, 255.0, 0.0, 255.0) ren.AddVolume(volume) ren.SetBackground(0, 0, 0) renWin = vtk.vtkRenderWindow() # iren = vtk.vtkRenderWindowInteractor() # iren.SetRenderWindow(renWin) renWin.SetSize(600, 600) renWin.AddRenderer(ren) renWin.Render() window_2_image = vtk.vtkWindowToImageFilter() window_2_image.SetInput(renWin) window_2_image.Update() png_writer = vtk.vtkBMPWriter() png_writer.SetFileName(dst + '%05d' % (i) + '.bmp') png_writer.SetInput(window_2_image.GetOutput()) png_writer.Write() # iren.Initialize() # iren.Start() print i i += 1
def render_volume(data, savepath=None, white=True, use_outline=False): """Renders three-dimensional visualization of the given array. Transparency options should be customized to cut background and show only relevant parts of the sample. Sample can also be visualized with different RGB colors based on gray values. Data mapper should be selected accordingly. vtkSmartVolumeMapper uses GPU for accelerated rendering if possible, vtkFixedPointVolumeRayCastMapper is maybe more reliable at some cases but slower. Viewing angle should also be customized to visualize sample well during the screenshot. Parameters ---------- data : 3d numpy array Input array that is going to be visualized savepath : str Full file name for the saved image. If not given, data can be interactively visualized. Example: C:/path/rendering.png white : bool Choose whether to have white or black background. Defaults to white. use_outline : bool Choose whether to use an outline to show data extent. """ # Input data as uint8 data_matrix = np.uint8(data) dims = np.shape(data) # Store data as VTK images data_importer = vtk.vtkImageImport() # Array is converted to a string of chars and imported. data_string = data_matrix.tostring() data_importer.CopyImportVoidPointer(data_string, len(data_string)) # Set type to unsigned char (uint8) data_importer.SetDataScalarTypeToUnsignedChar() # Data contains only gray values (not RGB) data_importer.SetNumberOfScalarComponents(1) # Data storing dimensions data_importer.SetDataExtent(0, dims[2] - 1, 0, dims[1] - 1, 0, dims[0] - 1) data_importer.SetWholeExtent(0, dims[2] - 1, 0, dims[1] - 1, 0, dims[0] - 1) # Gray value transparency (this can be modified for different samples) alpha_channel = vtk.vtkPiecewiseFunction() alpha_channel.AddPoint(0, 0.0) alpha_channel.AddPoint(70, 0.0) alpha_channel.AddPoint(80, 0.1) alpha_channel.AddPoint(100, 0.2) alpha_channel.AddPoint(150, 0.9) # Possibility to use RGB colors. color_transfer = vtk.vtkColorTransferFunction() color_transfer.AddRGBPoint(50, 0.0, 0.0, 0.0) color_transfer.AddRGBPoint(100, 0.5, 0.5, 0.5) if white: color_transfer.AddRGBPoint(255, 0.7, 0.7, 0.7) else: color_transfer.AddRGBPoint(255, 1.0, 1.0, 1.0) # Apply transparency and colors to volume volume_property = vtk.vtkVolumeProperty() volume_property.SetColor(color_transfer) volume_property.SetScalarOpacity(alpha_channel) # Create volume mapper and specify data to volume # mapper = vtk.vtkFixedPointVolumeRayCastMapper() mapper = vtk.vtkSmartVolumeMapper() mapper.SetInputConnection(data_importer.GetOutputPort()) # Create actual volume. Set mapper and properties volume = vtk.vtkVolume() volume.SetMapper(mapper) volume.SetProperty(volume_property) # Create renderer and render window renderer = vtk.vtkRenderer() render_window = vtk.vtkRenderWindow() render_window.AddRenderer(renderer) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(render_window) # Set outline if use_outline: outline = vtk.vtkOutlineFilter() outline.SetInputConnection(data_importer.GetOutputPort()) mapper2 = vtk.vtkPolyDataMapper() mapper2.SetInputConnection(outline.GetOutputPort()) actor2 = vtk.vtkActor() actor2.SetMapper(mapper2) renderer.AddActor(actor2) # Set background color if white: renderer.SetBackground(1, 1, 1) else: renderer.SetBackground(0, 0, 0) # Rotate volume w = vtk.vtkTransform() w.RotateZ(45) volume.SetUserTransform(w) # Add volume to renderer renderer.AddVolume(volume) # Camera options renderer.GetActiveCamera().SetPosition(0, -0.5, -0.5) #renderer.GetActiveCamera().Azimuth(-110) #renderer.GetActiveCamera().Elevation(-170) renderer.ResetCameraClippingRange() renderer.ResetCamera() # # Camera options # camera = vtk.vtkCamera() # camera.SetPosition(0.5, 1, 0) # camera.SetFocalPoint(0, 0.5, 0.5) # camera.SetViewUp(1, 0, 1) # renderer.SetActiveCamera(camera) # renderer.ResetCamera() # 2nd set of options # camera = vtk.vtkCamera() # camera.SetPosition(0.5, 1, 0) # camera.SetFocalPoint(0, 0.5, 0.5) # camera.SetViewUp(1, 0, 1) # renderer.SetActiveCamera(camera) # renderer.ResetCamera() # Window size render_window.SetSize(600, 600) # Application quit def exit_check(obj, event): if obj.GetEventPending() != 0: obj.SetAbortRender(1) # Tell the application to use the function as an exit check. render_window.AddObserver("AbortCheckEvent", exit_check) interactor.Initialize() render_window.Render() if savepath: # Take a screenshot path = savepath.rsplit('/', 1)[0] if not os.path.exists(path): os.makedirs(path, exist_ok=True) img = vtk.vtkWindowToImageFilter() img.SetInput(render_window) img.Update() writer = vtk.vtkPNGWriter() print('Saved to: ' + savepath) writer.SetFileName(str(savepath)) writer.SetInputData(img.GetOutput()) writer.Write() return else: # Run the window with user interactions interactor.Start()
import vtk def cb(interactor, event): global plane_actor plane_actor.RotateZ(0.1) ren = vtk.vtkRenderer() windowToImageFilter = vtk.vtkWindowToImageFilter() iren = vtk.vtkRenderWindowInteractor() moviewriter = vtk.vtkOggTheoraWriter() class MyInteractorStyle(vtk.vtkInteractorStyleTrackballCamera): def __init__(self, parent=None): self.AddObserver("MiddleButtonPressEvent", self.middleButtonPressEvent) self.AddObserver("MiddleButtonReleaseEvent", self.middleButtonReleaseEvent) def middleButtonPressEvent(self, obj, event): print("Middle Button pressed") t = ren.GetActiveCamera() for i in range(360): t.Azimuth(1) iren.GetRenderWindow().Render() windowToImageFilter.Modified() moviewriter.Write() self.OnMiddleButtonDown() return
def gen_shot(vtk_filename, png_filename): """ Generate PNG image of the FE mesh. Parameters ---------- vtk_filename : str The input mesh filename (file in VTK format). png_filename : str The name of the output PNG file. """ reader = vtk.vtkUnstructuredGridReader() reader.SetFileName(vtk_filename) reader.Update() bnd = reader.GetOutput().GetPoints().GetBounds() surface0 = vtk.vtkDataSetSurfaceFilter() surface0.SetInput(reader.GetOutput()) surface0.Update() if abs(bnd[5] - bnd[4]) > 1.0e-12: tr = vtk.vtkTransform() tr.RotateWXYZ(45, 1, 1, 1) trFilter = vtk.vtkTransformPolyDataFilter() trFilter.SetTransform(tr) trFilter.SetInputConnection(surface0.GetOutputPort()) trFilter.Update() surface = trFilter else: surface = surface0 ca, cb = surface.GetOutput().GetCellData().GetScalars().GetRange() lut = vtk.vtkLookupTable() lut.SetHueRange(0.667, 0.667) lut.SetSaturationRange(0.0, 1.0) lut.SetValueRange(0.8, 1.0) lut.SetAlphaRange(1.0, 1.0) lut.SetTableRange(ca, cb) gf = vtk.vtkGraphicsFactory() gf.SetOffScreenOnlyMode(1) gf.SetUseMesaClasses(1) ifa = vtk.vtkImagingFactory() ifa.SetUseMesaClasses(1) mapper = vtk.vtkPolyDataMapper() mapper.SetLookupTable(lut) mapper.SetScalarRange(ca, cb) mapper.SetInput(surface.GetOutput()) mapper.SetScalarModeToUseCellData() actor = vtk.vtkActor() actor.SetMapper(mapper) mapper2 = vtk.vtkPolyDataMapper() mapper2.SetInput(surface.GetOutput()) actor2 = vtk.vtkActor() actor2.SetMapper(mapper2) actor2.GetProperty().SetRepresentationToWireframe() ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetOffScreenRendering(1) renWin.AddRenderer(ren) ren.AddActor(actor) ren.AddActor(actor2) renWin.Render() image = vtk.vtkWindowToImageFilter() image.SetInput(renWin) image.Update() base, _ = os.path.splitext(vtk_filename) writer = vtk.vtkPNGWriter() writer.SetFileName(png_filename) writer.SetInput(image.GetOutput()) writer.Write()
# renderer.AddActor(actory) # renderer.AddActor(actorz) renderer.AddActor(tubeActor) #renderer.RemoveAllViewProps() renderer.SetBackground(0.1, 0.1, 0.1) # Background color renderer.SetAmbient(.4, .4, .4) #renderer.TwoSidedLightingOff() #renderer.LightFollowCameraOff() renderer.AddLight(light1) renderer.AddLight(light2) renderer.AddLight(light3) renderWindow.Render() vtkwin_im = vtk.vtkWindowToImageFilter() vtkwin_im.SetInput(renderWindow) vtkwin_im.Update() vtk_image = vtkwin_im.GetOutput() height, width, _ = vtk_image.GetDimensions() vtk_array = vtk_image.GetPointData().GetScalars() components = vtk_array.GetNumberOfComponents() arr = vtk_to_numpy(vtk_array).reshape(height, width, components) """ vrml_exporter = vtk.vtkVRMLExporter() vrml_exporter.SetInput(renderWindow) vrml_exporter.SetFileName('test.wrl') vrml_exporter.Write() obj_exporter = vtk.vtkOBJExporter()
def view_patch_vtk(r, azimuth=90, elevation=0, roll=-90, outfile=0, show=1): c = r.vColor ro = r r = createPolyData(r.vertices, r.faces) Colors = vtkUnsignedCharArray() Colors.SetNumberOfComponents(3) Colors.SetName("Colors") for i in range(len(ro.vertices)): Colors.InsertNextTuple3(255 * c[i, 0], 255 * c[i, 1], 255 * c[i, 2]) r.GetPointData().SetScalars(Colors) r.Modified() # ## r.Update() # mapper mapper = vtkPolyDataMapper() if VTK_MAJOR_VERSION <= 5: mapper.SetInput(r) else: # mapper.SetInputConnection(r.GetOutputPort()) mapper.SetInputData(r) actor = vtkActor() actor.SetMapper(mapper) # actor.GetProperty().SetInterpolationToPhong() normals = vtkPolyDataNormals() normals.SetInputData(r) normals.ComputePointNormalsOn() normals.ComputeCellNormalsOn() # normals.SplittingOff() normals.AutoOrientNormalsOn() normals.ConsistencyOn() #normals.SetFeatureAngle(4.01) normals.Update() mapper.SetInputData(normals.GetOutput()) ren = vtkRenderer() ren.TwoSidedLightingOff() renWin = vtkRenderWindow() renWin.SetSize(1600, 1600) # renWin.SetDPI(200) if show == 0: renWin.SetOffScreenRendering(1) renWin.AddRenderer(ren) # create a renderwindowinteractor iren = vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.SetBackground(256.0 / 256, 256.0 / 256, 256.0 / 256) ren.AddActor(actor) # enable user interface interactor iren.Initialize() renWin.Render() ren.GetActiveCamera().Azimuth(azimuth) ren.GetActiveCamera().Elevation(elevation) ren.GetActiveCamera().Roll(roll) renWin.Render() # windowToImageFilter->SetInput(renderWindow); # windowToImageFilter->SetMagnification(3); //set the resolution of the output image (3 times the current resolution of vtk render window) # windowToImageFilter->SetInputBufferTypeToRGBA(); //also record the alpha (transparency) channel # windowToImageFilter->ReadFrontBufferOff(); // read from the back buffer # windowToImageFilter->Update(); if outfile != 0: w2i = vtkWindowToImageFilter() writer = vtkPNGWriter() # iren.SetDPI(200) w2i.SetInput(renWin) w2i.SetInputBufferTypeToRGBA() w2i.ReadFrontBufferOff() w2i.Update() writer.SetInputData(w2i.GetOutput()) writer.SetFileName(outfile) iren.Render() writer.Write() image = Image.open(outfile) image.load() # imageSize = image.size imageBox = image.getbbox() print(image.getbbox()) cropped = image.crop(imageBox) print(cropped.getbbox()) cropped.save(outfile) if show != 0: iren.Start() close_window(iren) del renWin, iren