def write_image(self, filename="image.png", magnification=1, image_format="png"): """ Save render window to an image. Arguments: filename: filename to save to. Defaults to image.png. magnification: magnification. Use it to render high res images. image_format: choose between jpeg, png. Png is the default. """ render_large = vtk.vtkRenderLargeImage() render_large.SetInput(self.ren) if image_format == "jpeg": writer = vtk.vtkJPEGWriter() writer.SetQuality(80) else: writer = vtk.vtkPNGWriter() render_large.SetMagnification(magnification) writer.SetFileName(filename) writer.SetInputConnection(render_large.GetOutputPort()) self.ren_win.Render() writer.Write() del render_large
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkRenderLargeImage(), 'Processing.', (), ('vtkImageData',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def takeSimShot(self, fileName): # print MODULENAME,' takeSimShot: fileName=',fileName # DON'T REMOVE! # Better quality # Passes vtkRenderer. Takes actual screenshot of the region within the widget window # If other application are present within this region it will shoot them also renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(self.graphicsFrameWidget.ren) renderLarge.SetMagnification(1) # We write out the image which causes the rendering to occur. If you # watch your screen you might see the pieces being rendered right # after one another. # writer = vtk.vtkPNGWriter() writer = vtk.vtkPNGWriter() writer.SetInputConnection(renderLarge.GetOutputPort()) print MODULENAME,"takeSimShot(): vtkPNGWriter, fileName=",fileName writer.SetFileName(fileName) print 'TRYING TO WRITE ',fileName writer.Write() print 'WROTE ',fileName
def write_picture(self, magnify, fname): ren = self.getRenderer() assert ren is not None renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(ren) renderLarge.SetMagnification(magnify) rotation = 'x' self.set_rotation(rotation) lfname = fname.lower() if lfname.endswith('.png'): writer = vtk.vtkPNGWriter() elif lfname.endswith('.jpeg'): writer = vtk.vtkJPEGWriter() elif lfname.endswith('.tiff'): writer = vtk.vtkTIFFWriter() elif lfname.endswith('.ps'): writer = vtk.vtkPostScriptWriter() else: writer = vtk.vtkPNGWriter() writer.SetInput(renderLarge.GetOutput()) writer.SetFileName(fname) writer.Write()
def writeLargeFrame( myscreen, w2if, lwr, n , zoom=1): renderlarge = vtk.vtkRenderLargeImage() renderlarge.SetInput( myscreen.ren ) renderlarge.SetMagnification(zoom) writer = vtk.vtkPNGWriter() writer.SetFileName("large_frame.png") writer.SetInputConnection( renderlarge.GetOutputPort() ) writer.Write() print "Wrote large frame!"
def OnExportPicture(self, pubsub_evt): Publisher.sendMessage('Begin busy cursor') view_prop_list = [] for slice_data in self.slice_data_list: view_prop_list.append(slice_data.box_actor) self.ren.RemoveViewProp(slice_data.box_actor) id, filename, filetype = pubsub_evt.data dict = {"AXIAL": const.AXIAL, "CORONAL": const.CORONAL, "SAGITAL": const.SAGITAL} if id == dict[self.orientation]: if filetype == const.FILETYPE_POV: renwin = self.interactor.GetRenderWindow() image = vtk.vtkWindowToImageFilter() image.SetInput(renwin) writer = vtk.vtkPOVExporter() writer.SetFilePrefix(filename.split(".")[0]) writer.SetRenderWindow(renwin) writer.Write() else: ren = self.slice_data.renderer #Use tiling to generate a large rendering. image = vtk.vtkRenderLargeImage() image.SetInput(ren) image.SetMagnification(1) image.Update() image = image.GetOutput() # write image file if (filetype == const.FILETYPE_BMP): writer = vtk.vtkBMPWriter() elif (filetype == const.FILETYPE_JPG): writer = vtk.vtkJPEGWriter() elif (filetype == const.FILETYPE_PNG): writer = vtk.vtkPNGWriter() elif (filetype == const.FILETYPE_PS): writer = vtk.vtkPostScriptWriter() elif (filetype == const.FILETYPE_TIF): writer = vtk.vtkTIFFWriter() filename = "%s.tif"%filename.strip(".tif") writer.SetInputData(image) writer.SetFileName(filename) writer.Write() for actor in view_prop_list: self.ren.AddViewProp(actor) Publisher.sendMessage('End busy cursor')
def takeSimShot(self, fileName): renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(self.graphicsFrameWidget.ren) renderLarge.SetMagnification(1) # We write out the image which causes the rendering to occur. If you # watch your screen you might see the pieces being rendered right # after one another. writer = vtk.vtkPNGWriter() writer.SetInputConnection(renderLarge.GetOutputPort()) # # # print "GOT HERE fileName=",fileName writer.SetFileName(fileName) writer.Write()
def WritePNG(ren, fn, magnification = 1): ''' Save the image as a PNG :param: ren - the renderer. :param: fn - the file name. :param: magnification - the magnification, usually 1. ''' renLgeIm = vtk.vtkRenderLargeImage() imgWriter = vtk.vtkPNGWriter() renLgeIm.SetInput(ren) renLgeIm.SetMagnification(magnification) imgWriter.SetInputConnection(renLgeIm.GetOutputPort()) imgWriter.SetFileName(fn) imgWriter.Write()
def key_press(obj,event): key = obj.GetKeySym() if key=='s' or key=='S': print('Saving image...') renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(ren) renderLarge.SetMagnification(png_magnify) renderLarge.Update() writer = vtk.vtkPNGWriter() writer.SetInputConnection(renderLarge.GetOutputPort()) writer.SetFileName('fvtk.png') writer.Write() print('Look for fvtk.png in your current dir.')
def WritePNG(ren, fn, magnification=1): """ Save the image as a PNG :param: ren - the renderer. :param: fn - the file name. :param: magnification - the magnification, usually 1. """ renLgeIm = vtk.vtkRenderLargeImage() imgWriter = vtk.vtkPNGWriter() renLgeIm.SetInput(ren) renLgeIm.SetMagnification(magnification) imgWriter.SetInputConnection(renLgeIm.GetOutputPort()) imgWriter.SetFileName(fn) imgWriter.Write()
def on_take_screenshot(self, fname=None, magnify=None, show_msg=True): """ Take a screenshot of a current view and save as a file Parameters ---------- fname : str; default=None None : pop open a window str : bypass the popup window magnify : int; default=None None : use self.settings.magnify int : resolution increase factor show_msg : bool; default=True log the command TODO: screenshot doesn't work well with the coordinate system text size """ fname, flt = self._get_screenshot_filename(fname) if not fname: return render_large = vtk.vtkRenderLargeImage() render_large.SetInput(self.rend) out = self._screenshot_setup(magnify, render_large) line_widths0, point_sizes0, coord_scale0, axes_actor, magnify = out nam, ext = os.path.splitext(fname) ext = ext.lower() for nam, exts, obj in (('PostScript', ['.ps'], vtk.vtkPostScriptWriter), ("BMP", ['.bmp'], vtk.vtkBMPWriter), ('JPG', ['.jpg', '.jpeg'], vtk.vtkJPEGWriter), ("TIFF", ['.tif', '.tiff'], vtk.vtkTIFFWriter)): if flt == nam: fname = fname if ext in exts else fname + exts[0] writer = obj() break else: fname = fname if ext == '.png' else fname + '.png' writer = vtk.vtkPNGWriter() writer.SetInputConnection(render_large.GetOutputPort()) writer.SetFileName(fname) writer.Write() #self.log_info("Saved screenshot: " + fname) if show_msg: self.gui.log_command('on_take_screenshot(%r, magnify=%s)' % (fname, magnify)) self._screenshot_teardown(line_widths0, point_sizes0, coord_scale0, axes_actor)
def WritePMG(ren, fn, magnification=1): """ Save the image as a PNG :param ren: The renderer. :param fn: The file name. :param magnification: The magnification, usually 1. """ renLgeIm = vtk.vtkRenderLargeImage() imgWriter = vtk.vtkPNGWriter() renLgeIm.SetInput(ren) renLgeIm.SetMagnification(magnification) imgWriter.SetInputConnection(renLgeIm.GetOutputPort()) imgWriter.SetFileName(fn) imgWriter.Write()
def key_press(obj, event): key = obj.GetKeySym() if key == 's' or key == 'S': print('Saving image...') renderLarge = vtk.vtkRenderLargeImage() if vtk.VTK_MAJOR_VERSION <= 5: renderLarge.SetInput(renderer) else: renderLarge.SetInputData(renderer) renderLarge.SetMagnification(png_magnify) renderLarge.Update() writer = vtk.vtkPNGWriter() writer.SetInputConnection(renderLarge.GetOutputPort()) writer.SetFileName('trimesh_save.png') writer.Write() print('Look for trimesh_save.png in your current working directory.')
def exportScreenshot(self, filename): """ Save screenshot of the render window into a PNG file. @param filename: the name of the file @type filename: str """ self.updateRenderWindow() w2i = vtk.vtkRenderLargeImage() writer = vtk.vtkPNGWriter() w2i.SetMagnification(2) w2i.SetInput(self.renderer) w2i.Update() writer.SetInputConnection(w2i.GetOutputPort()) writer.SetFileName(filename) writer.Write()
def key_press(obj, event): key = obj.GetKeySym() if key == 's' or key == 'S': print('Saving image...') renderLarge = vtk.vtkRenderLargeImage() if vtk.VTK_MAJOR_VERSION <= 5: renderLarge.SetInput(renderer) else: renderLarge.SetInputData(renderer) renderLarge.SetMagnification(png_magnify) renderLarge.Update() writer = vtk.vtkPNGWriter() writer.SetInputConnection(renderLarge.GetOutputPort()) writer.SetFileName('trimesh_save.png') writer.Write() print('Look for trimesh_save.png in your current directory.')
def save_image(renderer, step): #Camera set Up renderer.GetActiveCamera().SetPosition(-105, 95, 110) renderer.GetActiveCamera().SetFocalPoint(0, 0, 0) renderer.GetActiveCamera().SetViewUp(0, 0, 1) renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(renderer) #Size of the output image, will change the brightness due to rendering issues renderLarge.SetMagnification(1) writer = vtk.vtkPNGWriter() writer.SetInputConnection(renderLarge.GetOutputPort()) directory = "./rendered_images/" if not os.path.exists(directory): os.makedirs(directory) writer.SetFileName("./rendered_images/" + str(step) + ".png") writer.Write()
def write_png(self, filename=None): large = vtk.vtkRenderLargeImage() large.SetInput(self.ren) large.SetMagnification(3) png = vtk.vtkPNGWriter() count = 0 if filename is None: files = glob.glob('image*.png') if len(files) > 0: numbers = [int (re.sub(r'image(\d+)\.png', r'\1', f)) for f in files] count = max(numbers) + 1 filename = 'image{:0>4}.png'.format(count) png.SetFileName(filename) png.SetInputConnection(large.GetOutputPort()) png.Write()
def WritePNG(ren, fn, magnification=1): ''' Save the image as a PNG :param: ren - the renderer. :param: fn - the file name. :param: magnification - the magnification, usually 1. ''' #renLgeIm = vtk.vtkWindowToImageFilter() renLgeIm = vtk.vtkRenderLargeImage() renLgeIm.SetInput(ren) renLgeIm.SetMagnification(magnification) #renLgeIm.SetInputBufferTypeToRGBA() #renLgeIm.ReadFrontBufferOff() #renLgeIm.Update() imgWriter = vtk.vtkPNGWriter() imgWriter.SetInputConnection(renLgeIm.GetOutputPort()) imgWriter.SetFileName(fn) imgWriter.Write()
def SaveAsBMP(self,filename,resolution=1): """Saves the window as bmp-file. Resolution is an integer representing the number of squares that the window is divided into when writing to the bmp-file. Thus choosing a higher number improves the quality of the saved image. """ from vtk import vtkRenderLargeImage,vtkBMPWriter #self.UpdateLight() renderLarge = vtkRenderLargeImage() renderLarge.SetInput(self.GetRenderer()) renderLarge.SetMagnification(resolution) writer = vtkBMPWriter() writer.SetFileName(filename) writer.SetInput(renderLarge.GetOutput()) writer.Write()
def screenshot(filename="screenshot.png", scale=None): """ Save a screenshot of the current rendering window. """ if not settings.plotter_instance or not settings.plotter_instance.window: colors.printc( '~bomb screenshot(): Rendering window is not present, skip.', c=1) return if scale is None: scale = settings.screeshotScale if settings.screeshotLargeImage: w2if = vtk.vtkRenderLargeImage() w2if.SetInput(settings.plotter_instance.renderer) w2if.SetMagnification(scale) else: w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(settings.plotter_instance.window) w2if.SetScale(scale, scale) if settings.screenshotTransparentBackground: w2if.SetInputBufferTypeToRGBA() w2if.ReadFrontBufferOff() # read from the back buffer w2if.Update() if filename.endswith('.png'): writer = vtk.vtkPNGWriter() writer.SetFileName(filename) writer.SetInputConnection(w2if.GetOutputPort()) writer.Write() elif filename.endswith('.jpg'): writer = vtk.vtkJPEGWriter() writer.SetFileName(filename) writer.SetInputConnection(w2if.GetOutputPort()) writer.Write() elif filename.endswith('.svg'): writer = vtk.vtkGL2PSExporter() #writer.SetFileFormatToPDF() #writer.SetFileFormatToTeX() writer.SetFileFormatToSVG() writer.CompressOff() writer.SetInput(settings.plotter_instance.window) writer.SetFilePrefix(filename.split('.')[0]) writer.Write()
def SaveAsBMP(self, filename, resolution=1): """Saves the window as bmp-file. Resolution is an integer representing the number of squares that the window is divided into when writing to the bmp-file. Thus choosing a higher number improves the quality of the saved image. """ from vtk import vtkRenderLargeImage, vtkBMPWriter #self.UpdateLight() renderLarge = vtkRenderLargeImage() renderLarge.SetInput(self.GetRenderer()) renderLarge.SetMagnification(resolution) writer = vtkBMPWriter() writer.SetFileName(filename) writer.SetInput(renderLarge.GetOutput()) writer.Write()
def take_screenshot(self, filename): ren = self.GetRenderWindow().GetRenderers().GetFirstRenderer() renderLarge = vtk.vtkRenderLargeImage() if vtk_major_version <= 5: renderLarge.SetInputData(ren) else: renderLarge.SetInput(ren) renderLarge.SetMagnification(1) # We write out the image which causes the rendering to occur. If you # watch your screen you might see the pieces being rendered right # after one another. writer = vtk.vtkPNGWriter() writer.SetInputConnection(renderLarge.GetOutputPort()) # # # print "GOT HERE fileName=",fileName writer.SetFileName(filename) writer.Write()
def take_screenshot(self,filename): ren = self.GetRenderWindow().GetRenderers().GetFirstRenderer() renderLarge = vtk.vtkRenderLargeImage() if vtk_major_version <= 5: renderLarge.SetInputData(ren) else: renderLarge.SetInput(ren) renderLarge.SetMagnification(1) # We write out the image which causes the rendering to occur. If you # watch your screen you might see the pieces being rendered right # after one another. writer = vtk.vtkPNGWriter() writer.SetInputConnection(renderLarge.GetOutputPort()) # # # print "GOT HERE fileName=",fileName writer.SetFileName(filename) writer.Write()
def photo(self): magnif = str(self.plainTextEdit.toPlainText()) if magnif == "": magnif = 1 else: magnif = int(magnif) w2if = vtk.vtkWindowToImageFilter() w2if.Update() renderLarge = vtk.vtkRenderLargeImage() renderer = self.qvtkWidget.GetRenderWindow().GetRenderers( ).GetFirstRenderer() renderLarge.SetInput(renderer) renderLarge.SetMagnification(magnif) writer = vtk.vtkPNGWriter() writer.SetInputConnection(renderLarge.GetOutputPort()) writer.SetFileName( str(QtGui.QFileDialog.getOpenFileName(directory="./output"))) writer.Write()
def test_gui_screenshot(self): bdf_filename = os.path.join(MODEL_PATH, 'bars', 'pbarl_chan.bdf') test = NastranGUI() test.load_nastran_geometry(bdf_filename) magnify = None render_large = vtk.vtkRenderLargeImage() test.run_vtk = True #test.create_corner_axis() # faking coordinate system axes_actor = vtk.vtkAxesActor() test.corner_axis = vtk.vtkOrientationMarkerWidget() test.corner_axis.SetOrientationMarker(axes_actor) #test.on_take_screenshot(fname='chan.png', magnify=None, show_msg=True) out = test.tool_actions._screenshot_setup(magnify, render_large) line_widths0, point_sizes0, coord_scale0, fake_axes_actor, magnify = out test.tool_actions._screenshot_teardown(line_widths0, point_sizes0, coord_scale0, axes_actor)
def onTakePicture(self, event): renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(self.getRenderer()) renderLarge.SetMagnification(4) wildcard = "PNG (*.png)|*.png|" \ "JPEG (*.jpeg; *.jpeg; *.jpg; *.jfif)|*.jpg;*.jpeg;*.jpg;*.jfif|" \ "TIFF (*.tif; *.tiff)|*.tif;*.tiff|" \ "BMP (*.bmp)|*.bmp|" \ "PostScript (*.ps)|*.ps|" \ "All files (*.*)|*.*" dlg = wx.FileDialog(None, "Choose a file", self.dirname, "", wildcard, wx.SAVE | wx.OVERWRITE_PROMPT) if dlg.ShowModal() == wx.ID_OK: fname = dlg.GetFilename() self.dirname = dlg.GetDirectory() fname = os.path.join(self.dirname, fname) print "fname = ", fname # We write out the image which causes the rendering to occur. If you # watch your screen you might see the pieces being rendered right # after one another. lfname = fname.lower() if lfname.endswith('.png'): writer = vtk.vtkPNGWriter() elif lfname.endswith('.jpeg'): writer = vtk.vtkJPEGWriter() elif lfname.endswith('.tiff'): writer = vtk.vtkTIFFWriter() elif lfname.endswith('.ps'): writer = vtk.vtkPostScriptWriter() else: writer = vtk.vtkPNGWriter() writer.SetInputConnection(renderLarge.GetOutputPort()) writer.SetFileName(fname) writer.Write() dlg.Destroy()
def photo(self): print "photo" magnif=str(self.plainTextEdit_2.toPlainText ()) if magnif=="": magnif=1 else: magnif=int(magnif) w2if=vtk.vtkWindowToImageFilter() w2if.Update() renderLarge= vtk.vtkRenderLargeImage() renderer=self.qvtkWidget.GetRenderWindow().GetRenderers().GetFirstRenderer() renderLarge.SetInput(renderer) renderLarge.SetMagnification(magnif) writer=vtk.vtkPNGWriter() writer.SetInputConnection(renderLarge.GetOutputPort()) writer.SetFileName(str(QtGui.QFileDialog.getOpenFileName(directory ="./output"))) writer.Write()
def OnExportPicture(self, pubsub_evt): Publisher.sendMessage('Begin busy cursor') id, filename, filetype = pubsub_evt.data if id == const.VOLUME: if filetype == const.FILETYPE_POV: renwin = self.interactor.GetRenderWindow() image = vtk.vtkWindowToImageFilter() image.SetInput(renwin) writer = vtk.vtkPOVExporter() writer.SetFileName(filename) writer.SetRenderWindow(renwin) writer.Write() else: #Use tiling to generate a large rendering. image = vtk.vtkRenderLargeImage() image.SetInput(self.ren) image.SetMagnification(1) image.Update() image = image.GetOutput() # write image file if (filetype == const.FILETYPE_BMP): writer = vtk.vtkBMPWriter() elif (filetype == const.FILETYPE_JPG): writer = vtk.vtkJPEGWriter() elif (filetype == const.FILETYPE_PNG): writer = vtk.vtkPNGWriter() elif (filetype == const.FILETYPE_PS): writer = vtk.vtkPostScriptWriter() elif (filetype == const.FILETYPE_TIF): writer = vtk.vtkTIFFWriter() filename = "%s.tif"%filename.strip(".tif") writer.SetInputData(image) writer.SetFileName(filename) writer.Write() Publisher.sendMessage('End busy cursor')
def OnExportPicture(self, pubsub_evt): Publisher.sendMessage('Begin busy cursor') id, filename, filetype = pubsub_evt.data if id == const.VOLUME: if filetype == const.FILETYPE_POV: renwin = self.interactor.GetRenderWindow() image = vtk.vtkWindowToImageFilter() image.SetInput(renwin) writer = vtk.vtkPOVExporter() writer.SetFileName(filename) writer.SetRenderWindow(renwin) writer.Write() else: #Use tiling to generate a large rendering. image = vtk.vtkRenderLargeImage() image.SetInput(self.ren) image.SetMagnification(1) image.Update() image = image.GetOutput() # write image file if (filetype == const.FILETYPE_BMP): writer = vtk.vtkBMPWriter() elif (filetype == const.FILETYPE_JPG): writer = vtk.vtkJPEGWriter() elif (filetype == const.FILETYPE_PNG): writer = vtk.vtkPNGWriter() elif (filetype == const.FILETYPE_PS): writer = vtk.vtkPostScriptWriter() elif (filetype == const.FILETYPE_TIF): writer = vtk.vtkTIFFWriter() filename = "%s.tif" % filename.strip(".tif") writer.SetInputData(image) writer.SetFileName(filename) writer.Write() Publisher.sendMessage('End busy cursor')
def _export_picture(self, id, filename, filetype): if filetype == const.FILETYPE_POV: renwin = self.interactor.GetRenderWindow() image = vtk.vtkWindowToImageFilter() image.SetInput(renwin) writer = vtk.vtkPOVExporter() writer.SetFileName(filename.encode(const.FS_ENCODE)) writer.SetRenderWindow(renwin) writer.Write() else: #Use tiling to generate a large rendering. image = vtk.vtkRenderLargeImage() image.SetInput(self.ren) image.SetMagnification(1) image.Update() image = image.GetOutput() # write image file if (filetype == const.FILETYPE_BMP): writer = vtk.vtkBMPWriter() elif (filetype == const.FILETYPE_JPG): writer = vtk.vtkJPEGWriter() elif (filetype == const.FILETYPE_PNG): writer = vtk.vtkPNGWriter() elif (filetype == const.FILETYPE_PS): writer = vtk.vtkPostScriptWriter() elif (filetype == const.FILETYPE_TIF): writer = vtk.vtkTIFFWriter() filename = u"%s.tif" % filename.strip(".tif") writer.SetInputData(image) writer.SetFileName(filename.encode(const.FS_ENCODE)) writer.Write() if not os.path.exists(filename): wx.MessageBox(_("InVesalius was not able to export this picture"), _("Export picture error"))
def draw(poly_data, color_scale='Diverging', write_file=False, file_name='unstr.png'): ctf = vtk.vtkColorTransferFunction() lut = vtk.vtkLookupTable() args = Namespace(colorScale=color_scale, vlog=False) ctf, lut = CreateCTF(args, ctf, lut) mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(poly_data) mapper.SetLookupTable(lut) data_array = poly_data.GetCellData().GetScalars() if data_array is not None: np_attribute = numpy_support.vtk_to_numpy(data_array) min_val = np_attribute.min() max_val = np_attribute.max() else: min_val = 0 max_val = 1 mapper.SetScalarRange(min_val, max_val) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetSpecular(0.3) camera = vtk.vtkCamera() camera.SetPosition(0, 0e3, 20e3) camera.SetFocalPoint(0, 0e3, -10e3) camera.Zoom(1.0) renderer = vtk.vtkRenderer() renderer.AddActor(actor) renderer.SetBackground(0, 0, 0) renderer.SetActiveCamera(camera) renderer.ResetCamera() light_kit = vtk.vtkLightKit() light_kit.MaintainLuminanceOn() light_kit.SetKeyLightIntensity(0.75) light_kit.SetKeyLightWarmth(0.60) light_kit.SetFillLightWarmth(0.4) light_kit.SetBackLightWarmth(0.5) light_kit.SetHeadLightWarmth(0.5) light_kit.AddLightsToRenderer(renderer) ren_win = vtk.vtkRenderWindow() ren_win.AddRenderer(renderer) ren_win.SetSize(1300, 900) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(ren_win) ren_win.Render() iren.Start() if write_file: render_large = vtk.vtkRenderLargeImage() render_large.SetInput(renderer) render_large.SetMagnification(1) writer = vtk.vtkPNGWriter() writer.SetInputConnection(render_large.GetOutputPort()) writer.SetFileName('../../output-vtk/' + file_name) writer.Write() print('done writing %s' % file_name) del render_large del writer
def visualize(self, out_path='out/', outer_box=True, axes=True, clip_neg=False, azimuth=0, elevation=0, n_frames=1, mag=1, video=False, viz_type='ODF', mask=None, mask_roi=None, skip_n=1, skip_n_roi=1, scale=1, roi_scale=1, zoom_start=1.0, zoom_end=1.0, top_zoom=1, interact=False, save_parallels=False, my_cam=None, compress=True, roi=None, corner_text='', scalemap=None, titles_on=True, scalebar_on=True, invert=False, flat=False, colormap='bwr', global_cm=True, camtilt=False, axes_on=False, colors=None, arrows=None, arrow_color=np.array([0, 0, 0]), linewidth=0.1, mark_slices=None, z_shift=0, profiles=[], markers=[], marker_colors=[], marker_scale=1, normalize_glyphs=True, gamma=1, density_max=1): log.info('Preparing to render ' + out_path) # Handle scalemap if scalemap is None: scalemap = util.ScaleMap(min=np.min(self.f[..., 0]), max=np.max(self.f[..., 0])) # Prepare output util.mkdir(out_path) # Setup vtk renderers renWin = vtk.vtkRenderWindow() if not interact: renWin.SetOffScreenRendering(1) if isinstance(viz_type, str): viz_type = [viz_type] # Rows and columns cols = len(viz_type) if roi is None: rows = 1 else: rows = 2 renWin.SetSize(np.int(500 * mag * cols), np.int(500 * mag * rows)) # Select background color if save_parallels: bg_color = [1, 1, 1] line_color = np.array([0, 0, 0]) line_bcolor = np.array([1, 1, 1]) else: if not invert: bg_color = [0, 0, 0] line_color = np.array([1, 1, 1]) line_bcolor = np.array([0, 0, 0]) else: bg_color = [1, 1, 1] line_color = np.array([0, 0, 0]) line_bcolor = np.array([1, 1, 1]) # For each viz_type rens = [] zoom_start = [] zoom_end = [] for row in range(rows): for col in range(cols): # Render ren = window.Scene() rens.append(ren) if viz_type[col] is 'Density': ren.background([0, 0, 0]) line_color = np.array([1, 1, 1]) else: ren.background(bg_color) ren.SetViewport(col / cols, (rows - row - 1) / rows, (col + 1) / cols, (rows - row) / rows) renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Mask if mask is None: mask = np.ones((self.X, self.Y, self.Z), dtype=np.bool) if mask_roi is None: mask_roi = mask # Main vs roi if row == 0: data = self.f skip_mask = np.zeros(mask.shape, dtype=np.bool) skip_mask[::skip_n, ::skip_n, ::skip_n] = 1 my_mask = np.logical_and(mask, skip_mask) scale = scale scalemap = scalemap if np.sum(my_mask) == 0: my_mask[0, 0, 0] = True else: data = self.f[roi[0][0]:roi[1][0], roi[0][1]:roi[1][1], roi[0][2]:roi[1][2], :] roi_mask = mask_roi[roi[0][0]:roi[1][0], roi[0][1]:roi[1][1], roi[0][2]:roi[1][2]] skip_mask = np.zeros(roi_mask.shape, dtype=np.bool) skip_mask[::skip_n_roi, ::skip_n_roi, ::skip_n_roi] = 1 my_mask = np.logical_and(roi_mask, skip_mask) scale = roi_scale scalemap = scalemap # Add visuals to renderer if viz_type[col] == "ODF": renWin.SetMultiSamples(4) log.info('Rendering ' + str(np.sum(my_mask)) + ' ODFs') fodf_spheres = viz.odf_sparse(data, self.Binv, sphere=self.sphere, scale=skip_n * scale * 0.5, norm=False, colormap=colormap, mask=my_mask, global_cm=global_cm, scalemap=scalemap, odf_sphere=False, flat=flat, normalize=normalize_glyphs) ren.add(fodf_spheres) elif viz_type[col] == "ODF Sphere": renWin.SetMultiSamples(4) log.info('Rendering ' + str(np.sum(my_mask)) + ' ODFs') fodf_spheres = viz.odf_sparse(data, self.Binv, sphere=self.sphere, scale=skip_n * scale * 0.5, norm=False, colormap=colormap, mask=my_mask, global_cm=global_cm, scalemap=scalemap, odf_sphere=True, flat=flat) ren.add(fodf_spheres) elif viz_type[col] == "Ellipsoid": renWin.SetMultiSamples(4) log.info( 'Warning: scaling is not implemented for ellipsoids') log.info('Rendering ' + str(np.sum(my_mask)) + ' ellipsoids') fodf_peaks = viz.tensor_slicer_sparse(data, sphere=self.sphere, scale=skip_n * scale * 0.5, mask=my_mask) ren.add(fodf_peaks) elif viz_type[col] == "Peak": renWin.SetMultiSamples(4) log.info('Rendering ' + str(np.sum(my_mask)) + ' peaks') fodf_peaks = viz.peak_slicer_sparse( data, self.Binv, self.sphere.vertices, linewidth=linewidth, scale=skip_n * scale * 0.5, colors=colors, mask=my_mask, scalemap=scalemap, normalize=normalize_glyphs) fodf_peaks.GetProperty().LightingOn() fodf_peaks.GetProperty().SetDiffuse( 0.4) # Doesn't work (VTK bug I think) fodf_peaks.GetProperty().SetAmbient(0.15) fodf_peaks.GetProperty().SetSpecular(0) fodf_peaks.GetProperty().SetSpecularPower(0) ren.add(fodf_peaks) elif viz_type[col] == "Principal": log.info( 'Warning: scaling is not implemented for principals') log.info('Rendering ' + str(np.sum(my_mask)) + ' principals') fodf_peaks = viz.principal_slicer_sparse( data, self.Binv, self.sphere.vertices, scale=skip_n * scale * 0.5, mask=my_mask) ren.add(fodf_peaks) elif viz_type[col] == "Density": renWin.SetMultiSamples(0) # Must be zero for smooth # renWin.SetAAFrames(4) # Slow antialiasing for volume renders log.info('Rendering density') gamma_corr = np.where(data[..., 0] > 0, data[..., 0]**gamma, data[..., 0]) scalemap.max = density_max * scalemap.max**gamma volume = viz.density_slicer(gamma_corr, scalemap) ren.add(volume) X = np.float(data.shape[0]) Y = np.float(data.shape[1]) Z = np.float(data.shape[2]) - z_shift # Titles if row == 0 and titles_on: viz.add_text(ren, viz_type[col], 0.5, 0.96, mag) # Scale bar if col == cols - 1 and not save_parallels and scalebar_on: yscale = 1e-3 * self.vox_dim[1] * data.shape[1] yscale_label = '{:.2g}'.format(yscale) + ' um' viz.add_text(ren, yscale_label, 0.5, 0.03, mag) viz.draw_scale_bar(ren, X, Y, Z, [1, 1, 1]) # Corner text if row == rows - 1 and col == 0 and titles_on: viz.add_text(ren, corner_text, 0.03, 0.03, mag, ha='left') # Draw boxes Nmax = np.max([X, Y, Z]) if outer_box: if row == 0: viz.draw_outer_box( ren, np.array([[0, 0, 0], [X, Y, Z]]) - 0.5, line_color) if row == 1: viz.draw_outer_box( ren, np.array([[0, 0, 0], [X, Y, Z]]) - 0.5, [0, 1, 1]) # Add colored axes if axes: viz.draw_axes(ren, np.array([[0, 0, 0], [X, Y, Z]]) - 0.5) # Add custom arrows if arrows is not None: for i in range(arrows.shape[0]): viz.draw_single_arrow(ren, arrows[i, 0, :], arrows[i, 1, :], color=arrow_color) viz.draw_unlit_line(ren, [ np.array([arrows[i, 0, :], [X / 2, Y / 2, Z / 2]]) ], [arrow_color], lw=0.3, scale=1.0) # Draw roi box if row == 0 and roi is not None: maxROI = np.max([ roi[1][0] - roi[0][0], roi[1][1] - roi[0][1], roi[1][2] - roi[0][2] ]) maxXYZ = np.max([self.X, self.Y, self.Z]) viz.draw_outer_box(ren, roi, [0, 1, 1], lw=0.3 * maxXYZ / maxROI) viz.draw_axes(ren, roi, lw=0.3 * maxXYZ / maxROI) # Draw marked slices if mark_slices is not None: for slicen in mark_slices: md = np.max((X, Z)) frac = slicen / data.shape[1] rr = 0.83 * md t1 = 0 t2 = np.pi / 2 t3 = np.pi t4 = 3 * np.pi / 2 points = [ np.array([[ X / 2 + rr * np.cos(t1), frac * Y, Z / 2 + rr * np.sin(t1) ], [ X / 2 + rr * np.cos(t2), frac * Y, Z / 2 + rr * np.sin(t2) ], [ X / 2 + rr * np.cos(t3), frac * Y, Z / 2 + rr * np.sin(t3) ], [ X / 2 + rr * np.cos(t4), frac * Y, Z / 2 + rr * np.sin(t4) ], [ X / 2 + rr * np.cos(t1), frac * Y, Z / 2 + rr * np.sin(t1) ], [ X / 2 + rr * np.cos(t2), frac * Y, Z / 2 + rr * np.sin(t2) ]]) ] viz.draw_unlit_line(ren, points, 6 * [line_color + 0.6], lw=0.3, scale=1.0) # Draw markers for i, marker in enumerate(markers): # Draw sphere source = vtk.vtkSphereSource() source.SetCenter(marker) source.SetRadius(marker_scale) source.SetThetaResolution(30) source.SetPhiResolution(30) # mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) # actor actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(marker_colors[i, :]) actor.GetProperty().SetLighting(0) ren.AddActor(actor) # Draw profile lines colors = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) for i, profile in enumerate(profiles): import pdb pdb.set_trace() n_seg = profile.shape[0] viz.draw_unlit_line(ren, [profile], n_seg * [colors[i, :]], lw=0.5, scale=1.0) # Draw sphere source = vtk.vtkSphereSource() source.SetCenter(profile[0]) source.SetRadius(1) source.SetThetaResolution(30) source.SetPhiResolution(30) # mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) # actor actor = vtk.vtkActor() actor.SetMapper(mapper) # actor.GetProperty().SetColor(colors[i,:]) actor.GetProperty().SetLighting(0) # assign actor to the renderer ren.AddActor(actor) # Setup cameras Rmax = np.linalg.norm([Z / 2, X / 2, Y / 2]) Rcam_rad = Rmax / np.tan(np.pi / 12) Ntmax = np.max([X, Y]) ZZ = Z if ZZ > Ntmax: Rcam_edge = np.max([X / 2, Y / 2]) else: Rcam_edge = np.min([X / 2, Y / 2]) Rcam = Rcam_edge + Rcam_rad if my_cam is None: cam = ren.GetActiveCamera() if camtilt: cam.SetPosition( ((X - 1) / 2, (Y - 1) / 2, (Z - 1) / 2 + Rcam)) cam.SetViewUp((-1, 0, 1)) if axes_on: max_dim = np.max((X, Z)) viz.draw_unlit_line(ren, [ np.array([[(X - max_dim) / 2, Y / 2, Z / 2], [X / 2, Y / 2, +Z / 2], [X / 2, Y / 2, (Z + max_dim) / 2]]) ], 3 * [line_color], lw=max_dim / 250, scale=1.0) else: cam.SetPosition( ((X - 1) / 2 + Rcam, (Y - 1) / 2, (Z - 1) / 2)) cam.SetViewUp((0, 0, 1)) cam.SetFocalPoint(((X - 1) / 2, (Y - 1) / 2, (Z - 1) / 2)) #ren.reset_camera() else: ren.set_camera(*my_cam) ren.azimuth(azimuth) ren.elevation(elevation) # Set zooming if save_parallels: zoom_start.append(1.7) zoom_end.append(1.7) else: if row == 0: zoom_start.append(1.3 * top_zoom) zoom_end.append(1.3 * top_zoom) else: zoom_start.append(1.3) zoom_end.append(1.3) # Setup writer writer = vtk.vtkTIFFWriter() if not compress: writer.SetCompressionToNoCompression() # Execute renders az = 90 naz = np.ceil(360 / n_frames) log.info('Rendering ' + out_path) if save_parallels: # Parallel rendering for summaries filenames = ['yz', 'xy', 'xz'] zooms = [zoom_start[0], 1.0, 1.0] azs = [90, -90, 0] els = [0, 0, 90] ren.projection(proj_type='parallel') ren.reset_camera() for i in tqdm(range(3)): ren.zoom(zooms[i]) ren.azimuth(azs[i]) ren.elevation(els[i]) ren.reset_clipping_range() renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetMagnification(1) renderLarge.SetInput(ren) renderLarge.Update() writer.SetInputConnection(renderLarge.GetOutputPort()) writer.SetFileName(out_path + filenames[i] + '.tif') writer.Write() else: # Rendering for movies for j, ren in enumerate(rens): ren.zoom(zoom_start[j]) for i in tqdm(range(n_frames)): for j, ren in enumerate(rens): ren.zoom(1 + ((zoom_end[j] - zoom_start[j]) / n_frames)) ren.azimuth(az) ren.reset_clipping_range() renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetMagnification(1) renderLarge.SetInput(ren) renderLarge.Update() writer.SetInputConnection(renderLarge.GetOutputPort()) if n_frames != 1: writer.SetFileName(out_path + str(i).zfill(3) + '.tif') else: writer.SetFileName(out_path + '.tif') writer.Write() az = naz # Interactive if interact: window.show(ren) # Generate video (requires ffmpeg) if video: log.info('Generating video from frames') fps = np.ceil(n_frames / 12) subprocess.call([ 'ffmpeg', '-nostdin', '-y', '-framerate', str(fps), '-loglevel', 'panic', '-i', out_path + '%03d' + '.png', '-pix_fmt', 'yuvj420p', '-vcodec', 'mjpeg', out_path[:-1] + '.avi' ]) # subprocess.call(['rm', '-r', out_path]) return my_cam
# ren.GetActiveCamera().SetWindowCenter(-0.2, 0.3) ren.GetActiveCamera().SetPosition(0, 1, 0) ren.GetActiveCamera().SetFocalPoint(0, 0, 0) ren.GetActiveCamera().SetViewUp(0, 0, 1) # # let the renderer compute good position and focal point # ren.ResetCamera() ren.GetActiveCamera().Dolly(1.4) ren1.ResetCameraClippingRange() # render the large image # renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(ren1) renderLarge.SetMagnification(3) renderLarge.Update() viewer = vtk.vtkImageViewer() viewer.SetInputConnection(renderLarge.GetOutputPort()) viewer.SetColorWindow(255) viewer.SetColorLevel(127.5) viewer.Render() ## on several opengl X window unix implementations ## multiple context deletes cause errors ## so we leak the renWin in this test for unix #if renWin1.IsA('vtkXOpenGLRenderWindow'): # renWin1.Register(ren1)
def record(ren, outdir, prefix, cam_pos=None, cam_focal=None, cam_view=None, n_frames=1, az_ang=10, size=(300, 300), animate=False, delay=100, verbose=False): """ This will record a snap/video of the rendered objects. Records a video as a series of ".png" files by rotating the azimuth angle 'az_ang' in every frame. Parameters ---------- ren: vtkRenderer() object (mandatory) as returned from function ren() outdir: str (mandatory) the output directory. prefix: str (mandatory) the png snap base names. cam_pos: 3-uplet (optional, default None) the camera position. cam_focal: 3-uplet (optional, default None) the camera focal point. cam_view: 3-uplet (optional, default None) the camera view up. n_frames: int (optional, default 1) the number of frames to save. az_ang: float (optional, default 10) the azimuthal angle of camera rotation (in degrees). size: 2-uplet (optional, default (300, 300)) (width, height) of the window. animate: bool (optional, default False) if True agglomerate the generated snaps in a Gif and delete the raw snaps. delay: int (optional, default 100) this option is useful for regulating the animation of image sequences ticks/ticks-per-second seconds must expire before the display of the next image. The default is no delay between each showing of the image sequence. The default ticks-per-second is 100. verbose: bool (optional, default False) if True display debuging message. Returns ------- snaps: list of str the generated snaps. """ # Create a window and a interactor window = vtk.vtkRenderWindow() window.AddRenderer(ren) window.SetSize(size) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(window) # Set the camera properties ren.ResetCamera() camera = ren.GetActiveCamera() if cam_pos is not None: camera.SetPosition(cam_pos) if cam_focal is not None: camera.SetFocalPoint(cam_focal) if cam_view is not None: camera.SetViewUp(cam_view) if verbose: print("Camera Position (%.2f,%.2f,%.2f)" % camera.GetPosition()) print("Camera Focal Point (%.2f,%.2f,%.2f)" % camera.GetFocalPoint()) print("Camera View Up (%.2f,%.2f,%.2f)" % camera.GetViewUp()) # Create 'n_frames' by rotating each time the scene by 'az_ang' degrees writer = vtk.vtkPNGWriter() snaps = [] for index in range(n_frames): render = vtk.vtkRenderLargeImage() render.SetInput(ren) render.SetMagnification(1) render.Update() writer.SetInputConnection(render.GetOutputPort()) current_prefix = prefix if n_frames > 1: current_prefix += "-" + str(index + 1).zfill(8) snap_file = os.path.join(outdir, current_prefix + ".png") writer.SetFileName(snap_file) snaps.append(snap_file) writer.Write() camera.Azimuth(az_ang) # Create an animation if animate: giffile = os.path.join(outdir, prefix + ".gif") images_to_gif(snaps, giffile, delay=delay) for fname in snaps: os.remove(fname) snaps = [giffile] return snaps
def render_cam_view(CADModel, FitResults, filename=None, oversampling=1, AA=1, Edges=False, EdgeColour=(1, 0, 0), EdgeWidth=2, Transparency=False, ROI=None, ROIColour=(0.8, 0, 0), ROIOpacity=0.3, roi_oversize=0, NearestNeighbourRemap=False, Verbose=True, Coords='Display', ScreenSize=None): """ Make CAD model renders from the camera's point of view, including all distortion effects etc. INPUTS: Required: CADModel - CAD model object FitResults - Fit results for the camera from whose viewpoint to do the render Optional (keyword): filename - filename, including file extension, to save resulting image (if not specified, the image is not saved). oversampling - the size of the rendered image is <real camera image size> * oversampling AA - Anti-aliasing factor. Larger numbers look nicer but take more memory to render Edges - Bool, if set to True renders the CAD model in wireframe (but still with occlusion) EdgeColour - 3-element tuple of floats 0-1, If Edges=True, what colour to make the edges in the wireframe (R,G,B) EdgeWidth - If Edges=True, line width for edges Transparency - whether to make black areas (i.e. background) transparent. ROI - An ROI definition object: if supplied, the ROI will be rendered on the image. ROIColour - (R,G,B) colour to render the ROI ROIOpacity - Opacity to render ROI qt_avilable_geometry - If being called from a Qt app, this must be used. OUTPUTS: im - numpy array with RGB[A] image If filename is provided, saves the render with the specified filename """ if Coords.lower() == 'original' and oversampling != 1: raise Exception( 'Cannot render in original coordinates with oversampling!') logbase2 = np.log(oversampling) / np.log(2) if abs(int(logbase2) - logbase2) > 1e-5: raise ValueError('Oversampling must be a power of two!') if Verbose: tstart = time.time() print('[Calcam Renderer] Preparing...') # This will be our result. To start with we always render in display coords. OutputImage = np.zeros([ int(FitResults.image_display_shape[1] * oversampling), int(FitResults.image_display_shape[0] * oversampling), 3 + Transparency ], dtype='uint8') # The un-distorted FOV is over-rendered to allow for distortion. # FOV_factor is how much to do this by; too small and image edges might be cut off. models = [] for field in FitResults.fit_params: models.append(field.model) if np.any(np.array(models) == 'fisheye'): FOV_factor = 3. else: FOV_factor = 1.5 x_pixels = FitResults.image_display_shape[0] y_pixels = FitResults.image_display_shape[1] renWin = vtk.vtkRenderWindow() renWin.OffScreenRenderingOn() # Get the screen resolution - even using off screen rendering, if the VTK render window # doesn't fit on the screen it causes problems. # Maybe slightly hacky way of finding this out? But I don't know a better one. if ScreenSize is None: try: app = qt.QApplication(sys.argv) desktopinfo = app.desktop() dummydialog = qt.QDialog() qt_available_geometry = desktopinfo.availableGeometry(dummydialog) ScreenSize = (qt_available_geometry.width(), available_geometry.height()) del qt_available_geometry, dummydialog, desktopinfo, app except: ScreenSize = (800, 600) # Set up render window for initial, un-distorted window renderer = vtk.vtkRenderer() renWin.AddRenderer(renderer) Camera = renderer.GetActiveCamera() # Set the model face colour to black if we only want to see edges if Edges: CADModel.edges = True CADModel.edge_width = EdgeWidth # If rendering wireframe, set the CAD model colour to the desired edge colour. Before we do that, save the colours we started with. oldColours = [] for Feature in CADModel.features: oldColours.append((Feature[4], Feature[0])) CADModel.set_colour(EdgeColour) # This whole thing is in a try() except() because it is prone to memory errors, and I need to put the CAD model # colour back the way it started if we have a problem. try: # Add all the bits of the machine for Actor in CADModel.get_vtkActors(): renderer.AddActor(Actor) # Add the ROI if provided if ROI is not None: try: n_rois = len(ROI.rois) for roi in ROI.rois: ROIActor = roi.get_vtkActor(FitResults.get_pupilpos()) ROIActor.GetProperty().SetColor(ROIColour) ROIActor.GetProperty().SetOpacity(ROIOpacity) if roi_oversize > 0: ROIActor.GetProperty().EdgeVisibilityOn() ROIActor.GetProperty().SetLineWidth(roi_oversize * 2.) ROIActor.GetProperty().SetEdgeColor(ROIColour) renderer.AddActor(ROIActor) except AttributeError: ROIActor = ROI.get_vtkActor(FitResults.get_pupilpos(field=0)) ROIActor.GetProperty().SetColor(ROIColour) ROIActor.GetProperty().SetOpacity(ROIOpacity) if roi_oversize > 0: ROIActor.GetProperty().EdgeVisibilityOn() ROIActor.GetProperty().SetLineWidth(roi_oversize * 2.) ROIActor.GetProperty().SetEdgeColor(ROIColour) renderer.AddActor(ROIActor) # We need a field mask the same size as the output FieldMask = cv2.resize( FitResults.fieldmask, (int(x_pixels * oversampling), int(y_pixels * oversampling)), interpolation=cv2.INTER_NEAREST) for field in range(FitResults.nfields): Cx = FitResults.fit_params[field].cam_matrix[0, 2] Cy = FitResults.fit_params[field].cam_matrix[1, 2] Fy = FitResults.fit_params[field].cam_matrix[1, 1] vtk_win_im = vtk.vtkRenderLargeImage() vtk_win_im.SetInput(renderer) # Width and height - initial render will be put optical centre in the window centre wt = int(2 * FOV_factor * max(Cx, x_pixels - Cx)) ht = int(2 * FOV_factor * max(Cy, y_pixels - Cy)) # Make sure the intended render window will fit on the screen window_factor = 1 if wt > ScreenSize[0] or ht > ScreenSize[1]: window_factor = int( max(np.ceil(float(wt) / float(ScreenSize[0])), np.ceil(float(ht) / float(ScreenSize[1])))) vtk_win_im.SetMagnification( int(window_factor * AA * max(oversampling, 1))) width = int(wt / window_factor) height = int(ht / window_factor) renWin.SetSize(width, height) # Set up CAD camera FOV_y = 360 * np.arctan(ht / (2 * Fy)) / 3.14159 CamPos = FitResults.get_pupilpos(field=field) CamTar = FitResults.get_los_direction(Cx, Cy, ForceField=field) + CamPos UpVec = -1. * FitResults.get_cam_to_lab_rotation(field=field)[:, 1] Camera.SetPosition(CamPos) Camera.SetViewAngle(FOV_y) Camera.SetFocalPoint(CamTar) Camera.SetViewUp(UpVec) if Verbose: print( '[Calcam Renderer] Rendering (Field {:d}/{:d})...'.format( field + 1, FitResults.nfields)) # Do the render and grab an image renWin.Render() vtk_win_im.Update() vtk_image = vtk_win_im.GetOutput() if field == FitResults.nfields - 1: renWin.Finalize() if Edges: # Put the colour scheme back to how it was for Feature in oldColours: CADModel.set_colour(Feature[0], Feature[1]) Actor.GetProperty().EdgeVisibilityOff() vtk_array = vtk_image.GetPointData().GetScalars() dims = vtk_image.GetDimensions() im = np.flipud( vtk.util.numpy_support.vtk_to_numpy(vtk_array).reshape( dims[1], dims[0], 3)) if Transparency: alpha = 255 * np.ones( [np.shape(im)[0], np.shape(im)[1]], dtype='uint8') alpha[np.sum(im, axis=2) == 0] = 0 im = np.dstack((im, alpha)) im = cv2.resize(im, (int(dims[0] / AA * min(oversampling, 1)), int(dims[1] / AA * min(oversampling, 1))), interpolation=cv2.INTER_AREA) if Verbose: print( '[Calcam Renderer] Applying lens distortion (Field {:d}/{:d})...' .format(field + 1, FitResults.nfields)) # Pixel locations we want on the final image [xn, yn] = np.meshgrid( np.linspace(0, x_pixels - 1, x_pixels * oversampling), np.linspace(0, y_pixels - 1, y_pixels * oversampling)) xn, yn = FitResults.normalise(xn, yn, field) # Transform back to pixel coords where we want to sample the un-distorted render. # Both x and y are divided by Fy because the initial render always has Fx = Fy. xmap = ((xn * Fy) + (width * window_factor) / 2.) * oversampling ymap = ((yn * Fy) + (height * window_factor) / 2.) * oversampling xmap = xmap.astype('float32') ymap = ymap.astype('float32') # Actually apply distortion if NearestNeighbourRemap: interp_method = cv2.INTER_NEAREST else: interp_method = cv2.INTER_CUBIC im = cv2.remap(im, xmap, ymap, interp_method) OutputImage[FieldMask == field, :] = im[FieldMask == field, :] CADModel.edges = False if Coords.lower() == 'original': OutputImage = FitResults.transform.display_to_original_image( OutputImage) if Verbose: print( '[Calcam Renderer] Completed in {:.1f} s.'.format(time.time() - tstart)) # Save the image if given a filename if filename is not None: # If we have transparency, we can only save as PNG. if Transparency and filename[-3:].lower() != 'png': print( '[Calcam Renderer] Images with transparency can only be saved as PNG! Overriding output file type to PNG.' ) filename = filename[:-3] + 'png' # Re-shuffle the colour channels for saving (openCV needs BGR / BGRA) SaveIm = OutputImage SaveIm[:, :, :3] = OutputImage[:, :, 2::-1] cv2.imwrite(filename, SaveIm) if Verbose: print( '[Calcam Renderer] Result saved as {:s}'.format(filename)) except: if Edges: CADModel.edges = False # Put the colour scheme back to how it was for Feature in oldColours: CADModel.set_colour(Feature[0], Feature[1]) Actor.GetProperty().EdgeVisibilityOff() try: renWin.Finalize() except: pass raise return OutputImage
# ren.GetActiveCamera().ParallelProjectionOn() ren.GetActiveCamera().SetPosition(0, 1, 0) ren.GetActiveCamera().SetFocalPoint(0, 0, 0) ren.GetActiveCamera().SetViewUp(0, 0, 1) # # let the renderer compute good position and focal point # ren.ResetCamera() ren.GetActiveCamera().Zoom(1.4) ren1.ResetCameraClippingRange() # render the large image # renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(ren1) renderLarge.SetMagnification(3) renderLarge.Update() viewer = vtk.vtkImageViewer() viewer.SetInputConnection(renderLarge.GetOutputPort()) viewer.SetColorWindow(255) viewer.SetColorLevel(127.5) viewer.Render() ## on several opengl X window unix implementations ## multiple context deletes cause errors ## so we leak the renWin1 in this test for unix #if renWin1.IsA('vtkXOpenGLRenderWindow'): # renWin1.Register(ren1)
def getMeshPicture( meshFile, pictureFile, cameraArgs={ "camPosition": None, "viewAngle": 30, "scale": 1.0, "targetPosition": None, "viewUp": [0, 0, 1], "fitView": True }, timeList=[0], startInteractive=False, mag=4, parallel="auto", fsArgs={ "scale": (1, 1, 1), "fsRange": None }, y0Args={ "scalarField": "alpha.water", "scalarRange": [0, 1] }, structArgs={ "scalarField": "p_rgh", }, sliceArgsList=[], hullPatch="ship", ): """ Function to generate picture out of openFoam results meshFile : mesh file or case directory """ from tqdm import tqdm #c = Chrono(start=True) baseFile, ext = os.path.splitext(pictureFile)[0:2] Writer = writerFromExt(ext) pathPic = os.path.abspath(os.path.dirname(pictureFile)) if not os.path.exists(pathPic): os.makedirs(pathPic) # Add a file name to the path. "p.foam" does not need to be created if os.path.isdir(meshFile): caseDir = meshFile meshFile = os.path.join(caseDir, "p.foam") else: caseDir = os.path.dirname(meshFile) # Automatically choose "SetCaseType" ( parallel vs (serial/notRun)) if parallel == "auto": if os.path.exists(os.path.join(caseDir, "processor0")): parallel = True else: parallel = False if type(timeList) == str: if timeList == "all": timeList = getAvailableTimeData(caseDir, parallel) elif timeList == "latest": timeList = [getAvailableTimeData(caseDir, parallel)[-1]] elif timeList == "latest-1": timeList = [getAvailableTimeData(caseDir, parallel)[-2]] else: raise (Exception( "time should be 'latest', 'all', or a float iterable")) print("Generating picture for : ", ["{:.2f}".format(i) for i in timeList]) #--- Read the openFoam file vtk_r = vtk.vtkPOpenFOAMReader() vtk_r.SetFileName(meshFile) if parallel: vtk_r.SetCaseType(0) print("Using decomposed case") else: vtk_r.SetCaseType(1) # 0 = decomposed case, 1 = reconstructed case print("Using reconstructed case") #vtk_r.ReadZonesOn() cdp = vtk.vtkCompositeDataPipeline() vtk_r.SetDefaultExecutivePrototype(cdp) vtk_r.SetDecomposePolyhedra(0) vtk_r.CreateCellToPointOn() vtk_r.DisableAllPatchArrays() vtk_r.SetPatchArrayStatus("internalMesh", 1) vtk_r.SetPatchArrayStatus(hullPatch, 1) vtk_r.SetPatchArrayStatus("domainY0", 1) vtk_r.SetTimeValue(timeList[0]) print("Read first") vtk_r.Update() # not mandatory, but just postpone the waiting time print("Read done") iter = vtk_r.GetOutput().NewIterator() blockDict = {} while not iter.IsDoneWithTraversal(): blockDict[iter.GetCurrentMetaData().Get( vtk.vtkCompositeDataSet.NAME())] = iter.GetCurrentFlatIndex() iter.GoToNextItem() print(blockDict) #--- Renderer renderer = vtk.vtkRenderer() #--------------------------------- Free-surface (ISO alpha = 0.5) if fsArgs is not None: fsActor, scalarBar = getFreeSurfaceActor(vtk_r, **fsArgs) renderer.AddActor(fsActor) # Add the mesh to the view renderer.AddActor(scalarBar) #--------------------------------- Ship surface if structArgs is not None: structureActor = getStuctureActor(vtk_r, blockIndex=blockDict[hullPatch], **structArgs) renderer.AddActor(structureActor) # Add the mesh to the view #------------------------------ Symmetry plane if y0Args is not None: symActor = getSymPlaneVtkActor(vtk_r, blockIndex=blockDict["domainY0"], **y0Args) renderer.AddActor(symActor) # Add the mesh to the view #------------------------------ Slices for cutArgs in sliceArgsList: sActor = getCutActor(vtk_r, **cutArgs) renderer.AddActor(sActor) # Add the mesh to the view renderer.SetBackground(1, 1, 1) # White background #--- Rendering windows renWin = vtk.vtkRenderWindow() # Avoid displaying interactive window if not startInteractive: renWin.SetOffScreenRendering(1) renWin.AddRenderer(renderer) renWin.SetSize(1650, 1050) # Set view point setCamera(renderer, **cameraArgs) # To get interactive windows if startInteractive: vtk_r.UpdateTimeStep(timeList[0]) vtk_r.Modified() iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) iren.Start() else: for itime, time in tqdm(enumerate(timeList)): #exe.SetUpdateTimeStep( 0, time ) #vtk_r.SetTimeValue( time ) # vtk_r.Update() vtk_r.UpdateTimeStep(time) vtk_r.Modified() # Require to update the time step data renWin.Render() w2if = vtk.vtkRenderLargeImage() w2if.SetMagnification(mag) # => Resoulition of the picture w2if.SetInput(renderer) w2if.Update() pictureFile = "{:}_{:03}{:}".format(baseFile, itime, ext) writer = Writer() writer.SetFileName(pictureFile) writer.SetInputConnection(w2if.GetOutputPort()) writer.Write()
def record(ren=None,cam_pos=None,cam_focal=None,cam_view=None,outdir=None,n_frames=10, az_ang=10, magnification=1,size=(125,125),bgr_color=(0.1,0.2,0.4)): ''' This will record a video of your scene Records a video as a series of .png files of your scene by rotating the azimuth angle az_angle in every frame Parameters ----------- ren : vtkRenderer() object as returned from function ren() cam_pos : None or sequence (3,) camera position cam_focal : None or sequence (3,) camera focal point cam_view : None or sequence (3,) camera view up outdir : str output directory for the frames n_frames : int number of frames to save az_ang : float azimuthal angle of camera rotation magnification : int how much to magnify the saved frame Examples --------- >>> from dipy.viz import fvtk >>> r=fvtk.ren() >>> a=fvtk.axes() >>> from dipy.viz import fvtk >>> r=fvtk.ren() >>> fvtk.add(r,fvtk.axes()) >>> #uncomment below to record >>> #fvtk.record(r,cam_pos=(0,0,-10)) ''' if ren==None: ren = vtk.vtkRenderer() ren.SetBackground(bgr_color) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(size[0],size[1]) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) #ren.GetActiveCamera().Azimuth(180) ''' # We'll set up the view we want. ren.GetActiveCamera().SetPosition(0, 1, 0) ren.GetActiveCamera().SetFocalPoint(0, 0, 0) ren.GetActiveCamera().SetViewUp(0, 0, 1) # Let the renderer compute a good position and focal point. ren.ResetCamera() ren.GetActiveCamera().Dolly(1.4) ren.ResetCameraClippingRange() ''' renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(ren) renderLarge.SetMagnification(magnification) renderLarge.Update() writer = vtk.vtkPNGWriter() ang=0 if cam_pos!=None: cx,cy,cz=cam_pos ren.GetActiveCamera().SetPosition(cx,cy,cz) if cam_focal!=None: fx,fy,fz=cam_focal ren.GetActiveCamera().SetFocalPoint(fx,fy,fz) if cam_view!=None: ux,uy,uz=cam_view ren.GetActiveCamera().SetViewUp(ux, uy, uz) for i in range(n_frames): ren.GetActiveCamera().Azimuth(ang) renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(ren) renderLarge.SetMagnification(magnification) renderLarge.Update() writer.SetInputConnection(renderLarge.GetOutputPort()) #filename='/tmp/'+str(3000000+i)+'.png' if outdir==None: filename=str(1000000+i)+'.png' else: filename=outdir+str(1000000+i)+'.png' writer.SetFileName(filename) writer.Write() ang=+az_ang
def streampoints(filename): reader = vtk.vtkStructuredPointsReader() reader.SetFileName(filename) reader.Update() outline=vtk.vtkOutlineFilter() outline.SetInputConnection(reader.GetOutputPort()) lineMapper = vtk.vtkDataSetMapper() lineMapper.SetInputConnection(outline.GetOutputPort()) lineActor = vtk.vtkActor() lineActor.SetMapper(lineMapper) pdata=vtk.vtkPolyData() points=vtk.vtkPoints() #Selecting source for Streamtracer ns=200 r=100 Z=25 for i in range(0, ns): a=(2*i*pi)/ns X=r*cos(a) Y=r*sin(a) # for Z in range(0,256): points.InsertNextPoint(float(X),float(Y),float(Z)) pdata.SetPoints(points) integ0 = vtk.vtkRungeKutta4() integ1 = vtk.vtkRungeKutta4() integ2 = vtk.vtkRungeKutta4() # Defining controller for vtkDistributedStreamTracer controller=vtk.vtkMPIController() Stream0 = vtk.vtkDistributedStreamTracer() #Stream0 = vtk.vtkStreamTracer() Stream0.SetInputConnection(reader.GetOutputPort()) Stream0.SetSource(line0.GetOutput()) #Stream0.SetSource(pdata) # Setting the parameters for Integration. Here you can change the integration parameters according to your desire. Stream0.SetMaximumPropagation(255) Stream0.SetController(controller) Stream0.SetInitialIntegrationStepUnitToCellLengthUnit() Stream0.SetMaximumIntegrationStep(2000) Stream0.SetInitialIntegrationStep(0.5) Stream0.SetIntegrator(integ0) Stream0.SetIntegrationDirectionToBoth() Stream0.Update() # Visualizing streamline as a tube.Here you can change the radius of the streamtube by changing the values of radius. streamTube0 = vtk.vtkTubeFilter() streamTube0.SetInputConnection(Stream0.GetOutputPort()) streamTube0.SetRadius(0.25) streamTube0.SetNumberOfSides(16) #streamTube0.SetVaryRadiusToVaryRadiusByVector() mapStreamTube0 = vtk.vtkPolyDataMapper() mapStreamTube0.SetInputConnection(streamTube0.GetOutputPort()) #mapStreamTube.SetScalarRange(reader.GetOutput()) streamTubeActor0 = vtk.vtkActor() streamTubeActor0.SetMapper(mapStreamTube0) streamTubeActor0.GetProperty().BackfaceCullingOn() streamTubeActor0.GetProperty().SetColor(0, 1, 1) Stream1 = vtk.vtkDistributedStreamTracer() #Stream0 = vtk.vtkStreamTracer() Stream1.SetInputConnection(reader.GetOutputPort()) Stream1.SetSource(line1.GetOutput()) #Stream0.SetSource(pdata) Stream1.SetMaximumPropagation(255) Stream1.SetController(controller) Stream1.SetInitialIntegrationStepUnitToCellLengthUnit() Stream1.SetMaximumIntegrationStep(2000) Stream1.SetInitialIntegrationStep(0.5) Stream1.SetIntegrator(integ1) Stream1.SetIntegrationDirectionToBoth() Stream1.Update() streamTube1= vtk.vtkTubeFilter() streamTube1.SetInputConnection(Stream0.GetOutputPort()) streamTube1.SetRadius(0.25) streamTube1.SetNumberOfSides(12) #streamTube1.SetVaryRadiusToVaryRadiusByVector() mapStreamTube1 = vtk.vtkPolyDataMapper() mapStreamTube1.SetInputConnection(streamTube1.GetOutputPort()) #mapStreamTube.SetScalarRange(reader.GetOutput()) streamTubeActor1 = vtk.vtkActor() streamTubeActor1.SetMapper(mapStreamTube1) streamTubeActor1.GetProperty().BackfaceCullingOn() streamTubeActor1.GetProperty().SetColor(0.5, 0.25, 1) #ren.AddActor(lineActor) Stream2 = vtk.vtkDistributedStreamTracer() #Stream0 = vtk.vtkStreamTracer() Stream2.SetInputConnection(reader.GetOutputPort()) Stream2.SetSource(line2.GetOutput()) #Stream2.SetSource(line1.GetOutput()) #Stream2.SetSource(line0.GetOutput()) #Stream0.SetSource(pdata) Stream2.SetMaximumPropagation(255) Stream2.SetController(controller) Stream2.SetInitialIntegrationStepUnitToCellLengthUnit() Stream2.SetMaximumIntegrationStep(2000) Stream2.SetInitialIntegrationStep(0.5) Stream2.SetIntegrator(integ2) Stream2.SetIntegrationDirectionToBoth() Stream2.Update() streamTube2= vtk.vtkTubeFilter() streamTube2.SetInputConnection(Stream0.GetOutputPort()) streamTube2.SetRadius(0.25) streamTube2.SetNumberOfSides(12) #streamTube2.SetVaryRadiusToVaryRadiusByVector() mapStreamTube2 = vtk.vtkPolyDataMapper() mapStreamTube2.SetInputConnection(streamTube2.GetOutputPort()) #mapStreamTube.SetScalarRange(reader.GetOutput()) streamTubeActor2 = vtk.vtkActor() streamTubeActor2.SetMapper(mapStreamTube2) streamTubeActor2.GetProperty().BackfaceCullingOn() streamTubeActor2.GetProperty().SetColor(0, .025, 0.125) # ren.AddActor(lineActor) # Adding the streanline to the actor for rendering ren.AddActor(streamTubeActor0) ren.AddActor(streamTubeActor1) #ren.AddActor(streamTubeActor2) renWin.Render() ren.ResetCamera() # Selecting renderer good position and focal point. Here You can change the camera positin for viewing a good image that you need. ren.GetActiveCamera().SetPosition(0, 1,0) ren.GetActiveCamera().SetFocalPoint(0,0,0) ren.GetActiveCamera().SetViewUp(0,0 , 1) ren.GetActiveCamera().Dolly(1.4) ren.ResetCameraClippingRange() largestreamline=vtk.vtkRenderLargeImage() largestreamline.SetInput(ren) largestreamline.SetMagnification(9) #cam1 = ren.GetActiveCamera().Zoom(z) #cam1 = ren.GetActiveCamera().Elevation(2) #cam1 = ren.GetActiveCamera().Azimuth(-5) #ren.SetActiveCamera(cam1) ren.ResetCamera() # Writing .PNG Images of the streamlines with images. writer = vtk.vtkPNGWriter() writer.SetInputConnection(largestreamline.GetOutputPort()) writer.SetFileName("Streamline.png") writer.Modified() writer.Write()
def DisplayCone(nc): ''' Create a cone, contour it using the banded contour filter and color it with the primary additive and subtractive colors. :param: nc: The vtkNamedColor class :return: The render window interactor. ''' # Create a cone coneSource = vtk.vtkConeSource() coneSource.SetCenter(0.0, 0.0, 0.0) coneSource.SetRadius(5.0) coneSource.SetHeight(10) coneSource.SetDirection(0, 1, 0) coneSource.Update() bounds = [1.0, -1.0, 1.0, -1.0, 1.0, -1.0] coneSource.GetOutput().GetBounds(bounds) elevation = vtk.vtkElevationFilter() elevation.SetInputConnection(coneSource.GetOutputPort()) elevation.SetLowPoint(0, bounds[2], 0) elevation.SetHighPoint(0, bounds[3], 0) bcf = vtk.vtkBandedPolyDataContourFilter() bcf.SetInputConnection(elevation.GetOutputPort()) bcf.SetScalarModeToValue() bcf.GenerateContourEdgesOn() bcf.GenerateValues(7, elevation.GetScalarRange()) # Build a simple lookup table of # primary additive and subtractive colors. lut = vtk.vtkLookupTable() lut.SetNumberOfTableValues(7) # Test setting and getting a color here. # We are also modifying alpha. # Convert to a list so that # SetColor(name,rgba) works. rgba = list(nc.GetColor4d("Red")) rgba[3] = 0.5 nc.SetColor("My Red", rgba) rgba = nc.GetColor4d("My Red") lut.SetTableValue(0, rgba) # Does "My Red" match anything? match = FindSynonyms(nc, "My Red") print("Matching colors to My Red:", match) rgba = nc.GetColor4d("DarkGreen") rgba[3] = 0.3 lut.SetTableValue(1, rgba) # Alternatively we can use our wrapper functions: lut.SetTableValue(2, nc.GetColor4d("Blue")) lut.SetTableValue(3, nc.GetColor4d("Cyan")) lut.SetTableValue(4, nc.GetColor4d("Magenta")) lut.SetTableValue(5, nc.GetColor4d("Yellow")) lut.SetTableValue(6, nc.GetColor4d("White")) lut.SetTableRange(elevation.GetScalarRange()) lut.Build() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(bcf.GetOutputPort()) mapper.SetLookupTable(lut) mapper.SetScalarModeToUseCellData() contourLineMapper = vtk.vtkPolyDataMapper() contourLineMapper.SetInputData(bcf.GetContourEdgesOutput()) contourLineMapper.SetScalarRange(elevation.GetScalarRange()) contourLineMapper.SetResolveCoincidentTopologyToPolygonOffset() actor = vtk.vtkActor() actor.SetMapper(mapper) contourLineActor = vtk.vtkActor() actor.SetMapper(mapper) contourLineActor.SetMapper(contourLineMapper) contourLineActor.GetProperty().SetColor(nc.GetColor3d("black")) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(actor) renderer.AddActor(contourLineActor) renderer.SetBackground(nc.GetColor3d("SteelBlue")) renderWindow.Render() fnsave = "TestNamedColorsIntegration.png" renLgeIm = vtk.vtkRenderLargeImage() imgWriter = vtk.vtkPNGWriter() renLgeIm.SetInput(renderer) renLgeIm.SetMagnification(1) imgWriter.SetInputConnection(renLgeIm.GetOutputPort()) imgWriter.SetFileName(fnsave) # imgWriter.Write() return renderWindowInteractor
def render_cam_view(cadmodel, calibration, extra_actors=[], filename=None, oversampling=1, aa=1, transparency=False, verbose=True, coords='Display', interpolation='Cubic'): ''' Render an image of a given CAD model from the point of view of a given calibration. Parameters: cadmodel (calcam.CADModel) : CAD model of scene calibration (calcam.Calibration) : Calibration whose point-of-view to render from. extra_actors (list of vtk.vtkActor) : List containing any additional vtkActors to add to the scene \ in addition to the CAD model. filename (str) : Filename to which to save the resulting image. If not given, no file is saved. oversampling (float) : Used to render the image at higer (if > 1) or lower (if < 1) resolution than the \ calibrated camera. Must be an integer power of 2. aa (int) : Anti-aliasing factor. 1 = no anti-aliasing. transparency (bool) : If true, empty areas of the image are set transparent. Otherwise they are black. verbose (bool) : Whether to print status updates while rendering. coords (str) : Either ``Display`` or ``Original``, the image orientation in which to return the image. interpolation(str) : Either ``nearest`` or ``cubic``, inerpolation used if re-sampling of the image during \ the rendering process. Note: if set to ``nesrest``, will make aa > 1 ineffective. Returns: np.ndarray : Array containing the rendered 8-bit per channel RGB (h x w x 3) or RGBA (h x w x 4) image.\ Also saves the result to disk if the filename parameter is set. ''' if np.any(calibration.view_models) is None: raise ValueError( 'This calibration object does not contain any fit results! Cannot render an image without a calibration fit.' ) if coords.lower() == 'original' and oversampling != 1: raise Exception( 'Cannot render in original coordinates with oversampling!') if interpolation.lower() == 'nearest': interp_method = cv2.INTER_NEAREST elif interpolation.lower() == 'cubic': interp_method = cv2.INTER_CUBIC else: raise ValueError('Interpolation method must be "nearest" or "cubic".') logbase2 = np.log(oversampling) / np.log(2) if abs(int(logbase2) - logbase2) > 1e-5: raise ValueError('Oversampling must be a power of two!') if verbose: tstart = time.time() print('[Calcam Renderer] Preparing...') # This will be our result. To start with we always render in display coords. orig_display_shape = calibration.geometry.get_display_shape() output = np.zeros([ int(orig_display_shape[1] * oversampling), int(orig_display_shape[0] * oversampling), 3 + transparency ], dtype='uint8') # The un-distorted FOV is over-rendered to allow for distortion. # FOV_factor is how much to do this by; too small and image edges might be cut off. models = [] for view_model in calibration.view_models: try: models.append(view_model.model) except AttributeError: pass if np.any(np.array(models) == 'fisheye'): fov_factor = 3. else: fov_factor = 1.5 x_pixels = orig_display_shape[0] y_pixels = orig_display_shape[1] renwin = vtk.vtkRenderWindow() renwin.OffScreenRenderingOn() # Set up render window for initial, un-distorted window renderer = vtk.vtkRenderer() renwin.AddRenderer(renderer) camera = renderer.GetActiveCamera() cad_linewidths = np.array(cadmodel.get_linewidth()) cadmodel.set_linewidth(list(cad_linewidths * aa)) cadmodel.add_to_renderer(renderer) for actor in extra_actors: actor.GetProperty().SetLineWidth(actor.GetProperty().GetLineWidth() * aa) renderer.AddActor(actor) # We need a field mask the same size as the output fieldmask = cv2.resize( calibration.get_subview_mask(coords='Display'), (int(x_pixels * oversampling), int(y_pixels * oversampling)), interpolation=cv2.INTER_NEAREST) for field in range(calibration.n_subviews): if calibration.view_models[field] is None: continue cx = calibration.view_models[field].cam_matrix[0, 2] cy = calibration.view_models[field].cam_matrix[1, 2] fy = calibration.view_models[field].cam_matrix[1, 1] vtk_win_im = vtk.vtkRenderLargeImage() vtk_win_im.SetInput(renderer) # Width and height - initial render will be put optical centre in the window centre wt = int(2 * fov_factor * max(cx, x_pixels - cx)) ht = int(2 * fov_factor * max(cy, y_pixels - cy)) # Make sure the intended render window will fit on the screen. # This makes the (reasonable) assumption that the current display is > 640x480. # Doing this is required because if the off-screen render wndow is # bigger than the current screen resolution, the image alignment comes out wrong. window_factor = 1 if wt > 640 or ht > 480: window_factor = int( max(np.ceil(float(wt) / 640.), np.ceil(float(ht) / 480.))) vtk_win_im.SetMagnification( int(window_factor * aa * max(oversampling, 1))) width = int(wt / window_factor) height = int(ht / window_factor) renwin.SetSize(width, height) # Set up CAD camera fov_y = 360 * np.arctan(ht / (2 * fy)) / 3.14159 cam_pos = calibration.get_pupilpos(subview=field) cam_tar = calibration.get_los_direction(cx, cy, subview=field) + cam_pos upvec = -1. * calibration.get_cam_to_lab_rotation(subview=field)[:, 1] camera.SetPosition(cam_pos) camera.SetViewAngle(fov_y) camera.SetFocalPoint(cam_tar) camera.SetViewUp(upvec) if verbose: print('[Calcam Renderer] Rendering (Sub-view {:d}/{:d})...'.format( field + 1, calibration.n_subviews)) # Do the render and grab an image renwin.Render() # Make sure the light lights up the whole model without annoying shadows or falloff. light = renderer.GetLights().GetItemAsObject(0) light.PositionalOn() light.SetConeAngle(180) # Do the render and grab an image renwin.Render() vtk_win_im.Update() vtk_image = vtk_win_im.GetOutput() vtk_array = vtk_image.GetPointData().GetScalars() dims = vtk_image.GetDimensions() im = np.flipud(vtk_to_numpy(vtk_array).reshape(dims[1], dims[0], 3)) if transparency: alpha = 255 * np.ones( [np.shape(im)[0], np.shape(im)[1]], dtype='uint8') alpha[np.sum(im, axis=2) == 0] = 0 im = np.dstack((im, alpha)) im = cv2.resize(im, (int(dims[0] / aa * min(oversampling, 1)), int(dims[1] / aa * min(oversampling, 1))), interpolation=interp_method) if verbose: print( '[Calcam Renderer] Applying lens distortion (Sub-view {:d}/{:d})...' .format(field + 1, calibration.n_subviews)) # Pixel locations we want on the final image [xn, yn ] = np.meshgrid(np.linspace(0, x_pixels - 1, x_pixels * oversampling), np.linspace(0, y_pixels - 1, y_pixels * oversampling)) xn, yn = calibration.normalise(xn, yn, field) # Transform back to pixel coords where we want to sample the un-distorted render. # Both x and y are divided by Fy because the initial render always has Fx = Fy. xmap = ((xn * fy) + (width * window_factor) / 2.) * oversampling ymap = ((yn * fy) + (height * window_factor) / 2.) * oversampling xmap = xmap.astype('float32') ymap = ymap.astype('float32') # Actually apply distortion im = cv2.remap(im, xmap, ymap, interp_method) output[fieldmask == field, :] = im[fieldmask == field, :] if coords.lower() == 'original': output = calibration.geometry.display_to_original_image( output, interpolation=interpolation) if verbose: print('[Calcam Renderer] Completed in {:.1f} s.'.format(time.time() - tstart)) # Save the image if given a filename if filename is not None: # If we have transparency, we can only save as PNG. if transparency and filename[-3:].lower() != 'png': print( '[Calcam Renderer] Images with transparency can only be saved as PNG! Overriding output file type to PNG.' ) filename = filename[:-3] + 'png' # Re-shuffle the colour channels for saving (openCV needs BGR / BGRA) save_im = copy.copy(output) save_im[:, :, :3] = save_im[:, :, 2::-1] cv2.imwrite(filename, save_im) if verbose: print('[Calcam Renderer] Result saved as {:s}'.format(filename)) # Tidy up after ourselves! cadmodel.set_linewidth(list(cad_linewidths)) cadmodel.remove_from_renderer(renderer) for actor in extra_actors: actor.GetProperty().SetLineWidth(actor.GetProperty().GetLineWidth() / aa) renderer.RemoveActor(actor) renwin.Finalize() return output
def record(scene=None, cam_pos=None, cam_focal=None, cam_view=None, out_path=None, path_numbering=False, n_frames=1, az_ang=10, magnification=1, size=(300, 300), reset_camera=True, verbose=False): """Record a video of your scene. Records a video as a series of ``.png`` files of your scene by rotating the azimuth angle az_angle in every frame. Parameters ----------- scene : Scene() or vtkRenderer() object Scene instance cam_pos : None or sequence (3,), optional Camera's position. If None then default camera's position is used. cam_focal : None or sequence (3,), optional Camera's focal point. If None then default camera's focal point is used. cam_view : None or sequence (3,), optional Camera's view up direction. If None then default camera's view up vector is used. out_path : str, optional Output path for the frames. If None a default fury.png is created. path_numbering : bool When recording it changes out_path to out_path + str(frame number) n_frames : int, optional Number of frames to save, default 1 az_ang : float, optional Azimuthal angle of camera rotation. magnification : int, optional How much to magnify the saved frame. Default is 1. size : (int, int) ``(width, height)`` of the window. Default is (300, 300). reset_camera : bool If True Call ``scene.reset_camera()``. Otherwise you need to set the camera before calling this function. verbose : bool print information about the camera. Default is False. Examples --------- >>> from fury import window, actor >>> scene = window.Scene() >>> a = actor.axes() >>> scene.add(a) >>> # uncomment below to record >>> # window.record(scene) >>> #check for new images in current directory """ if scene is None: scene = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(scene) renWin.SetSize(size[0], size[1]) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # scene.GetActiveCamera().Azimuth(180) if reset_camera: scene.ResetCamera() renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(scene) renderLarge.SetMagnification(magnification) renderLarge.Update() writer = vtk.vtkPNGWriter() ang = 0 if cam_pos is not None: cx, cy, cz = cam_pos scene.GetActiveCamera().SetPosition(cx, cy, cz) if cam_focal is not None: fx, fy, fz = cam_focal scene.GetActiveCamera().SetFocalPoint(fx, fy, fz) if cam_view is not None: ux, uy, uz = cam_view scene.GetActiveCamera().SetViewUp(ux, uy, uz) cam = scene.GetActiveCamera() if verbose: print('Camera Position (%.2f, %.2f, %.2f)' % cam.GetPosition()) print('Camera Focal Point (%.2f, %.2f, %.2f)' % cam.GetFocalPoint()) print('Camera View Up (%.2f, %.2f, %.2f)' % cam.GetViewUp()) for i in range(n_frames): scene.GetActiveCamera().Azimuth(ang) renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(scene) renderLarge.SetMagnification(magnification) renderLarge.Update() writer.SetInputConnection(renderLarge.GetOutputPort()) if path_numbering: if out_path is None: filename = str(i).zfill(6) + '.png' else: filename = out_path + str(i).zfill(6) + '.png' else: if out_path is None: filename = 'fury.png' else: filename = out_path writer.SetFileName(filename) writer.Write() ang = +az_ang
def DisplayCone(self): ''' Create a cone, contour it using the banded contour filter and color it with the primary additive and subtractive colors. ''' #print namedColors # Create a cone coneSource = vtk.vtkConeSource() coneSource.SetCenter(0.0, 0.0, 0.0) coneSource.SetRadius(5.0) coneSource.SetHeight(10) coneSource.SetDirection(0,1,0) coneSource.Update() bounds = [1.0,-1.0,1.0,-1.0,1.0,-1.0] coneSource.GetOutput().GetBounds(bounds) elevation = vtk.vtkElevationFilter() elevation.SetInputConnection(coneSource.GetOutputPort()) elevation.SetLowPoint(0,bounds[2],0) elevation.SetHighPoint(0,bounds[3],0) bcf = vtk.vtkBandedPolyDataContourFilter() bcf.SetInputConnection(elevation.GetOutputPort()) bcf.SetScalarModeToValue() bcf.GenerateContourEdgesOn() bcf.GenerateValues(7,elevation.GetScalarRange()) # Build a simple lookup table of # primary additive and subtractive colors. lut = vtk.vtkLookupTable() lut.SetNumberOfTableValues(7) # Test setting and getting a color here. # We are also modifying alpha. rgba = self.GetRGBAColor("Red") rgba[3] = 0.5 self.namedColors.SetColor("My Red",rgba) rgba = self.GetRGBAColor("My Red") lut.SetTableValue(0,rgba) # Does "My Red" match anything? match = self.FindSynonyms("My Red") print "Matching colors to My Red:", match rgba = self.GetRGBAColor("DarkGreen") rgba[3] = 0.3 lut.SetTableValue(1,rgba) # Alternatively we can use our wrapper functions: lut.SetTableValue(2,self.GetRGBAColor("Blue")) lut.SetTableValue(3,self.GetRGBAColor("Cyan")) lut.SetTableValue(4,self.GetRGBAColor("Magenta")) lut.SetTableValue(5,self.GetRGBAColor("Yellow")) lut.SetTableValue(6,self.GetRGBAColor("White")) lut.SetTableRange(elevation.GetScalarRange()) lut.Build() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(bcf.GetOutputPort()) mapper.SetLookupTable(lut) mapper.SetScalarModeToUseCellData() contourLineMapper = vtk.vtkPolyDataMapper() contourLineMapper.SetInputData(bcf.GetContourEdgesOutput()) contourLineMapper.SetScalarRange(elevation.GetScalarRange()) contourLineMapper.SetResolveCoincidentTopologyToPolygonOffset() actor = vtk.vtkActor() actor.SetMapper(mapper) contourLineActor = vtk.vtkActor() actor.SetMapper(mapper) contourLineActor.SetMapper(contourLineMapper) contourLineActor.GetProperty().SetColor( self.GetRGBColor("black")) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(actor) renderer.AddActor(contourLineActor) renderer.SetBackground( self.GetRGBColor("SteelBlue")) renderWindow.Render() fnsave = "TestNamedColorsIntegration.png" renLgeIm = vtk.vtkRenderLargeImage() imgWriter = vtk.vtkPNGWriter() renLgeIm.SetInput(renderer) renLgeIm.SetMagnification(1) imgWriter.SetInputConnection(renLgeIm.GetOutputPort()) imgWriter.SetFileName(fnsave) imgWriter.Write() renderWindowInteractor.Start()
def saveRendererToImg(renderer,fnOut,magnification=10): """Saves renderer to image file. Supported extensions are: * '.ps' (PostScript) * '.eps' (Encapsualted PostScript) * '.pdf' (Portable Document Format) * '.jpg' (Joint Photographic Experts Group) * '.png' (Portable Network Graphics) * '.pnm' (Portable Any Map) * '.tif' (Tagged Image File Format) * '.bmp' (Bitmap Image) Some code taken from http://www.programcreek.com/python/example/23102/vtk.vtkGL2PSExporter . Args: fnOut (str): Path to output file. renderer (vtk.vtkOpenGLRenderer): Renderer. Keyword Args: magnification (int): Degree of magnification. Returns: vtk.vtkExporter: Exporter object. """ #Generate exporter vtkImageWriters = { '.tif': vtk.vtkTIFFWriter(), '.tiff': vtk.vtkTIFFWriter(), '.bmp': vtk.vtkBMPWriter(), '.pnm': vtk.vtkPNMWriter(), '.png': vtk.vtkPNGWriter(), '.jpg': vtk.vtkJPEGWriter(), '.jpeg': vtk.vtkJPEGWriter(), '.ps': vtk.vtkPostScriptWriter(), '.eps': vtk.vtkPostScriptWriter(), } #Get extension basename,ext=os.path.splitext(fnOut) #Large Image renderer for nicer images rendererLarge=vtk.vtkRenderLargeImage() rendererLarge.SetInput(renderer) rendererLarge.SetMagnification(magnification) #Get proper writer try: writer = vtkImageWriters[ext.lower()] except KeyError: printError("Extension "+ext+" is currently not supported") return None #Write writer.SetFileName(fnOut) writer.SetInputConnection(rendererLarge.GetOutputPort()) writer.Write() return writer
def setupPipeline(): #read file global reader reader = vtk.vtkOBJReader() reader.SetFileName(filename) #map 3d model global mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(reader.GetOutputPort()) #set actor global actor actor = vtk.vtkActor() actor.SetMapper(mapper) # Create a rendering window and renderer global ren ren = vtk.vtkRenderer() ren.SetBackground(0, 0, 0) ren.AddActor(actor) global intermediateWindow intermediateWindow = vtk.vtkRenderWindow() intermediateWindow.AddRenderer(ren) #render image global renImage renImage = vtk.vtkRenderLargeImage() renImage.SetInput(ren) renImage.SetMagnification(magnificationFactor) #Canny edge detector inspired by #https://vtk.org/Wiki/VTK/Examples/Cxx/Images/CannyEdgeDetector #to grayscale global lumImage lumImage = vtk.vtkImageLuminance() lumImage.SetInputConnection(renImage.GetOutputPort()) #to float global floatImage floatImage = vtk.vtkImageCast() floatImage.SetOutputScalarTypeToFloat() floatImage.SetInputConnection(lumImage.GetOutputPort()) #gaussian convolution global smoothImage smoothImage = vtk.vtkImageGaussianSmooth() smoothImage.SetInputConnection(floatImage.GetOutputPort()) smoothImage.SetDimensionality(2) smoothImage.SetRadiusFactors(1, 1, 0) #gradient global gradientImage gradientImage = vtk.vtkImageGradient() gradientImage.SetInputConnection(smoothImage.GetOutputPort()) gradientImage.SetDimensionality(2) #gradient magnitude global magnitudeImage magnitudeImage = vtk.vtkImageMagnitude() magnitudeImage.SetInputConnection(gradientImage.GetOutputPort()) #non max suppression global nonmaxSuppr nonmaxSuppr = vtk.vtkImageNonMaximumSuppression() nonmaxSuppr.SetDimensionality(2) #padding global padImage padImage = vtk.vtkImageConstantPad() padImage.SetInputConnection(gradientImage.GetOutputPort()) padImage.SetOutputNumberOfScalarComponents(3) padImage.SetConstant(0) #to structured points global i2sp1 i2sp1 = vtk.vtkImageToStructuredPoints() i2sp1.SetInputConnection(nonmaxSuppr.GetOutputPort()) #link edges global linkImage linkImage = vtk.vtkLinkEdgels() linkImage.SetInputConnection(i2sp1.GetOutputPort()) linkImage.SetGradientThreshold(2) #thresholds links global thresholdEdgels thresholdEdgels = vtk.vtkThreshold() thresholdEdgels.SetInputConnection(linkImage.GetOutputPort()) thresholdEdgels.ThresholdByUpper(10) thresholdEdgels.AllScalarsOff() #filter global gf gf = vtk.vtkGeometryFilter() gf.SetInputConnection(thresholdEdgels.GetOutputPort()) #to structured points global i2sp i2sp = vtk.vtkImageToStructuredPoints() i2sp.SetInputConnection(magnitudeImage.GetOutputPort()) #subpixel global spe spe = vtk.vtkSubPixelPositionEdgels() spe.SetInputConnection(gf.GetOutputPort()) #stripper global strip strip = vtk.vtkStripper() strip.SetInputConnection(spe.GetOutputPort()) global dsm dsm = vtk.vtkPolyDataMapper() dsm.SetInputConnection(strip.GetOutputPort()) dsm.ScalarVisibilityOff() global planeActor planeActor = vtk.vtkActor() planeActor.SetMapper(dsm) planeActor.GetProperty().SetAmbient(1.0) planeActor.GetProperty().SetDiffuse(0.0) global edgeRender edgeRender = vtk.vtkRenderer() edgeRender.AddActor(planeActor) global renderWindow renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(edgeRender) global finalImage finalImage = vtk.vtkRenderLargeImage() finalImage.SetMagnification(magnificationFactor) finalImage.SetInput(edgeRender) global revImage revImage = vtk.vtkImageThreshold() revImage.SetInputConnection(finalImage.GetOutputPort()) revImage.ThresholdByUpper(127) revImage.ReplaceInOn() revImage.ReplaceOutOn() revImage.SetOutValue(255) revImage.SetInValue(0) #write image global imgWriter imgWriter = vtk.vtkPNGWriter() imgWriter.SetInputConnection(revImage.GetOutputPort()) imgWriter.SetFileName("test.png")
def showVtkPolyData(self, pdata, windowSizeX=600, windowSizeY=400, filename=''): """ Show the boundary surface or write image to file @param pdata vtkPolyData instance @param windowSizeX number of pixels in x @param windowSizeY number of pixels in y @param filename write to a file if this keyword is present and a non-empty string """ # Create a rendering window and renderer. try: ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() iren = vtk.vtkRenderWindowInteractor() camera = vtk.vtkCamera() mapper = vtk.vtkPolyDataMapper() actor = vtk.vtkActor() axes = [vtk.vtkArrowSource(), vtk.vtkArrowSource(), vtk.vtkArrowSource()] axesTransf = [vtk.vtkTransform(), vtk.vtkTransform(), vtk.vtkTransform()] axesTPD = [vtk.vtkTransformPolyDataFilter(), vtk.vtkTransformPolyDataFilter(), vtk.vtkTransformPolyDataFilter()] axesMappers = [vtk.vtkPolyDataMapper(), vtk.vtkPolyDataMapper(), vtk.vtkPolyDataMapper()] axesActors = [vtk.vtkActor(), vtk.vtkActor(), vtk.vtkActor()] renderLarge = vtk.vtkRenderLargeImage() except: print('WARNING: Cannot call show method -- likely missing VTK') return renWin.AddRenderer(ren) renWin.SetSize(windowSizeX, windowSizeY) # Create a renderwindowinteractor. iren.SetRenderWindow(renWin) # Camera xmin, xmax, ymin, ymax, zmin, zmax = pdata.GetBounds() lo = numpy.array([xmin, ymin, zmin]) hi = numpy.array([xmax, ymax, zmax]) camera.SetFocalPoint(hi) center = 0.5*(lo + hi) camera.SetPosition(center + hi - lo) camera.Zoom(1.0) ren.SetActiveCamera(camera) # Mapper. if vtk.VTK_MAJOR_VERSION >= 6: mapper.SetInputData(pdata) else: mapper.SetInput(pdata) # Actor. actor.SetMapper(mapper) actor.GetProperty().SetColor(1, 1, 1) # Add axes. axesColrs = [(1., 0., 0.,), (0., 1., 0.,), (0., 0., 1.,)] for a in axes: a.SetShaftRadius(0.01) a.SetTipLength(0.2) a.SetTipRadius(0.03) for at in axesTransf: at.PostMultiply() # Rotate the y and z arrows (initially along x). axesTransf[1].RotateZ(90.0) axesTransf[2].RotateY(-90.0) # Scale. for i in range(3): factor = hi[i] - lo[i] scale = [1., 1., 1.] scale[i] = factor axesTransf[i].Scale(scale) # Translate to loBounds. for at in axesTransf: at.Translate(lo) for i in range(3): axesTPD[i].SetInputConnection(axes[i].GetOutputPort()) axesTPD[i].SetTransform(axesTransf[i]) axesMappers[i].SetInputConnection(axesTPD[i].GetOutputPort()) axesActors[i].SetMapper(axesMappers[i]) axesActors[i].GetProperty().SetColor(axesColrs[i]) ren.AddActor(axesActors[i]) # Assign actor to the renderer. ren.AddActor(actor) # Write to file. writer = None if filename: if filename.lower().find('.png') > 0: writer = vtk.vtkPNGWriter() elif filename.lower().find('.jp') > 0: writer = vtk.vtkJPEGWriter() elif filename.lower().find('.tiff') > 0: writer = vtk.vtkTIFFWriter() if writer: renderLarge.SetInput(ren) renderLarge.SetMagnification(1) renderLarge.Update() writer.SetFileName(filename) writer.SetInputConnection(renderLarge.GetOutputPort()) writer.Write() else: # Fire up interactor. iren.Initialize() renWin.Render() iren.Start()
def plotSurface(domain): domain.GetOutput().GetPointData().SetActiveScalars('TS') lut = vtk.vtkLookupTable() lut.SetNumberOfColors(16) lut.SetHueRange(2/3,0.0) #lut.SetValueRange (270, 273); lut.SetNanColor(1,1,1,0.5) lut.SetNumberOfTableValues(3) lut.SetNumberOfColors(16) lut.Build() # create a rendering window and renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) WIDTH=1200 HEIGHT=1200 renWin.SetSize(WIDTH,HEIGHT) # create a renderwindowinteractor joystickStyle = vtk.vtkInteractorStyleJoystickCamera() iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.SetInteractorStyle(joystickStyle) # mapper coneMapper = vtk.vtkDataSetMapper() coneMapper.SetInputData(domain.GetOutput()) coneMapper.SetScalarModeToUsePointData() coneMapper.ScalarVisibilityOn() coneMapper.SetLookupTable(lut) coneMapper.SetScalarRange(domain.GetOutput().GetPointData().GetArray("TS").GetRange()) # actor coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) coneActor.SetScale(1,1,50) coneActor.GetProperty().SetEdgeColor(0.7,0.7,0.7) #coneActor.GetProperty().EdgeVisibilityOn() coneActor.GetProperty().SetAmbient(0.0) coneActor.GetProperty().SetSpecularPower(0) coneActor.GetProperty().SetDiffuse(1) cam = vtk.vtkCamera() cam.SetPosition(10.89,46.83,0.07) #cam.SetPosition(10.89,46.83,0.08) cam.SetFocalPoint(10.82,46.83,0.02) cam.SetViewUp(0,0,1) # assign actor to the renderer ren.SetBackground(1,1,1) ren.AddActor(coneActor) ren.SetActiveCamera(cam) ren.ResetCamera() # enable user interface interactor #iren.Initialize() renWin.OffScreenRenderingOn() renWin.Render() #iren.Start() renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(ren) renderLarge.SetMagnification(5) # w2if = vtk.vtkWindowToImageFilter() # w2if.SetInputConnection(renderLarge.GetOutputPort()) # w2if.Update() writer = vtk.vtkPNGWriter() writer.SetInputConnection(renderLarge.GetOutputPort()) writer.SetFileName('cosipy.png') writer.Write()
def record(scene=None, cam_pos=None, cam_focal=None, cam_view=None, out_path=None, path_numbering=False, n_frames=1, az_ang=10, magnification=1, size=(300, 300), reset_camera=True, screen_clip=False, stereo='off', verbose=False): """Record a video of your scene. Records a video as a series of ``.png`` files of your scene by rotating the azimuth angle az_angle in every frame. Parameters ----------- scene : Scene() or vtkRenderer() object Scene instance cam_pos : None or sequence (3,), optional Camera's position. If None then default camera's position is used. cam_focal : None or sequence (3,), optional Camera's focal point. If None then default camera's focal point is used. cam_view : None or sequence (3,), optional Camera's view up direction. If None then default camera's view up vector is used. out_path : str, optional Output path for the frames. If None a default fury.png is created. path_numbering : bool When recording it changes out_path to out_path + str(frame number) n_frames : int, optional Number of frames to save, default 1 az_ang : float, optional Azimuthal angle of camera rotation. magnification : int, optional How much to magnify the saved frame. Default is 1. size : (int, int) ``(width, height)`` of the window. Default is (300, 300). screen_clip: bool Clip the the png based on screen resolution. Default is False. reset_camera : bool If True Call ``scene.reset_camera()``. Otherwise you need to set the camera before calling this function. stereo: string Set the stereo type. Default is 'off'. Other types include: * 'opengl': OpenGL frame-sequential stereo. Referred to as 'CrystalEyes' by VTK. * 'anaglyph': For use with red/blue glasses. See VTK docs to use different colors. * 'interlaced': Line interlaced. * 'checkerboard': Checkerboard interlaced. * 'left': Left eye only. * 'right': Right eye only. * 'horizontal': Side-by-side. verbose : bool print information about the camera. Default is False. Examples --------- >>> from fury import window, actor >>> scene = window.Scene() >>> a = actor.axes() >>> scene.add(a) >>> # uncomment below to record >>> # window.record(scene) >>> # check for new images in current directory """ if scene is None: scene = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.SetBorders(screen_clip) renWin.AddRenderer(scene) renWin.SetSize(size[0], size[1]) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # scene.GetActiveCamera().Azimuth(180) if reset_camera: scene.ResetCamera() if stereo.lower() != 'off': enable_stereo(renWin, stereo) renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(scene) renderLarge.SetMagnification(magnification) renderLarge.Update() ang = 0 if cam_pos is not None: cx, cy, cz = cam_pos scene.GetActiveCamera().SetPosition(cx, cy, cz) if cam_focal is not None: fx, fy, fz = cam_focal scene.GetActiveCamera().SetFocalPoint(fx, fy, fz) if cam_view is not None: ux, uy, uz = cam_view scene.GetActiveCamera().SetViewUp(ux, uy, uz) cam = scene.GetActiveCamera() if verbose: print('Camera Position (%.2f, %.2f, %.2f)' % cam.GetPosition()) print('Camera Focal Point (%.2f, %.2f, %.2f)' % cam.GetFocalPoint()) print('Camera View Up (%.2f, %.2f, %.2f)' % cam.GetViewUp()) for i in range(n_frames): scene.GetActiveCamera().Azimuth(ang) renderLarge = vtk.vtkRenderLargeImage() renderLarge.SetInput(scene) renderLarge.SetMagnification(magnification) renderLarge.Update() if path_numbering: if out_path is None: filename = str(i).zfill(6) + '.png' else: filename = out_path + str(i).zfill(6) + '.png' else: if out_path is None: filename = 'fury.png' else: filename = out_path arr = numpy_support.vtk_to_numpy(renderLarge.GetOutput().GetPointData() .GetScalars()) w, h, _ = renderLarge.GetOutput().GetDimensions() components = renderLarge.GetOutput().GetNumberOfScalarComponents() arr = np.flipud(arr.reshape((h, w, components))) save_image(arr, filename) ang = +az_ang
def saveRendererToImg(renderer, fnOut, magnification=10): """Saves renderer to image file. Supported extensions are: * '.ps' (PostScript) * '.eps' (Encapsualted PostScript) * '.pdf' (Portable Document Format) * '.jpg' (Joint Photographic Experts Group) * '.png' (Portable Network Graphics) * '.pnm' (Portable Any Map) * '.tif' (Tagged Image File Format) * '.bmp' (Bitmap Image) Some code taken from http://www.programcreek.com/python/example/23102/vtk.vtkGL2PSExporter . Args: fnOut (str): Path to output file. renderer (vtk.vtkOpenGLRenderer): Renderer. Keyword Args: magnification (int): Degree of magnification. Returns: vtk.vtkExporter: Exporter object. """ #Generate exporter vtkImageWriters = { '.tif': vtk.vtkTIFFWriter(), '.tiff': vtk.vtkTIFFWriter(), '.bmp': vtk.vtkBMPWriter(), '.pnm': vtk.vtkPNMWriter(), '.png': vtk.vtkPNGWriter(), '.jpg': vtk.vtkJPEGWriter(), '.jpeg': vtk.vtkJPEGWriter(), '.ps': vtk.vtkPostScriptWriter(), '.eps': vtk.vtkPostScriptWriter(), } #Get extension basename, ext = os.path.splitext(fnOut) #Large Image renderer for nicer images rendererLarge = vtk.vtkRenderLargeImage() rendererLarge.SetInput(renderer) rendererLarge.SetMagnification(magnification) #Get proper writer try: writer = vtkImageWriters[ext.lower()] except KeyError: printError("Extension " + ext + " is currently not supported") return None #Write writer.SetFileName(fnOut) writer.SetInputConnection(rendererLarge.GetOutputPort()) writer.Write() return writer