def get_camera_info(obj, ev):
if iren.GetKeyCode() == "s":
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renWin)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName("screenshot.png")
writer.SetInputData(w2if.GetOutput())
writer.Write()
print("screenshot saved")
# save to pdf
if iren.GetKeyCode() == "s":
exp = vtk.vtkGL2PSExporter()
exp.SetRenderWindow(renWin)
exp.SetFilePrefix("screenpdf")
exp.SetFileFormat(2)
exp.SetCompress(False)
exp.SetLandscape(False)
exp.SetSortToBSP()
# exp.SetSortToSimple() # less expensive sort algorithm
exp.DrawBackgroundOn()
exp.SetWrite3DPropsAsRasterImage(False)
def SavePDF():
pdf_number=__main__.pdf_number
option_verbose=__main__.option_verbose
option_prefix=__main__.option_prefix
renwin=__main__.renwin
rtTimer=vtk.vtkTimerLog
my_print(option_verbose,'----------------------------')
my_print(option_verbose,'Saving PDF')
rtStartCPU=rtTimer.GetCPUTime()
filepdf=option_prefix+'_%03d' %pdf_number
my_print(option_verbose,'Start writing PDF file', filepdf+'.pdf')
psw = vtk.vtkGL2PSExporter()
psw.SetInput(renwin)
#psw.SetFileFormatToPS()
psw.SetFileFormatToPDF()
#psw.SetFileFormatToEPS()
psw.SetSortToOff()
if __main__.option_projection == 'linear' :
psw.LandscapeOff()
psw.SetFilePrefix(filepdf)
psw.Write()
rtEndCPU=rtTimer.GetCPUTime()
my_print(option_verbose,'End writing PDF file')
my_print(option_verbose,'CPU time:', rtEndCPU-rtStartCPU)
__main__.pdf_number=pdf_number+1
def SavePDF():
pdf_number = __main__.pdf_number
option_verbose = __main__.option_verbose
option_prefix = __main__.option_prefix
renwin = __main__.renwin
rtTimer = vtk.vtkTimerLog
my_print(option_verbose, '----------------------------')
my_print(option_verbose, 'Saving PDF')
rtStartCPU = rtTimer.GetCPUTime()
filepdf = option_prefix + '_%03d' % pdf_number
my_print(option_verbose, 'Start writing PDF file', filepdf + '.pdf')
psw = vtk.vtkGL2PSExporter()
psw.SetInput(renwin)
#psw.SetFileFormatToPS()
psw.SetFileFormatToPDF()
#psw.SetFileFormatToEPS()
psw.SetSortToOff()
if __main__.option_projection == 'linear':
psw.LandscapeOff()
psw.SetFilePrefix(filepdf)
psw.Write()
rtEndCPU = rtTimer.GetCPUTime()
my_print(option_verbose, 'End writing PDF file')
my_print(option_verbose, 'CPU time:', rtEndCPU - rtStartCPU)
__main__.pdf_number = pdf_number + 1
def savefig3d(plt3d, file_prefix):
expo = vtk.vtkGL2PSExporter()
expo.SetFilePrefix(file_prefix)
expo.SetFileFormatToPDF()
expo.SetRenderWindow(plt3d.ren_win)
expo.Write()
return
def screenshot(filename="screenshot.png"):
"""
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
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(settings.plotter_instance.window)
s = settings.screeshotScale
w2if.SetScale(s, s)
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 save_screenshot(self, fn, ext):
if ext.lower() == '.eps':
exporter = vtk.vtkGL2PSExporter()
exporter.SetFileFormatToEPS()
#exporter.CompressOn()
exporter.SetFilePrefix(fn)
exporter.SetRenderWindow(self.frame.ren_win)
exporter.Write()
def save_exporter(renderwindow, base, extension):
base = base.encode(sys.getfilesystemencoding())
print 'save_exporter', base, '+', extension
try:
exporter = vtk.vtkGL2PSExporter()
except AttributeError, e:
return 'Can\'t export image: ' + unicode(e)
def screenshot(filename="screenshot.png", scale=None, returnNumpy=False):
"""
Save a screenshot of the current rendering window.
:param int scale: set image magnification
:param bool returnNumpy: return a numpy array of the image
"""
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)
if hasattr(w2if, 'SetScale'):
w2if.SetScale(scale, scale)
if settings.screenshotTransparentBackground:
w2if.SetInputBufferTypeToRGBA()
w2if.ReadFrontBufferOff() # read from the back buffer
w2if.Update()
if returnNumpy:
w2ifout = w2if.GetOutput()
npdata = vtk_to_numpy(w2ifout.GetPointData().GetArray("ImageScalars"))
npdata = npdata[:,[0,1,2]]
ydim, xdim, _ = w2ifout.GetDimensions()
npdata = npdata.reshape([xdim, ydim, -1])
npdata = np.flip(npdata, axis=0)
return npdata
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 ExportAsPDF(reportName, renWin):
vtkGL2PSExporter = vtk.vtkGL2PSExporter()
vtkGL2PSExporter.SetRenderWindow(renWin)
vtkGL2PSExporter.SetFileFormatToPDF()
filenameForPdf = reportName
vtkGL2PSExporter.DrawBackgroundOn()
vtkGL2PSExporter.SetFilePrefix(filenameForPdf)
vtkGL2PSExporter.SetFileFormatToPDF()
vtkGL2PSExporter.SetCompress(0)
vtkGL2PSExporter.Write()
def store_visualization(self, render_window):
file_name = str(QtGui.QFileDialog.getSaveFileName(
self,
'Save Visualization',
os.path.join(os.getcwd(), '/visualization.svg'),
'SVG-Images (*.svg)'
))
if len(file_name) > 0:
exporter = vtk.vtkGL2PSExporter()
exporter.SetRenderWindow(render_window)
exporter.SetFileFormatToSVG()
exporter.CompressOff()
exporter.DrawBackgroundOff()
exporter.SetFilePrefix(os.path.splitext(file_name)[0])
exporter.Write()
def vectorGraphics(self, output_type, file, width=None, height=None, units=None):
if self.renWin is None:
raise Exception("Nothing on Canvas to dump to file")
gl = vtk.vtkGL2PSExporter()
gl.SetInput(self.renWin)
gl.SetCompress(0) # Do not compress
gl.SetFilePrefix(".".join(file.split(".")[:-1]))
if output_type=="svg":
gl.SetFileFormatToSVG()
elif output_type == "ps":
gl.SetFileFormatToPS()
elif output_type=="pdf":
gl.SetFileFormatToPDF()
else:
raise Exception("Unknown format: %s" % output_type)
gl.Write()
def vectorGraphics(self, output_type, file, width=None, height=None, units=None):
if self.renWin is None:
raise Exception("Nothing on Canvas to dump to file")
self.hideGUI()
gl = vtk.vtkGL2PSExporter()
# This is the size of the initial memory buffer that holds the transformed
# vertices produced by OpenGL. If you start seeing a lot of warnings:
# GL2PS info: OpenGL feedback buffer overflow
# increase it to save some time.
# ParaView lags so we need a try/except around this
# in case it is a ParaView build
try:
gl.SetBufferSize(50*1024*1024) # 50MB
except:
pass
# Since the vcs layer stacks renderers to manually order primitives, sorting
# is not needed and will only slow things down and introduce artifacts.
gl.SetSortToOff()
gl.SetInput(self.renWin)
gl.SetCompress(0) # Do not compress
gl.SetFilePrefix(".".join(file.split(".")[:-1]))
gl.TextAsPathOn()
if output_type=="svg":
gl.SetFileFormatToSVG()
elif output_type == "ps":
gl.SetFileFormatToPS()
elif output_type=="pdf":
gl.SetFileFormatToPDF()
else:
raise Exception("Unknown format: %s" % output_type)
gl.Write()
plot = self.get3DPlot()
if plot: plot.showWidgets()
self.showGUI()
def vectorGraphics(self, output_type, file, width=None, height=None, units=None):
if self.renWin is None:
raise Exception("Nothing on Canvas to dump to file")
self.hideGUI()
gl = vtk.vtkGL2PSExporter()
# This is the size of the initial memory buffer that holds the transformed
# vertices produced by OpenGL. If you start seeing a lot of warnings:
# GL2PS info: OpenGL feedback buffer overflow
# increase it to save some time.
# ParaView lags so we need a try/except around this
# in case it is a ParaView build
try:
gl.SetBufferSize(50*1024*1024) # 50MB
except:
pass
# Since the vcs layer stacks renderers to manually order primitives, sorting
# is not needed and will only slow things down and introduce artifacts.
gl.SetSortToOff()
gl.SetInput(self.renWin)
gl.SetCompress(0) # Do not compress
gl.SetFilePrefix(".".join(file.split(".")[:-1]))
gl.TextAsPathOn()
if output_type=="svg":
gl.SetFileFormatToSVG()
elif output_type == "ps":
gl.SetFileFormatToPS()
elif output_type=="pdf":
gl.SetFileFormatToPDF()
else:
raise Exception("Unknown format: %s" % output_type)
gl.Write()
plot = self.get3DPlot()
if plot: plot.showWidgets()
self.showGUI()
def saveRendererToPS(renderer,fnOut):
"""Saves mesh to postscript file.
Supported extensions are:
* '.ps' (PostScript)
* '.eps' (Encapsualted PostScript)
* '.pdf' (Portable Document Format)
* '.tex' (LaTeX)
* '.svg' (Scalable Vector Graphics)
.. note:: This function imports *vtk*. *vtk* is only necessary in a few functions,
hence only imported when needed. This should make PyFRAP more portable.
Some code taken from http://www.programcreek.com/python/example/23102/vtk.vtkGL2PSExporter .
Args:
fnOut (str): Path to output file.
renderer (vtk.vtkOpenGLRenderer): Renderer.
Returns:
vtk.vtkGL2PSExporter: Exporter object.
"""
#Generate exporter
exp = vtk.vtkGL2PSExporter()
exp.SetRenderWindow(renderer)
#Get extension
basename,ext=os.path.splitext(fnOut)
vectorFileFormats = {'.ps': 0, '.eps': 1, '.pdf': 2, '.tex': 3,'.svg':4}
exp.SetFilePrefix(basename)
exp.SetFileFormat(vectorFileFormats[ext.lower()])
exp.Write()
return exp
def saveRendererToPS(renderer, fnOut):
"""Saves mesh to postscript file.
Supported extensions are:
* '.ps' (PostScript)
* '.eps' (Encapsualted PostScript)
* '.pdf' (Portable Document Format)
* '.tex' (LaTeX)
* '.svg' (Scalable Vector Graphics)
.. note:: This function imports *vtk*. *vtk* is only necessary in a few functions,
hence only imported when needed. This should make PyFRAP more portable.
Some code taken from http://www.programcreek.com/python/example/23102/vtk.vtkGL2PSExporter .
Args:
fnOut (str): Path to output file.
renderer (vtk.vtkOpenGLRenderer): Renderer.
Returns:
vtk.vtkGL2PSExporter: Exporter object.
"""
#Generate exporter
exp = vtk.vtkGL2PSExporter()
exp.SetRenderWindow(renderer)
#Get extension
basename, ext = os.path.splitext(fnOut)
vectorFileFormats = {'.ps': 0, '.eps': 1, '.pdf': 2, '.tex': 3, '.svg': 4}
exp.SetFilePrefix(basename)
exp.SetFileFormat(vectorFileFormats[ext.lower()])
exp.Write()
return exp
def testRasterEPS(self):
"""Test EPS output when Write3DPropsAsRasterImage is on."""
# Get a temporary file name. Set the extension to empty since
# the exporter appends a suitable extension.
tmp_eps = tempfile.mktemp('')
# Write an EPS file.
exp = vtk.vtkGL2PSExporter()
exp.SetRenderWindow(self.renWin)
exp.SetFilePrefix(tmp_eps)
# Turn off compression so PIL can read file.
exp.CompressOff()
exp.SetSortToOff()
exp.DrawBackgroundOn()
exp.Write3DPropsAsRasterImageOn()
exp.Write()
# Now read the EPS file using PIL.
tmp_eps += '.eps'
im = Image.open(tmp_eps)
# Get a temporary name for the PNG file.
tmp_png = tempfile.mktemp('.png')
im.save(tmp_png)
# Now read the saved image and compare it for the test.
png_r = vtk.vtkPNGReader()
png_r.SetFileName(tmp_png)
png_r.Update()
img = png_r.GetOutput()
# Cleanup. Do this first because if the test fails, an
# exception is raised and the temporary files won't be
# removed.
self._cleanup([tmp_eps, tmp_png])
img_file = "TestGL2PSExporter.png"
Testing.compareImageWithSavedImage(img,
Testing.getAbsImagePath(img_file))
# Interact if necessary.
Testing.interact()
def testRasterEPS(self):
"""Test EPS output when Write3DPropsAsRasterImage is on."""
# Get a temporary file name. Set the extension to empty since
# the exporter appends a suitable extension.
tmp_eps = tempfile.mktemp('')
# Write an EPS file.
exp = vtk.vtkGL2PSExporter()
exp.SetRenderWindow(self.renWin)
exp.SetFilePrefix(tmp_eps)
# Turn off compression so PIL can read file.
exp.CompressOff()
exp.SetSortToOff()
exp.DrawBackgroundOn()
exp.Write3DPropsAsRasterImageOn()
exp.Write()
# Now read the EPS file using PIL.
tmp_eps += '.eps'
im = Image.open(tmp_eps)
# Get a temporary name for the PNG file.
tmp_png = tempfile.mktemp('.png')
im.save(tmp_png)
# Now read the saved image and compare it for the test.
png_r = vtk.vtkPNGReader()
png_r.SetFileName(tmp_png)
png_r.Update()
img = png_r.GetOutput()
# Cleanup. Do this first because if the test fails, an
# exception is raised and the temporary files won't be
# removed.
self._cleanup([tmp_eps, tmp_png])
img_file = "TestGL2PSExporter.png"
Testing.compareImageWithSavedImage(img,
Testing.getAbsImagePath(img_file))
# Interact if necessary.
Testing.interact()
actor = vtkActor()
actor.SetMapper(mapper)
renderer = vtkRenderer()
renderWindow = vtkRenderWindow()
renderWindow.SetOffScreenRendering(1)
renderWindow.AddRenderer(renderer)
renderer.AddActor(actor)
renderer.SetBackground(1, 1, 1)
renderWindow.Render()
windowToImageFilter = vtkWindowToImageFilter()
windowToImageFilter.SetInput(renderWindow)
windowToImageFilter.Update()
writer = vtkPNGWriter()
writer.SetFileName("sphere.png")
writer.SetInputConnection(windowToImageFilter.GetOutputPort())
writer.Write()
exp = vtk.vtkGL2PSExporter()
exp.SetFileFormatToPDF()
exp.SetRenderWindow(renderWindow)
exp.SetFilePrefix('cone_pdf')
# Turn off compression so PIL can read file.
exp.CompressOff()
# exp.SetSortToBSP()
exp.DrawBackgroundOn()
exp.Write()
def generate_distance_plot():
def add_spline(outline):
outline['spline_params'] = sa.get_spline_params(outline['points'])[0]
return outline
bones = map(add_spline, lh.load_files('data/2D/registered-outline/2015-06-08'))
class1bones = [ bone for bone in bones if bone['class'] == 2 ]
class2bones = [ bone for bone in bones if bone['class'] == 3 ]
class1outline = np.mean([sa.evaluate_spline(np.linspace(0, 1, 180, endpoint=False), s['spline_params']) for s in class1bones], axis=0)
class2outline = np.mean([sa.evaluate_spline(np.linspace(0, 1, 180, endpoint=False), s['spline_params']) for s in class2bones], axis=0)
total_mean = np.mean([sa.evaluate_spline(np.linspace(0, 1, 180, endpoint=False), s['spline_params']) for s in bones], axis=0)
distances = np.linalg.norm(class1outline - class2outline, axis=1)
angles = np.array([degrees(gh.cart2pol(ev[0], ev[1])[1]) for ev in total_mean])
angles[angles[:] < 0] += 360
limit_min, limit_max = get_axis_limits(distances)
chart = vtk.vtkChartXY()
chart.GetAxis(1).SetBehavior(vtk.vtkAxis.FIXED)
chart.GetAxis(0).SetBehavior(vtk.vtkAxis.FIXED)
chart.GetAxis(0).SetTitle('')
chart.GetAxis(1).SetTitle('')
chart.GetAxis(0).GetLabelProperties().SetFontSize(30)
chart.GetAxis(1).GetLabelProperties().SetFontSize(30)
chart.GetAxis(1).SetRange(0, 359)
chart.GetAxis(0).SetRange(0, 1)
chart_table = vtk.vtkTable()
chart_angle_axis_array = vtk.vtkFloatArray()
chart_angle_axis_array.SetName('Angle (degrees)')
chart_metric_array = vtk.vtkFloatArray()
chart_metric_array.SetName('Distance')
chart_table.AddColumn(chart_angle_axis_array)
chart_table.AddColumn(chart_metric_array)
chart_line = chart.AddPlot(vtk.vtkChart.LINE)
chart_line.SetColor(0, 0, 0, 255)
chart_line.SetWidth(2)
chart.GetAxis(0).SetGridVisible(False)
chart.GetAxis(1).SetGridVisible(False)
chart_line.SetWidth(5)
chart_table.SetNumberOfRows(distances.shape[0])
for i in range(distances.shape[0]):
chart_table.SetValue(i, 0, angles[i])
chart_table.SetValue(i, 1, distances[i])
chart_line.SetInputData(chart_table, 0, 1)
render_window = vtk.vtkRenderWindow()
render_window.SetOffScreenRendering(1)
render_window.SetSize(640, 360)
tick_positions_x = vtk.vtkDoubleArray()
tick_positions_y = vtk.vtkDoubleArray()
for angle in [0, 90, 180, 270, 360]:
tick_positions_x.InsertNextValue(angle)
for height in [limit_min, floor(limit_max*100) / 100]:
tick_positions_y.InsertNextValue(height)
chart.GetAxis(0).SetRange(limit_min, limit_max)
chart.GetAxis(0).SetCustomTickPositions(tick_positions_y)
chart.GetAxis(1).SetRange(0, 360)
chart.GetAxis(1).SetCustomTickPositions(tick_positions_x)
chart.Update()
graph_context = vtk.vtkContextView()
graph_context.SetRenderWindow(render_window)
graph_context.GetScene().AddItem(chart)
exporter = vtk.vtkGL2PSExporter()
exporter.SetRenderWindow(render_window)
exporter.SetFileFormatToSVG()
exporter.CompressOff()
exporter.DrawBackgroundOff()
exporter.SetFilePrefix(os.path.abspath('thesis/img/results/real/distances'))
exporter.Write()
render_window.Finalize()
def lazy_vtkGL2PSExporter():
"""Lazy import of the vtkGL2PSExporter."""
return vtk.vtkGL2PSExporter()
def save_gl2ps (self, file_name="", exp=None):
"""Save scene to a vector PostScript/EPS/PDF/TeX file using
GL2PS. If you choose to use a TeX file then note that only
the text output is saved to the file. You will need to save
the graphics separately.
Keyword Arguments:
file_name -- Optional file name to save to. (default ''). If
no file name is given then a dialog will pop up asking for the
file name.
exp -- Optionally configured vtkGL2PSExporter object.
Defaults to None and this will result in a pop-up window
asking for configuration options.
"""
debug ("In RenderWindow::save_gl2ps ()")
# Make sure the exporter is available.
if not hasattr(vtk, 'vtkGL2PSExporter'):
msg = "Saving as a vector PS/EPS/PDF/TeX file using GL2PS is "\
"either not supported by your version of VTK or "\
"you have not configured VTK to work with GL2PS -- read "\
"the documentation for the vtkGL2PSExporter class."
Common.print_err (msg)
return
# Get a filename
if not file_name:
file_name = tk_fsave (title="Export to PS/EPS/PDF/TeX",
initialdir=Common.config.initial_dir,
defaultextension=".eps",
filetypes=[("All files", "*"),
("EPS files", "*.eps"),
("PS files", "*.ps"),
("PDF files", "*.pdf"),
("TeX files", "*.tex")])
if len(file_name) != 0:
f_prefix, f_ext = os.path.splitext(file_name)
ex = None
if exp:
ex = exp
if not isinstance(exp, vtk.vtkGL2PSExporter):
msg = "Need a vtkGL2PSExporter you passed a "\
"%s"%exp.__class__.__name__
ex.SetFilePrefix(f_prefix)
else:
ex = vtk.vtkGL2PSExporter()
# defaults
ex.SetFilePrefix(f_prefix)
if f_ext == ".ps":
ex.SetFileFormatToPS()
elif f_ext == ".tex":
ex.SetFileFormatToTeX()
elif f_ext == ".pdf":
ex.SetFileFormatToPDF()
else:
ex.SetFileFormatToEPS()
ex.SetSortToBSP()
# configure the exporter.
c = vtkPipeline.ConfigVtkObj.ConfigVtkObj(self.renwin)
c.configure(self.frame, ex, get=[], auto_update=1,
one_frame=1, run_command=0)
self.frame.update()
c.root.transient(self.frame)
self.frame.wait_window(c.root)
self.lift()
ex.SetRenderWindow(self.renwin)
Common.state.busy()
ex.Write()
Common.state.idle()
pactor.SetMapper(papper)
#pactor.GetProperty().SetOpacity(opacity)
pactor.GetProperty().SetRepresentationToWireframe()
pactor.GetProperty().SetColor(1.0, 1.0, 1.0)
ren.AddActor(pactor)
ren.SetBackground(0, 0, 0)
ren.ResetCamera()
#renWin.SetSize(1024, 768)
renWin.SetSize(1024, 768)
#renderLarge = vtk.vtkRenderLargeImage()
#renderLarge.SetInput(ren)
#renderLarge.SetMagnification(4)
writer = vtk.vtkGL2PSExporter()
writer.SetRenderWindow(renWin)
writer.SetFileFormatToPDF()
writer.SetFilePrefix("largeImage")
writer.Write()
#writer = vtk.vtkTIFFWriter()
#writer.SetInputConnection (renderLarge.GetOutputPort())
#writer.SetFileName("largeImage.tif")
#writer.Write()
renWin.Render()
iren.Start()
actor.SetMapper(mapper)
renderer = vtkRenderer()
renderWindow = vtkRenderWindow()
renderWindow.SetOffScreenRendering(1)
renderWindow.AddRenderer(renderer)
renderer.AddActor(actor)
renderer.SetBackground(1, 1, 1)
renderWindow.Render()
windowToImageFilter = vtkWindowToImageFilter()
windowToImageFilter.SetInput(renderWindow)
windowToImageFilter.Update()
writer = vtkPNGWriter()
writer.SetFileName("sphere.png")
writer.SetInputConnection(windowToImageFilter.GetOutputPort())
writer.Write()
exp = vtk.vtkGL2PSExporter()
exp.SetFileFormatToPDF()
exp.SetRenderWindow(renderWindow)
exp.SetFilePrefix('cone_pdf')
# Turn off compression so PIL can read file.
exp.CompressOff()
# exp.SetSortToBSP()
exp.DrawBackgroundOn()
exp.Write()
