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