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 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 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 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 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
