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 run(self):
global vtk_error
#----- verify extension ------------------
extension = VerifyDataType(self.filepath)
file_name = self.filepath.split(os.path.sep)[-1]
n_array = ReadBitmap(self.filepath)
if not(isinstance(n_array, numpy.ndarray)):
return False
image = converters.to_vtk(n_array, spacing=(1,1,1),\
slice_number=1, orientation="AXIAL")
dim = image.GetDimensions()
x = dim[0]
y = dim[1]
img = vtk.vtkImageResample()
img.SetInputData(image)
img.SetAxisMagnificationFactor ( 0, 0.25 )
img.SetAxisMagnificationFactor ( 1, 0.25 )
img.SetAxisMagnificationFactor ( 2, 1 )
img.Update()
tp = img.GetOutput().GetScalarTypeAsString()
image_copy = vtk.vtkImageData()
image_copy.DeepCopy(img.GetOutput())
thumbnail_path = tempfile.mktemp()
write_png = vtk.vtkPNGWriter()
write_png.SetInputConnection(img.GetOutputPort())
write_png.AddObserver("WarningEvent", VtkErrorPNGWriter)
write_png.SetFileName(thumbnail_path)
write_png.Write()
if vtk_error:
img = vtk.vtkImageCast()
img.SetInputData(image_copy)
img.SetOutputScalarTypeToUnsignedShort()
#img.SetClampOverflow(1)
img.Update()
write_png = vtk.vtkPNGWriter()
write_png.SetInputConnection(img.GetOutputPort())
write_png.SetFileName(thumbnail_path)
write_png.Write()
vtk_error = False
id = wx.NewId()
bmp_item = [self.filepath, thumbnail_path, extension, x, y,\
str(x) + ' x ' + str(y), file_name, id]
self.bmp_file.Add(bmp_item)
def write_picture(self, magnify, fname):
ren = self.getRenderer()
assert ren is not None
renderLarge = vtk.vtkRenderLargeImage()
renderLarge.SetInput(ren)
renderLarge.SetMagnification(magnify)
rotation = 'x'
self.set_rotation(rotation)
lfname = fname.lower()
if lfname.endswith('.png'):
writer = vtk.vtkPNGWriter()
elif lfname.endswith('.jpeg'):
writer = vtk.vtkJPEGWriter()
elif lfname.endswith('.tiff'):
writer = vtk.vtkTIFFWriter()
elif lfname.endswith('.ps'):
writer = vtk.vtkPostScriptWriter()
else:
writer = vtk.vtkPNGWriter()
writer.SetInput(renderLarge.GetOutput())
writer.SetFileName(fname)
writer.Write()
def 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 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 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 takeSimShot(self, fileName):
# print MODULENAME,' takeSimShot: fileName=',fileName
# DON'T REMOVE!
# Better quality
# Passes vtkRenderer. Takes actual screenshot of the region within the widget window
# If other application are present within this region it will shoot them also
renderLarge = vtk.vtkRenderLargeImage()
renderLarge.SetInput(self.graphicsFrameWidget.ren)
renderLarge.SetMagnification(1)
# We write out the image which causes the rendering to occur. If you
# watch your screen you might see the pieces being rendered right
# after one another.
# writer = vtk.vtkPNGWriter()
writer = vtk.vtkPNGWriter()
writer.SetInputConnection(renderLarge.GetOutputPort())
print MODULENAME,"takeSimShot(): vtkPNGWriter, fileName=",fileName
writer.SetFileName(fileName)
print 'TRYING TO WRITE ',fileName
writer.Write()
print 'WROTE ',fileName
def 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 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 save_png(image, filename):
from vtk import vtkPNGWriter
writer = vtkPNGWriter()
writer.SetFileName(filename)
writer.SetInputData(image)
writer.Update()
writer.Write()
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 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 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 WritePNGImageFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing PNG image file.')
outputImage = self.Image
if self.Image.GetScalarTypeAsString() != 'unsigned char':
shiftScale = vtk.vtkImageShiftScale()
shiftScale.SetInputData(self.Image)
if self.WindowLevel[0] == 0.0:
scalarRange = self.Image.GetScalarRange()
shiftScale.SetShift(-scalarRange[0])
shiftScale.SetScale(255.0/(scalarRange[1]-scalarRange[0]))
else:
shiftScale.SetShift(-(self.WindowLevel[1]-self.WindowLevel[0]/2.0))
shiftScale.SetScale(255.0/self.WindowLevel[0])
shiftScale.SetOutputScalarTypeToUnsignedChar()
shiftScale.ClampOverflowOn()
shiftScale.Update()
outputImage = shiftScale.GetOutput()
writer = vtk.vtkPNGWriter()
writer.SetInputData(outputImage)
if self.Image.GetDimensions()[2] == 1:
writer.SetFileName(self.OutputFileName)
else:
writer.SetFilePrefix(self.OutputFileName)
writer.SetFilePattern("%s%04d.png")
writer.Write()
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 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 generate png from ", inputfile)
#Read data
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(inputfile)
reader.Update()
image = reader.GetOutput()
#image.SetSpacing(1,1,1)
#image.GetPointData().SetScalars(image.GetPointData().GetVectors())
#Compute Q Criterion for texture mapping
#Now put this in a png file
castFilter = vtk.vtkImageCast()
castFilter.SetInputData(image)
castFilter.Update()
w = vtk.vtkPNGWriter()
w.SetInputData(castFilter.GetOutput())
w.SetFileName("xyslice.png")
w.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 _handleFailedImage(idiff, pngr, img_fname):
"""Writes all the necessary images when an image comparison
failed."""
f_base, f_ext = os.path.splitext(img_fname)
# write the difference image gamma adjusted for the dashboard.
gamma = vtk.vtkImageShiftScale()
gamma.SetInputConnection(idiff.GetOutputPort())
gamma.SetShift(0)
gamma.SetScale(10)
pngw = vtk.vtkPNGWriter()
pngw.SetFileName(_getTempImagePath(f_base + ".diff.png"))
pngw.SetInputConnection(gamma.GetOutputPort())
pngw.Write()
# Write out the image that was generated. Write it out as full so that
# it may be used as a baseline image if the tester deems it valid.
pngw.SetInputConnection(idiff.GetInputConnection(0,0))
pngw.SetFileName(_getTempImagePath(f_base + ".png"))
pngw.Write()
# write out the valid image that matched.
pngw.SetInputConnection(idiff.GetInputConnection(1,0))
pngw.SetFileName(_getTempImagePath(f_base + ".valid.png"))
pngw.Write()
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 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 write_image(self, filename="image.png", magnification=1,
image_format="png"):
"""
Save render window to an image.
Arguments:
filename:
filename to save to. Defaults to image.png.
magnification:
magnification. Use it to render high res images.
image_format:
choose between jpeg, png. Png is the default.
"""
render_large = vtk.vtkRenderLargeImage()
render_large.SetInput(self.ren)
if image_format == "jpeg":
writer = vtk.vtkJPEGWriter()
writer.SetQuality(80)
else:
writer = vtk.vtkPNGWriter()
render_large.SetMagnification(magnification)
writer.SetFileName(filename)
writer.SetInputConnection(render_large.GetOutputPort())
self.ren_win.Render()
writer.Write()
del render_large
def 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 __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 get_screenshot(renWin, filename):
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renWin)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName(filename)
writer.SetInput(w2if.GetOutput())
writer.Write()
renWin.Render()
def dump_image_to_file(fname,img): print "Writing to:",fname wr = vtk.vtkPNGWriter() wr.SetFileName(fname) imp = vtkImageImportFromArray() imp.SetArray((img+255/510)) wr.SetInputConnection(imp.GetOutputPort()) wr.Update() wr.Write()
def writeLargeFrame( myscreen, w2if, lwr, n , zoom=1):
renderlarge = vtk.vtkRenderLargeImage()
renderlarge.SetInput( myscreen.ren )
renderlarge.SetMagnification(zoom)
writer = vtk.vtkPNGWriter()
writer.SetFileName("large_frame.png")
writer.SetInputConnection( renderlarge.GetOutputPort() )
writer.Write()
print "Wrote large frame!"
def 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 saveStructureScreenshot(renWin, filename):
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renWin)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName(filename)
writer.SetInput(w2if.GetOutput())
writer.Write()
def execute(self, arg, trans):
# Number of Chan-Vese iterations
nIter = 20
std = 1.5 # [mm], original
squareSize = 1.5 # [mm]
saveMetaImage = False
savePNGImage = False
# Actual work - now done using SciPy
# Gaussian smoothing
dx, dy, dz = arg.GetSpacing()
sx, sy = std / dx, std / dy
smoother = vtk.vtkImageGaussianSmooth()
smoother.SetStandardDeviations(sx, sy)
smoother.SetDimensionality(2)
smoother.SetInputData(arg)
smoother.Update()
if savePNGImage:
writer = vtk.vtkPNGWriter()
writer.SetFileName('./output.png')
writer.SetInputConnection(smoother.GetOutputPort())
writer.Write()
if saveMetaImage:
# Save to disk
writer = vtk.vtkMetaImageWriter()
writer.SetFileName('./output.mhd')
writer.SetInputConnection(smoother.GetOutputPort())
writer.Write()
smoothedData = smoother.GetOutput()
# Convert VTK to NumPy image
dims = arg.GetDimensions()
vtk_array = smoothedData.GetPointData().GetScalars()
nComponents = vtk_array.GetNumberOfComponents()
npData = vtk_to_numpy(vtk_array).reshape(
dims[2], dims[1], dims[0],
nComponents)[:, :, :, 0].reshape(dims[1], dims[0])
# Seed for active contours
iSquareSize = int(squareSize / dx)
init_ls = checkerboard_level_set(npData.shape, iSquareSize)
contours = morphological_chan_vese(npData,
nIter,
init_level_set=init_ls,
smoothing=2)
# Add singleton to get 3-dimensional data
data = contours[None, :]
# Convert Numpy to VTK data
importer = vtk.vtkImageImport()
importer.SetDataScalarType(vtk.VTK_SIGNED_CHAR)
importer.SetDataExtent(0, data.shape[2] - 1, 0, data.shape[1] - 1, 0,
data.shape[0] - 1)
importer.SetWholeExtent(0, data.shape[2] - 1, 0, data.shape[1] - 1, 0,
data.shape[0] - 1)
importer.SetImportVoidPointer(data.data)
importer.Update()
vtkData = importer.GetOutput()
vtkData.SetSpacing(smoothedData.GetSpacing())
vtkData.SetOrigin(0, 0, 0)
# Contour filter
contourFilter = vtk.vtkContourFilter()
iso_value = 0.5
contourFilter.SetInputData(vtkData)
contourFilter.SetValue(0, iso_value)
contourFilter.Update()
contourFilter.ReleaseDataFlagOn()
# Compute normals
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(contourFilter.GetOutputPort())
normals.SetFeatureAngle(60.0)
normals.ReleaseDataFlagOn()
# Join line segments
stripper = vtk.vtkStripper()
stripper.SetInputConnection(normals.GetOutputPort())
stripper.ReleaseDataFlagOn()
stripper.Update()
# Transform data from scaled screen to world coordinates
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetInputConnection(stripper.GetOutputPort())
transformFilter.SetTransform(trans)
transformFilter.Update()
result = transformFilter.GetOutput()
# Emit done with output
self.done.emit(result)
def main(filename="frame/f.png", yc=6, n=0):
f = ocl.Ocode()
f.set_depth(10)
myscreen = camvtk.VTKScreen()
myscreen.camera.SetPosition(50, 22, 40)
myscreen.camera.SetFocalPoint(0, 0, 0)
myscreen.camera.Azimuth(n * 0.5)
# box around octree
oct_cube = camvtk.Cube(center=(0, 0, 0), length=40, color=camvtk.white)
oct_cube.SetWireframe()
myscreen.addActor(oct_cube)
# screenshot writer
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(myscreen.renWin)
lwr = vtk.vtkPNGWriter()
lwr.SetInput(w2if.GetOutput())
arrowcenter = (1, 2, 0)
xar = camvtk.Arrow(color=camvtk.red, center=arrowcenter, rotXYZ=(0, 0, 0))
myscreen.addActor(xar)
yar = camvtk.Arrow(color=camvtk.green,
center=arrowcenter,
rotXYZ=(0, 0, 90))
myscreen.addActor(yar)
zar = camvtk.Arrow(color=camvtk.blue,
center=arrowcenter,
rotXYZ=(0, -90, 0))
myscreen.addActor(zar)
t = ocl.LinOCT()
#t2 = ocl.LinOCT()
t.init(3)
#t2.init(3)
print " after init() t :", t.str()
#print " after init() t2 :", t2.str()
# sphere
svol = ocl.SphereOCTVolume()
svol.radius = 3.2
svol.center = ocl.Point(1, 0, 3)
# cube
cube1 = ocl.CubeOCTVolume()
cube1.side = 69
cube1.center = ocl.Point(0, 0, 0)
#cylinder
cylvol = ocl.CylinderOCTVolume()
cylvol.p2 = ocl.Point(0, 0, 4)
cylvol.radius = 4
c = ocl.CylCutter(1)
c.length = 3
print "cutter length=", c.length
p1 = ocl.Point(0, 0, 0)
p2 = ocl.Point(1, 1.4, 0)
g1vol = ocl.CylMoveOCTVolume(c, p1, p2)
cyl1 = camvtk.Cylinder(center=(p1.x, p1.y, p1.z),
radius=c.radius,
height=c.length,
rotXYZ=(90, 0, 0),
color=camvtk.grey)
cyl1.SetWireframe()
myscreen.addActor(cyl1)
cyl2 = camvtk.Cylinder(center=(p2.x, p2.y, p2.z),
radius=c.radius,
height=c.length,
rotXYZ=(90, 0, 0),
color=camvtk.grey)
cyl2.SetWireframe()
myscreen.addActor(cyl2)
startp = camvtk.Sphere(center=(p1.x, p1.y, p1.z),
radius=0.1,
color=camvtk.green)
myscreen.addActor(startp)
endp = camvtk.Sphere(center=(p2.x, p2.y, p2.z),
radius=0.1,
color=camvtk.red)
myscreen.addActor(endp)
t.build(g1vol)
#print "t2 build()"
#t2.build(cube1)
#print " t2 after build() ", t2.size()
#t2.condense()
#print " t2 after condense() ", t2.size()
# original trees
drawTree(myscreen, t, opacity=1, color=camvtk.green)
#drawTree(myscreen,t2,opacity=1, color=camvtk.red)
#print " diff12()...",
#t3 = t2.operation(1,t)
#print "done."
#print " diff21()...",
#t4 = t2.operation(2,t)
#print "done."
#print " intersection()...",
#t5 = t2.operation(3,t)
#print "done."
#print " sum()...",
#t6 = t2.operation(4,t)
#print "done."
#print " difference 1-2 t3 (blue) =", t3.size()
#print " difference 2-1 t4 (yellow)=", t4.size()
#print " intersection t5 (pink) =", t5.size()
#print " union t6 (grey) =", t6.size()
#drawTree(myscreen,t3,opacity=1, color=camvtk.blue, offset=(0,15,0))
#drawTree(myscreen,t4,opacity=1, color=camvtk.yellow,offset=(0,-15,0))
#drawTree(myscreen,t5,opacity=1, color=camvtk.pink,offset=(-15,0,0))
#drawTree(myscreen,t6,opacity=1, color=camvtk.grey,offset=(-15,-15,0))
title = camvtk.Text()
title.SetPos((myscreen.width - 350, myscreen.height - 30))
title.SetText("OpenCAMLib " +
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
myscreen.addActor(title)
#st2 = camvtk.Text()
#ytext = "Linear OCTree set operations: difference, intersection, union"
#st2.SetText(ytext)
#st2.SetPos( (50, myscreen.height-30) )
#myscreen.addActor( st2)
#st3 = camvtk.Text()
#text = "Original OCTrees\n Ball:%d nodes\n Cube: %d nodes" % ( t.size(), t2.size() )
#st3.SetText(text)
#st3.SetPos( (50, 200) )
#myscreen.addActor( st3)
#st4 = camvtk.Text()
#un = " Union (grey): %d nodes\n" % (t6.size())
#int = " Intersection (pink): %d nodes\n" % (t5.size())
#diff1 = " difference Cube-Ball (blue): %d nodes\n" % (t3.size())
#diff2 = " difference Ball-Cube (yellow): %d nodes\n" % (t4.size())
#text= un+int+diff1+diff2
#st4.SetText(text)
#st4.SetPos( (50, 100) )
#myscreen.addActor( st4)
myscreen.render()
lwr.SetFileName(filename)
time.sleep(0.2)
#lwr.Write()
myscreen.iren.Start()
def main(filename="frame/f.png", yc=6, n=0):
f = ocl.Ocode()
f.set_depth(8)
myscreen = camvtk.VTKScreen()
myscreen.camera.SetPosition(50, 22, 40)
myscreen.camera.SetFocalPoint(0, 0, 0)
myscreen.camera.Azimuth(n * 0.5)
# screenshot writer
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(myscreen.renWin)
lwr = vtk.vtkPNGWriter()
lwr.SetInput(w2if.GetOutput())
xar = camvtk.Arrow(color=camvtk.red, center=(10, 20, 0), rotXYZ=(0, 0, 0))
myscreen.addActor(xar)
yar = camvtk.Arrow(color=camvtk.green,
center=(10, 20, 0),
rotXYZ=(0, 0, 90))
myscreen.addActor(yar)
zar = camvtk.Arrow(color=camvtk.blue,
center=(10, 20, 0),
rotXYZ=(0, -90, 0))
myscreen.addActor(zar)
t = ocl.LinOCT()
t2 = ocl.LinOCT()
t.init(3)
t2.init(3)
print " after init() t :", t.str()
print " after init() t2 :", t2.str()
svol = ocl.SphereOCTVolume()
svol.radius = 3
svol.center = ocl.Point(1, 0, 3)
cube1 = ocl.CubeOCTVolume()
cube1.side = 6
cube1.center = ocl.Point(0, 0, 0)
cube2 = ocl.CubeOCTVolume()
cube2.center = ocl.Point(1, 2, 0)
cube2.side = 30
print "t build()"
t.build(svol)
print " t after build() ", t.size()
t.condense()
print " t after condense() ", t.size()
print "t2 build()"
t2.build(cube1)
print " t2 after build() ", t2.size()
t2.condense()
print " t2 after condense() ", t2.size()
# original trees
drawTree(myscreen, t, opacity=1, color=camvtk.green)
drawTree(myscreen, t2, opacity=1, color=camvtk.red)
print " diff12()...",
t3 = t2.operation(1, t)
print "done."
print " diff21()...",
t4 = t2.operation(2, t)
print "done."
print " intersection()...",
t5 = t2.operation(3, t)
print "done."
print " sum()...",
t6 = t2.operation(4, t)
print "done."
print " difference 1-2 t3 (blue) =", t3.size()
print " difference 2-1 t4 (yellow)=", t4.size()
print " intersection t5 (pink) =", t5.size()
print " union t6 (grey) =", t6.size()
drawTree(myscreen, t3, opacity=1, color=camvtk.blue, offset=(0, 15, 0))
drawTree(myscreen, t4, opacity=1, color=camvtk.yellow, offset=(0, -15, 0))
drawTree(myscreen, t5, opacity=1, color=camvtk.pink, offset=(-15, 0, 0))
drawTree(myscreen, t6, opacity=1, color=camvtk.grey, offset=(-15, -15, 0))
title = camvtk.Text()
title.SetPos((myscreen.width - 350, myscreen.height - 30))
title.SetText("OpenCAMLib " +
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
myscreen.addActor(title)
st2 = camvtk.Text()
ytext = "Linear OCTree set operations: difference, intersection, union"
st2.SetText(ytext)
st2.SetPos((50, myscreen.height - 30))
myscreen.addActor(st2)
st3 = camvtk.Text()
text = "Original OCTrees\n Ball:%d nodes\n Cube: %d nodes" % (t.size(),
t2.size())
st3.SetText(text)
st3.SetPos((50, 200))
myscreen.addActor(st3)
st4 = camvtk.Text()
un = " Union (grey): %d nodes\n" % (t6.size())
int = " Intersection (pink): %d nodes\n" % (t5.size())
diff1 = " difference Cube-Ball (blue): %d nodes\n" % (t3.size())
diff2 = " difference Ball-Cube (yellow): %d nodes\n" % (t4.size())
text = un + int + diff1 + diff2
st4.SetText(text)
st4.SetPos((50, 100))
myscreen.addActor(st4)
myscreen.render()
lwr.SetFileName(filename)
time.sleep(0.2)
#lwr.Write()
myscreen.iren.Start()
prop_volume.SetScalarOpacity(vtk_opacity_map)
prop_volume.SetColor(vtk_color_map)
# camera
camera.Elevation(elev)
camera.Azimuth(azimuth)
camera.Roll(roll)
camera.Zoom(zoom)
# render to image
render_window.Render()
window_to_image = vtk.vtkWindowToImageFilter()
window_to_image.SetInputBufferTypeToRGBA()
window_to_image.SetInput(render_window)
window_to_image.Update()
image_writer = vtk.vtkPNGWriter()
image_writer.SetFileName(output_img_dir + rel_filename)
image_writer.SetInputConnection(window_to_image.GetOutputPort())
image_writer.Write()
# undo camera
camera.Zoom(1.0 / zoom)
camera.Roll(-roll)
camera.Azimuth(-azimuth)
camera.Elevation(-elev)
#
ind += 1
#
def create_dicom_thumbnails(filename, window=None, level=None):
rvtk = vtkgdcm.vtkGDCMImageReader()
rvtk.SetFileName(filename)
rvtk.Update()
img = rvtk.GetOutput()
if window is None or level is None:
_min, _max = img.GetScalarRange()
window = _max - _min
level = _min + window / 2
dx, dy, dz = img.GetDimensions()
if dz > 1:
thumbnail_paths = []
for i in xrange(dz):
img_slice = ExtractVOI(img, 0, dx-1, 0, dy-1, i, i+1)
colorer = vtk.vtkImageMapToWindowLevelColors()
colorer.SetInputData(img_slice)
colorer.SetWindow(window)
colorer.SetLevel(level)
colorer.SetOutputFormatToRGB()
colorer.Update()
resample = vtk.vtkImageResample()
resample.SetInputData(colorer.GetOutput())
resample.SetAxisMagnificationFactor ( 0, 0.25 )
resample.SetAxisMagnificationFactor ( 1, 0.25 )
resample.SetAxisMagnificationFactor ( 2, 1 )
resample.Update()
thumbnail_path = tempfile.mktemp()
write_png = vtk.vtkPNGWriter()
write_png.SetInputData(resample.GetOutput())
write_png.SetFileName(thumbnail_path)
write_png.Write()
thumbnail_paths.append(thumbnail_path)
return thumbnail_paths
else:
colorer = vtk.vtkImageMapToWindowLevelColors()
colorer.SetInputData(img)
colorer.SetWindow(window)
colorer.SetLevel(level)
colorer.SetOutputFormatToRGB()
colorer.Update()
resample = vtk.vtkImageResample()
resample.SetInputData(colorer.GetOutput())
resample.SetAxisMagnificationFactor ( 0, 0.25 )
resample.SetAxisMagnificationFactor ( 1, 0.25 )
resample.SetAxisMagnificationFactor ( 2, 1 )
resample.Update()
thumbnail_path = tempfile.mktemp()
write_png = vtk.vtkPNGWriter()
write_png.SetInputData(resample.GetOutput())
write_png.SetFileName(thumbnail_path)
write_png.Write()
return thumbnail_path
def plotResult3D(self, dpt, T, gt3Dorig, joint3D, visibility=None, filename=None, showGT=True, showPC=True,
niceColors=False):
"""
Plot 3D point cloud
:param dpt: depth image
:param T: 2D image transformation
:param gt3Dorig: groundtruth 3D pose
:param joint3D: 3D joint data
:param visibility: plot different markers for visible/non-visible joints, visible are marked as 1, non-visible 0
:param filename: name of file to save, if None return image
:param showGT: show groundtruth annotation
:param showPC: show point cloud
:return: None, or image if filename=None
"""
import vtk
from vtk.util.numpy_support import vtk_to_numpy
from util.vtkpointcloud import VtkPointCloud
import matplotlib.pyplot as plt
def close_window(iren):
render_window = iren.GetRenderWindow()
render_window.Finalize()
iren.TerminateApp()
def key_pressed_callback(obj, event):
key = obj.GetKeySym()
iren = obj
render_window = iren.GetRenderWindow()
if key == "s":
file_name = self.subfolder + str(numpy.random.randint(0, 100)).zfill(5) + ".png"
image = vtk.vtkWindowToImageFilter()
image.SetInput(render_window)
png_writer = vtk.vtkPNGWriter()
png_writer.SetInputConnection(image.GetOutputPort())
png_writer.SetFileName(file_name)
render_window.Render()
png_writer.Write()
elif key == "c":
camera = renderer.GetActiveCamera()
print "Camera settings:"
print " * position: %s" % (camera.GetPosition(),)
print " * focal point: %s" % (camera.GetFocalPoint(),)
print " * up vector: %s" % (camera.GetViewUp(),)
class vtkTimerCallback():
def __init__(self):
pass
def execute(self, obj, event):
if plt.matplotlib.get_backend() == 'agg':
iren = obj
render_window = iren.GetRenderWindow()
render_window.Finalize()
iren.TerminateApp()
del render_window, iren
# Renderer
renderer = vtk.vtkRenderer()
renderer.SetBackground(1.0, 1.0, 1.0)
if showPC is True:
pointCloud = VtkPointCloud()
pcl = self.getPCL(dpt, T)
for k in xrange(pcl.shape[0]):
point = pcl[k]
pointCloud.addPoint(point)
renderer.AddActor(pointCloud.vtkActor)
renderer.ResetCamera()
self.vtkPlotHand(renderer, joint3D, visibility, 'nice' if niceColors is True else (1, 0, 0))
if showGT:
self.vtkPlotHand(renderer, gt3Dorig, visibility, 'nice' if niceColors is True else (0, 0, 1))
# setup camera position
camera = renderer.GetActiveCamera()
camera.Pitch(self.VTKviewport[0])
camera.Yaw(self.VTKviewport[1])
camera.Roll(self.VTKviewport[2])
camera.Azimuth(self.VTKviewport[3])
camera.Elevation(self.VTKviewport[4])
# Render Window
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
# Interactor
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.AddObserver("KeyPressEvent", key_pressed_callback)
if showPC is False:
renderer.ResetCamera()
# setup camera position
camera = renderer.GetActiveCamera()
camera.Pitch(self.VTKviewport[0])
camera.Yaw(self.VTKviewport[1])
camera.Roll(self.VTKviewport[2])
camera.Azimuth(self.VTKviewport[3])
camera.Elevation(self.VTKviewport[4])
# Begin Interaction
renderWindow.Render()
renderWindow.SetWindowName("XYZ Data Viewer")
# Sign up to receive TimerEvent
cb = vtkTimerCallback()
cb.actor = renderer.GetActors().GetLastActor()
renderWindowInteractor.AddObserver('TimerEvent', cb.execute)
timerId = renderWindowInteractor.CreateRepeatingTimer(10)
renderWindowInteractor.Start()
if filename is not None:
im = vtk.vtkWindowToImageFilter()
writer = vtk.vtkPNGWriter()
im.SetInput(renderWindow)
im.Update()
writer.SetInputConnection(im.GetOutputPort())
writer.SetFileName('{}/{}.png'.format(self.subfolder, filename))
writer.Write()
close_window(renderWindowInteractor)
del renderWindow, renderWindowInteractor
else:
im = vtk.vtkWindowToImageFilter()
im.SetInput(renderWindow)
im.Update()
vtk_image = im.GetOutput()
height, width, _ = vtk_image.GetDimensions()
vtk_array = vtk_image.GetPointData().GetScalars()
components = vtk_array.GetNumberOfComponents()
close_window(renderWindowInteractor)
del renderWindow, renderWindowInteractor
return vtk_to_numpy(vtk_array).reshape(height, width, components)
def main():
"""
Visualize Freesurfer, SimNIBS headreco, and Nexstim coil locations in the scanner coordinate system.
"""
SHOW_AXES = True
SHOW_SCENE_AXES = True
SHOW_COIL_AXES = True
SHOW_SKIN = True
SHOW_BRAIN = True
SHOW_FREESURFER = 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 = 'S5'
id_extra = False # 8, 9, 10, 12, False
data_dir = os.environ['OneDrive'] + r'\data\nexstim_coord'
# data_dir = 'P:\\tms_eeg\\mTMS\\projects\\lateral ppTMS M1\\E-fields\\'
# data_subj = data_dir + subj + '\\'
simnibs_dir = data_dir + r'\simnibs\m2m_ppM1_{}_nc'.format(subj)
fs_dir = data_dir + r'\freesurfer\ppM1_{}'.format(subj)
if id_extra:
nav_dir = data_dir + r'\nav_coordinates\ppM1_{}_{}'.format(
subj, id_extra)
else:
nav_dir = data_dir + r'\nav_coordinates\ppM1_{}'.format(subj)
# filenames
# coil_file = data_dir + 'magstim_fig8_coil.stl'
coil_file = os.environ[
'OneDrive'] + r'\data\nexstim_coord\magstim_fig8_coil.stl'
if id_extra:
coord_file = nav_dir + r'\ppM1_eximia_{}_{}.txt'.format(subj, id_extra)
else:
coord_file = nav_dir + r'\ppM1_eximia_{}.txt'.format(subj)
# img_file = data_subj + subj + '.nii'
img_file = data_dir + r'\mri\ppM1_{}\ppM1_{}.nii'.format(subj, subj)
brain_file = simnibs_dir + r'\wm.stl'
skin_file = simnibs_dir + r'\skin.stl'
fs_file = fs_dir + r'\lh.pial.stl'
fs_t1 = fs_dir + r'\mri\T1.mgz'
if id_extra:
output_file = nav_dir + r'\transf_mat_{}_{}'.format(subj, id_extra)
else:
output_file = nav_dir + r'\transf_mat_{}'.format(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)
if AFFINE_IMG:
affine = imagedata.affine
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)
print("\nAffine: \n")
print(affine)
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])
print('\nOriginal coordinates from Nexstim: \n')
[print(s) for s in coords]
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:
# brain_actor = load_stl(brain_file, ren, colour=[0., 1., 1.], opacity=0.7, user_matrix=np.linalg.inv(affine))
brain_actor = load_stl(brain_file,
ren,
colour=[0., 1., 1.],
opacity=1.)
if SHOW_SKIN:
# skin_actor = load_stl(skin_file, ren, opacity=0.5, user_matrix=np.linalg.inv(affine))
skin_actor = load_stl(skin_file, ren, colour="SkinColor", opacity=.4)
if SHOW_FREESURFER:
img = fsio.MGHImage.load(fs_t1)
#print("MGH Header: ", img)
#print("MGH data: ", img.header['Pxyz_c'])
# skin_actor = load_stl(skin_file, ren, opacity=0.5, user_matrix=np.linalg.inv(affine))
trans_fs = np.identity(4)
trans_fs[:3, -1] = img.header['Pxyz_c']
fs_actor = load_stl(fs_file,
ren,
colour=[1., 0., 1.],
opacity=0.5,
user_matrix=trans_fs)
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()
# col = (1, 0, 0)
myscreen.addActor( camvtk.Point(center=(cl.x,cl.y,cl.z) , color=col) )
myscreen.addActor( camvtk.Point(center=(cl2.x,cl2.y,cl2.z+0.2) , color=(0.6,0.2,0.9)) )
#myscreen.addActor( camvtk.Point(center=(cc.x,cc.y,cc.z), color=col) )
#print cc.type
print "none=",nn," vertex=",nv, " edge=",ne, " facet=",nf, " sum=", nn+nv+ne+nf
print len(clpoints), " cl points evaluated"
myscreen.camera.SetPosition(3, 23, 15)
myscreen.camera.SetFocalPoint(5, 5, 0)
myscreen.render()
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(myscreen.renWin)
lwr = vtk.vtkPNGWriter()
lwr.SetInput( w2if.GetOutput() )
w2if.Modified()
lwr.SetFileName("tux1.png")
#lwr.Write()
t = camvtk.Text()
t.SetPos( (myscreen.width-200, myscreen.height-30) )
myscreen.addActor( t)
for n in range(1,36):
t.SetText(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
myscreen.camera.Azimuth( 1 )
time.sleep(0.01)
myscreen.render()
lwr.SetFileName("kd_frame"+ ('%03d' % n)+".png")
def main(args):
parser = argparse.ArgumentParser(
description=
'Render a DSM from a DTM and polygons representing buildings.')
parser.add_argument("--input_vtp_path",
type=str,
help="Input buildings polygonal file (.vtp)")
parser.add_argument(
"--input_obj_paths",
nargs="*",
help="List of input building (.obj) file paths. "
"Building object files start "
"with a digit, road object files start with \"Road\". "
"All obj files start with comments specifying the offsets "
"that are added the coordinats. There are three comment lines, "
"one for each coordinate: \"#c offset: value\" where c is x, y and z.")
parser.add_argument("input_dtm", help="Input digital terain model (DTM)")
parser.add_argument("output_dsm",
help="Output digital surface model (DSM)")
parser.add_argument("--render_png",
action="store_true",
help="Do not save the DSM, render into a PNG instead.")
parser.add_argument(
"--render_cls",
action="store_true",
help="Render a buildings mask: render buildings label (6), "
"background (2) and no DTM.")
parser.add_argument("--buildings_only",
action="store_true",
help="Do not use the DTM, use only the buildings.")
parser.add_argument("--debug",
action="store_true",
help="Save intermediate results")
args = parser.parse_args(args)
# open the DTM
dtm = gdal.Open(args.input_dtm, gdal.GA_ReadOnly)
if not dtm:
raise RuntimeError("Error: Failed to open DTM {}".format(
args.input_dtm))
dtmDriver = dtm.GetDriver()
dtmDriverMetadata = dtmDriver.GetMetadata()
dsm = None
dtmBounds = [0.0, 0.0, 0.0, 0.0]
if dtmDriverMetadata.get(gdal.DCAP_CREATE) == "YES":
print("Create destination image "
"size:({}, {}) ...".format(dtm.RasterXSize, dtm.RasterYSize))
# georeference information
projection = dtm.GetProjection()
transform = dtm.GetGeoTransform()
gcpProjection = dtm.GetGCPProjection()
gcps = dtm.GetGCPs()
options = ["COMPRESS=DEFLATE"]
# ensure that space will be reserved for geographic corner coordinates
# (in DMS) to be set later
if (dtmDriver.ShortName == "NITF" and not projection):
options.append("ICORDS=G")
if args.render_cls:
eType = gdal.GDT_Byte
else:
eType = gdal.GDT_Float32
dsm = dtmDriver.Create(args.output_dsm,
xsize=dtm.RasterXSize,
ysize=dtm.RasterYSize,
bands=1,
eType=eType,
options=options)
if (projection):
# georeference through affine geotransform
dsm.SetProjection(projection)
dsm.SetGeoTransform(transform)
else:
# georeference through GCPs
dsm.SetGCPs(gcps, gcpProjection)
gdal.GCPsToGeoTransform(gcps, transform)
corners = [[0, 0], [0, dtm.RasterYSize],
[dtm.RasterXSize, dtm.RasterYSize], [dtm.RasterXSize, 0]]
geoCorners = numpy.zeros((4, 2))
for i, corner in enumerate(corners):
geoCorners[i] = [
transform[0] + corner[0] * transform[1] +
corner[1] * transform[2], transform[3] +
corner[0] * transform[4] + corner[1] * transform[5]
]
dtmBounds[0] = numpy.min(geoCorners[:, 0])
dtmBounds[1] = numpy.max(geoCorners[:, 0])
dtmBounds[2] = numpy.min(geoCorners[:, 1])
dtmBounds[3] = numpy.max(geoCorners[:, 1])
if args.render_cls:
# label for no building
dtmRaster = numpy.full([dtm.RasterYSize, dtm.RasterXSize], 2)
nodata = 0
else:
print("Reading the DTM {} size: ({}, {})\n"
"\tbounds: ({}, {}), ({}, {})...".format(
args.input_dtm, dtm.RasterXSize, dtm.RasterYSize,
dtmBounds[0], dtmBounds[1], dtmBounds[2], dtmBounds[3]))
dtmRaster = dtm.GetRasterBand(1).ReadAsArray()
nodata = dtm.GetRasterBand(1).GetNoDataValue()
print("Nodata: {}".format(nodata))
else:
raise RuntimeError(
"Driver {} does not supports Create().".format(dtmDriver))
# read the buildings polydata, set Z as a scalar and project to XY plane
print("Reading the buildings ...")
# labels for buildings and elevated roads
labels = [6, 17]
if (args.input_vtp_path and os.path.isfile(args.input_vtp_path)):
polyReader = vtk.vtkXMLPolyDataReader()
polyReader.SetFileName(args.input_vtp_path)
polyReader.Update()
polyVtkList = [polyReader.GetOutput()]
elif (args.input_obj_paths):
# buildings start with numbers
# optional elevated roads start with Road*.obj
bldg_re = re.compile(".*/?[0-9][^/]*\\.obj")
bldg_files = [f for f in args.input_obj_paths if bldg_re.match(f)]
print(bldg_files)
road_re = re.compile(".*/?Road[^/]*\\.obj")
road_files = [f for f in args.input_obj_paths if road_re.match(f)]
files = [bldg_files, road_files]
files = [x for x in files if x]
print(road_files)
if len(files) >= 2:
print("Found {} buildings and {} roads".format(
len(files[0]), len(files[1])))
elif len(files) == 1:
print("Found {} buildings".format(len(files[0])))
else:
raise RuntimeError("No OBJ files found in {}".format(
args.input_obj_paths))
polyVtkList = []
for category in range(len(files)):
append = vtk.vtkAppendPolyData()
for i, fileName in enumerate(files[category]):
offset = [0.0, 0.0, 0.0]
gdal_utils.read_offset(fileName, offset)
print("Offset: {}".format(offset))
transform = vtk.vtkTransform()
transform.Translate(offset[0], offset[1], offset[2])
objReader = vtk.vtkOBJReader()
objReader.SetFileName(fileName)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputConnection(objReader.GetOutputPort())
append.AddInputConnection(transformFilter.GetOutputPort())
append.Update()
polyVtkList.append(append.GetOutput())
else:
raise RuntimeError(
"Must provide either --input_vtp_path, or --input_obj_paths")
arrayName = "Elevation"
append = vtk.vtkAppendPolyData()
for category in range(len(polyVtkList)):
poly = dsa.WrapDataObject(polyVtkList[category])
polyElevation = poly.Points[:, 2]
if args.render_cls:
# label for buildings
polyElevation[:] = labels[category]
polyElevationVtk = numpy_support.numpy_to_vtk(polyElevation)
polyElevationVtk.SetName(arrayName)
poly.PointData.SetScalars(polyElevationVtk)
append.AddInputDataObject(polyVtkList[category])
append.Update()
# Create the RenderWindow, Renderer
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.OffScreenRenderingOn()
renWin.SetSize(dtm.RasterXSize, dtm.RasterYSize)
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren)
# show the buildings
trisBuildingsFilter = vtk.vtkTriangleFilter()
trisBuildingsFilter.SetInputDataObject(append.GetOutput())
trisBuildingsFilter.Update()
p2cBuildings = vtk.vtkPointDataToCellData()
p2cBuildings.SetInputConnection(trisBuildingsFilter.GetOutputPort())
p2cBuildings.PassPointDataOn()
p2cBuildings.Update()
buildingsScalarRange = p2cBuildings.GetOutput().GetCellData().GetScalars(
).GetRange()
if (args.debug):
polyWriter = vtk.vtkXMLPolyDataWriter()
polyWriter.SetFileName("p2c.vtp")
polyWriter.SetInputConnection(p2cBuildings.GetOutputPort())
polyWriter.Write()
buildingsMapper = vtk.vtkPolyDataMapper()
buildingsMapper.SetInputDataObject(p2cBuildings.GetOutput())
buildingsActor = vtk.vtkActor()
buildingsActor.SetMapper(buildingsMapper)
ren.AddActor(buildingsActor)
if (args.render_png):
print("Render into a PNG ...")
# Show the terrain.
print("Converting the DTM into a surface ...")
# read the DTM as a VTK object
dtmReader = vtk.vtkGDALRasterReader()
dtmReader.SetFileName(args.input_dtm)
dtmReader.Update()
dtmVtk = dtmReader.GetOutput()
# Convert the terrain into a polydata.
surface = vtk.vtkImageDataGeometryFilter()
surface.SetInputDataObject(dtmVtk)
# Make sure the polygons are planar, so need to use triangles.
tris = vtk.vtkTriangleFilter()
tris.SetInputConnection(surface.GetOutputPort())
# Warp the surface by scalar values
warp = vtk.vtkWarpScalar()
warp.SetInputConnection(tris.GetOutputPort())
warp.SetScaleFactor(1)
warp.UseNormalOn()
warp.SetNormal(0, 0, 1)
warp.Update()
dsmScalarRange = warp.GetOutput().GetPointData().GetScalars().GetRange(
)
dtmMapper = vtk.vtkPolyDataMapper()
dtmMapper.SetInputConnection(warp.GetOutputPort())
dtmActor = vtk.vtkActor()
dtmActor.SetMapper(dtmMapper)
ren.AddActor(dtmActor)
ren.ResetCamera()
camera = ren.GetActiveCamera()
camera.ParallelProjectionOn()
camera.SetParallelScale((dtmBounds[3] - dtmBounds[2]) / 2)
if (args.buildings_only):
scalarRange = buildingsScalarRange
else:
scalarRange = [
min(dsmScalarRange[0], buildingsScalarRange[0]),
max(dsmScalarRange[1], buildingsScalarRange[1])
]
lut = vtk.vtkColorTransferFunction()
lut.AddRGBPoint(scalarRange[0], 0.23, 0.30, 0.75)
lut.AddRGBPoint((scalarRange[0] + scalarRange[1]) / 2, 0.86, 0.86,
0.86)
lut.AddRGBPoint(scalarRange[1], 0.70, 0.02, 0.15)
dtmMapper.SetLookupTable(lut)
dtmMapper.SetColorModeToMapScalars()
buildingsMapper.SetLookupTable(lut)
if (args.buildings_only):
ren.RemoveActor(dtmActor)
renWin.Render()
windowToImageFilter = vtk.vtkWindowToImageFilter()
windowToImageFilter.SetInput(renWin)
windowToImageFilter.SetInputBufferTypeToRGBA()
windowToImageFilter.ReadFrontBufferOff()
windowToImageFilter.Update()
writerPng = vtk.vtkPNGWriter()
writerPng.SetFileName(args.output_dsm + ".png")
writerPng.SetInputConnection(windowToImageFilter.GetOutputPort())
writerPng.Write()
else:
print("Render into a floating point buffer ...")
ren.ResetCamera()
camera = ren.GetActiveCamera()
camera.ParallelProjectionOn()
camera.SetParallelScale((dtmBounds[3] - dtmBounds[2]) / 2)
distance = camera.GetDistance()
focalPoint = [(dtmBounds[0] + dtmBounds[1]) * 0.5,
(dtmBounds[3] + dtmBounds[2]) * 0.5,
(buildingsScalarRange[0] + buildingsScalarRange[1]) * 0.5
]
position = [focalPoint[0], focalPoint[1], focalPoint[2] + distance]
camera.SetFocalPoint(focalPoint)
camera.SetPosition(position)
valuePass = vtk.vtkValuePass()
valuePass.SetRenderingMode(vtk.vtkValuePass.FLOATING_POINT)
# use the default scalar for point data
valuePass.SetInputComponentToProcess(0)
valuePass.SetInputArrayToProcess(
vtk.VTK_SCALAR_MODE_USE_POINT_FIELD_DATA, arrayName)
passes = vtk.vtkRenderPassCollection()
passes.AddItem(valuePass)
sequence = vtk.vtkSequencePass()
sequence.SetPasses(passes)
cameraPass = vtk.vtkCameraPass()
cameraPass.SetDelegatePass(sequence)
ren.SetPass(cameraPass)
# We have to render the points first, otherwise we get a segfault.
renWin.Render()
valuePass.SetInputArrayToProcess(
vtk.VTK_SCALAR_MODE_USE_CELL_FIELD_DATA, arrayName)
renWin.Render()
elevationFlatVtk = valuePass.GetFloatImageDataArray(ren)
valuePass.ReleaseGraphicsResources(renWin)
print("Writing the DSM ...")
elevationFlat = numpy_support.vtk_to_numpy(elevationFlatVtk)
# VTK X,Y corresponds to numpy cols,rows. VTK stores arrays
# in Fortran order.
elevationTranspose = numpy.reshape(elevationFlat,
[dtm.RasterXSize, dtm.RasterYSize],
"F")
# changes from cols, rows to rows,cols.
elevation = numpy.transpose(elevationTranspose)
# numpy rows increase as you go down, Y for VTK images increases as you go up
elevation = numpy.flip(elevation, 0)
if args.buildings_only:
dsmElevation = elevation
else:
# elevation has nans in places other than buildings
dsmElevation = numpy.fmax(dtmRaster, elevation)
dsm.GetRasterBand(1).WriteArray(dsmElevation)
if nodata:
dsm.GetRasterBand(1).SetNoDataValue(nodata)
newArray.SetValue(idx * 3, int(value % 256))
newArray.SetValue(idx * 3 + 1, int(value / 256 % 256))
newArray.SetValue(idx * 3 + 2, int(value / 256 / 256))
# if idx % progress == 0:
# count = count + 1
# print count
# # sys.stdout.write('.')
# # sys.stdout.flush()
# #sys. "\rProcessing %s: %d %s" % (array.GetName(), count, "/-\\|"[count%4])
print
# Pipeline
writer = vtkPNGWriter()
reader = vtkXMLImageDataReader()
filter = vtkProgrammableFilter()
filter.SetExecuteMethod(unfoldData)
# Loop over files to process
idx = 0
for fileName in fileNames:
directory = outputDir + ('/%d/' % idx)
# Make sure the destination directory exist
if not os.path.exists(directory):
os.makedirs(directory)
reader.SetFileName(basePath + '/' + fileName)
reader.Update()
def record(ren, outdir, prefix, cam_pos=None, cam_focal=None,
cam_view=None, n_frames=1, az_ang=10, size=(300, 300),
animate=False, delay=100, verbose=False):
""" This will record a snap/video of the rendered objects.
Records a video as a series of ".png" files by rotating the azimuth angle
'az_ang' in every frame.
Parameters
----------
ren: vtkRenderer() object (mandatory)
as returned from function ren()
outdir: str (mandatory)
the output directory.
prefix: str (mandatory)
the png snap base names.
cam_pos: 3-uplet (optional, default None)
the camera position.
cam_focal: 3-uplet (optional, default None)
the camera focal point.
cam_view: 3-uplet (optional, default None)
the camera view up.
n_frames: int (optional, default 1)
the number of frames to save.
az_ang: float (optional, default 10)
the azimuthal angle of camera rotation (in degrees).
size: 2-uplet (optional, default (300, 300))
(width, height) of the window.
animate: bool (optional, default False)
if True agglomerate the generated snaps in a Gif and delete the
raw snaps.
delay: int (optional, default 100)
this option is useful for regulating the animation of image
sequences ticks/ticks-per-second seconds must expire before the
display of the next image. The default is no delay between each
showing of the image sequence. The default ticks-per-second is 100.
verbose: bool (optional, default False)
if True display debuging message.
Returns
-------
snaps: list of str
the generated snaps.
"""
# Create a window and a interactor
window = vtk.vtkRenderWindow()
window.AddRenderer(ren)
window.SetSize(size)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(window)
# Set the camera properties
ren.ResetCamera()
camera = ren.GetActiveCamera()
if cam_pos is not None:
camera.SetPosition(cam_pos)
if cam_focal is not None:
camera.SetFocalPoint(cam_focal)
if cam_view is not None:
camera.SetViewUp(cam_view)
if verbose:
print("Camera Position (%.2f,%.2f,%.2f)" % camera.GetPosition())
print("Camera Focal Point (%.2f,%.2f,%.2f)" % camera.GetFocalPoint())
print("Camera View Up (%.2f,%.2f,%.2f)" % camera.GetViewUp())
# Create 'n_frames' by rotating each time the scene by 'az_ang' degrees
writer = vtk.vtkPNGWriter()
snaps = []
for index in range(n_frames):
render = vtk.vtkRenderLargeImage()
render.SetInput(ren)
render.SetMagnification(1)
render.Update()
writer.SetInputConnection(render.GetOutputPort())
current_prefix = prefix
if n_frames > 1:
current_prefix += "-" + str(index + 1).zfill(8)
snap_file = os.path.join(outdir, current_prefix + ".png")
writer.SetFileName(snap_file)
snaps.append(snap_file)
writer.Write()
camera.Azimuth(az_ang)
# Create an animation
if animate:
giffile = os.path.join(outdir, prefix + ".gif")
images_to_gif(snaps, giffile, delay=delay)
for fname in snaps:
os.remove(fname)
snaps = [giffile]
return snaps
def main(filename="frame/f.png",yc=6, n=0):
print(ocl.revision())
f=ocl.Ocode()
f.set_depth(7) # depth and scale set here.
f.set_scale(1)
myscreen = camvtk.VTKScreen()
myscreen.camera.SetPosition(50, 22, 40)
myscreen.camera.SetFocalPoint(0,0, 0)
myscreen.camera.Azimuth( n*0.5 )
# box around octree
oct_cube = camvtk.Cube(center=(0,0,0), length=4*f.get_scale(), color=camvtk.white)
oct_cube.SetWireframe()
myscreen.addActor(oct_cube)
# screenshot writer
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(myscreen.renWin)
lwr = vtk.vtkPNGWriter()
lwr.SetInput( w2if.GetOutput() )
# X Y Z arrows
arrowcenter=(1,2,0)
xar = camvtk.Arrow(color=camvtk.red, center=arrowcenter, rotXYZ=(0,0,0))
myscreen.addActor(xar)
yar = camvtk.Arrow(color=camvtk.green, center=arrowcenter, rotXYZ=(0,0,90))
myscreen.addActor(yar)
zar = camvtk.Arrow(color=camvtk.blue, center=arrowcenter, rotXYZ=(0,-90,0))
myscreen.addActor(zar)
t = ocl.LinOCT()
t2 = ocl.LinOCT()
t.init(5)
t2.init(4)
print(" after init() t :", t.str())
print(" after init() t2 :", t2.str())
c = ocl.CylCutter(1) # cutter
c.length = 3
print("cutter length=", c.length)
p1 = ocl.Point(-0.2,-0.2,0.2) # start of move
p2 = ocl.Point(1.5,1.5,-1) # end of move
# volume of g1 move
g1vol = ocl.CylMoveOCTVolume(c, p1, p2)
# sphere
svol = ocl.SphereOCTVolume()
svol.radius=1
svol.center = ocl.Point(0,0,1)
svol.calcBB()
# cube
cube1 = ocl.CubeOCTVolume()
cube1.side=2.123
cube1.center = ocl.Point(0,0,0)
cube1.calcBB()
#cylinder volume at start of move
cylvol = ocl.CylinderOCTVolume()
cylvol.p1 = ocl.Point(p1)
cylvol.p2 = ocl.Point(p1)+ocl.Point(0,0,c.length)
cylvol.radius= c.radius
cylvol.calcBB()
# draw exact cylinder
cp = 0.5*(cylvol.p1 + cylvol.p2)
height = (cylvol.p2-cylvol.p1).norm()
cylvolactor = camvtk.Cylinder(center=(cp.x, cp.y, cp.z-float(height)/2), radius = cylvol.radius, height=height, rotXYZ=(90,0,0))
cylvolactor.SetWireframe()
myscreen.addActor(cylvolactor)
# cylinder at start of move
#drawCylCutter(myscreen, c, p1)
# cylinder at end of move
drawCylCutter(myscreen, c, p2)
# green ball at start of move
startp = camvtk.Sphere(center=(p1.x,p1.y,p1.z), radius=0.1, color=camvtk.green)
myscreen.addActor(startp)
# red ball at end of move
endp = camvtk.Sphere(center=(p2.x,p2.y,p2.z), radius=0.1, color=camvtk.red)
myscreen.addActor(endp)
# build g1 tree
t_before = time.time()
t.build( g1vol )
t_after = time.time()
print("g1 build took ", t_after-t_before," s")
# build cube
t_before = time.time()
t2.build( cube1 )
t_after = time.time()
print("cube build took ", t_after-t_before," s")
#t.sort()
#t2.sort()
print("calling diff()...",)
t_before = time.time()
#dt = t2.operation(1,t)
t2.diff(t)
t_after = time.time()
print("done.")
print("diff took ", t_after-t_before," s")
print("diff has ", t2.size()," nodes")
# original trees
print("drawing trees")
drawTree2(myscreen,t,opacity=1, color=camvtk.green)
drawTree2(myscreen,t2,opacity=0.2, color=camvtk.cyan)
drawTree2(myscreen,t2,opacity=1, color=camvtk.cyan, offset=(5,0,0))
# elliptical tube
pmax = p1 + 1.5* (p2-p1)
pmin = p1 - 0.5* (p2-p1)
myscreen.addActor( camvtk.Sphere(center=(pmax.x,pmax.y,pmax.z), radius=0.1, color=camvtk.lgreen) )
myscreen.addActor( camvtk.Sphere(center=(pmin.x,pmin.y,pmin.z), radius=0.1, color=camvtk.pink) )
aaxis = pmin + ocl.Point(-0.353553, 0.353553, 0)
baxis = pmin + ocl.Point(0.0243494, 0.0243494, 0.126617)
myscreen.addActor( camvtk.Sphere(center=(aaxis.x,aaxis.y,aaxis.z), radius=0.1, color=camvtk.orange) )
myscreen.addActor( camvtk.Sphere(center=(baxis.x,baxis.y,baxis.z), radius=0.1, color=camvtk.yellow) )
title = camvtk.Text()
title.SetPos( (myscreen.width-350, myscreen.height-30) )
title.SetText("OpenCAMLib " + datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
myscreen.addActor(title)
print(" render()...",)
myscreen.render()
print("done.")
lwr.SetFileName(filename)
time.sleep(0.2)
#lwr.Write()
myscreen.iren.Start()
def drawScreen(a,b,c,filename,write_flag):
print ocl.revision()
myscreen = camvtk.VTKScreen()
z_hi = a.z
if b.z > z_hi:
z_hi = b.z
if c.z > z_hi:
z_hi = c.z
z_lo = a.z
if b.z < z_lo:
z_lo = b.z
if c.z < z_lo:
z_lo = c.z
#z_hi = 0.3 # this is the shallow case
#ztri = 0.8 # this produces the steep case where we hit the circular rim
#z_lo = 0.1
#a = ocl.Point(0,1,ztri)
#b = ocl.Point(1,0.5,ztri)
#c = ocl.Point(0.2,0.2,ztri_lo)
myscreen.addActor(camvtk.Point(center=(a.x,a.y,a.z), color=(1,0,1)))
myscreen.addActor(camvtk.Point(center=(b.x,b.y,b.z), color=(1,0,1)))
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)
angle = math.pi/5
diameter=0.3
length=5
#cutter = ocl.BallCutter(diameter, length)
#cutter = ocl.CylCutter(diameter, length)
#cutter = ocl.BullCutter(diameter, diameter/4, length)
cutter = ocl.ConeCutter(diameter, angle, length)
#cutter = cutter.offsetCutter( 0.1 )
print "cutter= ", cutter
print "length=", cutter.getLength()
print "fiber..."
range=2
Nmax = 100
yvals = [float(n-float(Nmax)/2)/Nmax*range for n in xrange(0,Nmax+1)]
xvals = [float(n-float(Nmax)/2)/Nmax*range for n in xrange(0,Nmax+1)]
zmin = z_lo - 0.3
zmax = z_hi
zNmax = 20
dz = (zmax-zmin)/(zNmax-1)
zvals=[]
for n in xrange(0,zNmax):
zvals.append(zmin+n*dz)
for zh in zvals:
yfiber(cutter,yvals,t,zh,myscreen)
xfiber(cutter,xvals,t,zh,myscreen)
print "done."
myscreen.camera.SetPosition(-2, -1, 3)
myscreen.camera.SetFocalPoint(1.0, 0.0, -0.5)
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
def dump_image_to_file(fname, img):
wr = vtk.vtkPNGWriter()
wr.SetFileName(fname)
wr.SetInputData(img)
wr.Write()
def build_jpeg_preview(
self,
file_path: str,
preview_name: str,
cache_path: str,
page_id: int,
extension: str = ".jpg",
size: ImgDims = None,
mimetype: str = "",
) -> None:
if not size:
size = self.default_size
tmp_filename = "{}.png".format(str(uuid.uuid4()))
if tempfile.tempdir:
tmp_filepath = os.path.join(tempfile.tempdir, tmp_filename)
else:
tmp_filepath = tmp_filename
colors = vtkNamedColors()
reader = vtkSTLReader() # TODO analyse wich file format is use
reader.SetFileName(file_path)
mapper = vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtkActor()
actor.SetMapper(mapper)
rotation = (-70, 0, 45)
R_x, R_y, R_z = rotation # TODO set a good looking default orientation
actor.RotateX(R_x)
actor.RotateY(R_y)
actor.RotateZ(R_z)
# Create a rendering window and renderer
ren = vtkRenderer()
renWin = vtkRenderWindow()
renWin.OffScreenRenderingOn()
renWin.AddRenderer(ren)
ren.SetBackground(colors.GetColor3d("white"))
# Assign actor to the renderer
ren.AddActor(actor)
renWin.Render()
# Write image
windowto_image_filter = vtkWindowToImageFilter()
windowto_image_filter.SetInput(renWin)
# windowto_image_filter.SetScale(scale) # image scale
windowto_image_filter.SetInputBufferTypeToRGBA()
writer = vtkPNGWriter()
writer.SetFileName(tmp_filepath)
writer.SetInputConnection(windowto_image_filter.GetOutputPort())
writer.Write()
return ImagePreviewBuilderPillow().build_jpeg_preview(
tmp_filepath, preview_name, cache_path, page_id, extension, size,
mimetype)
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(1,1,self.Zaspect)
self.rActor.SetScale(s)
self.rActor.Modified()
if hasattr(self, 'fActor'):
# self.fActor.SetScale(1,1,self.Zaspect)
self.fActor.SetScale(s)
self.fActor.Modified()
if hasattr(self, 'svd_pointActor'):
self.svd_pointActor.SetScale(s)
self.svd_pointActor.Modified()
self.add_axis(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()
self.add_axis(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()
self.add_axis(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("point_cloud.png")
writer.Write()
print('Screen output saved to %s' %
os.path.join(os.getcwd(), 'point_cloud.png'))
elif key == "a":
if hasattr(self, 'ax3D'):
flip_visible(self.ax3D)
elif key == "o":
if hasattr(self, 'outlineActor'):
flip_visible(self.outlineActor)
elif key == "f":
if hasattr(self, 'ax3D'):
flip_colors(self.ren, self.ax3D)
elif key == "r":
if self.picking == True:
self.picking = False
self.show_picking()
else:
self.picking = True
self.show_picking()
self.start_pick()
elif key == "l":
self.load_mat()
self.ui.vtkWidget.update()
self.ui.vtkWidget.setFocus()
def write(objct, fileoutput, binary=True):
"""
Write 3D object to file. (same as `save()`).
Possile extensions are:
- vtk, vti, npy, ply, obj, stl, byu, vtp, vti, mhd, xyz, tif, png, bmp.
"""
obj = objct
if isinstance(obj, Mesh): # picks transformation
obj = objct.polydata(True)
elif isinstance(obj, (vtk.vtkActor, vtk.vtkVolume)):
obj = objct.GetMapper().GetInput()
elif isinstance(obj, (vtk.vtkPolyData, vtk.vtkImageData)):
obj = objct
fr = fileoutput.lower()
if fr.endswith(".vtk"):
writer = vtk.vtkPolyDataWriter()
elif fr.endswith(".ply"):
writer = vtk.vtkPLYWriter()
pscal = obj.GetPointData().GetScalars()
if not pscal:
pscal = obj.GetCellData().GetScalars()
if pscal and pscal.GetName():
writer.SetArrayName(pscal.GetName())
#writer.SetColorMode(0)
lut = objct.GetMapper().GetLookupTable()
if lut:
writer.SetLookupTable(lut)
elif fr.endswith(".stl"):
writer = vtk.vtkSTLWriter()
elif fr.endswith(".vtp"):
writer = vtk.vtkXMLPolyDataWriter()
elif fr.endswith(".vtm"):
g = vtk.vtkMultiBlockDataGroupFilter()
for ob in objct:
if isinstance(ob, Mesh): # picks transformation
ob = ob.polydata(True)
elif isinstance(ob, (vtk.vtkActor, vtk.vtkVolume)):
ob = ob.GetMapper().GetInput()
g.AddInputData(ob)
g.Update()
mb = g.GetOutputDataObject(0)
wri = vtk.vtkXMLMultiBlockDataWriter()
wri.SetInputData(mb)
wri.SetFileName(fileoutput)
wri.Write()
return mb
elif fr.endswith(".xyz"):
writer = vtk.vtkSimplePointsWriter()
elif fr.endswith(".facet"):
writer = vtk.vtkFacetWriter()
elif fr.endswith(".tif"):
writer = vtk.vtkTIFFWriter()
writer.SetFileDimensionality(len(obj.GetDimensions()))
elif fr.endswith(".vti"):
writer = vtk.vtkXMLImageDataWriter()
elif fr.endswith(".mhd"):
writer = vtk.vtkMetaImageWriter()
elif fr.endswith(".nii"):
writer = vtk.vtkNIFTIImageWriter()
elif fr.endswith(".png"):
writer = vtk.vtkPNGWriter()
elif fr.endswith(".jpg"):
writer = vtk.vtkJPEGWriter()
elif fr.endswith(".bmp"):
writer = vtk.vtkBMPWriter()
elif fr.endswith(".npy"):
if utils.isSequence(objct):
objslist = objct
else:
objslist = [objct]
dicts2save = []
for obj in objslist:
dicts2save.append( _np_dump(obj) )
np.save(fileoutput, dicts2save)
return dicts2save
elif fr.endswith(".obj"):
outF = open(fileoutput, "w")
outF.write('# OBJ file format with ext .obj\n')
outF.write('# File Created by vtkplotter\n')
cobjct = objct.clone().clean()
for p in cobjct.points():
outF.write('v '+ str(p[0]) +" "+ str(p[1])+" "+ str(p[2])+'\n')
for vn in cobjct.normals(cells=False):
outF.write('vn '+str(vn[0])+" "+str(vn[1])+" "+str(vn[2])+'\n')
#pdata = cobjct.polydata().GetPointData().GetScalars()
#if pdata:
# ndata = vtk_to_numpy(pdata)
# for vd in ndata:
# outF.write('vp '+ str(vd) +'\n')
#ptxt = cobjct.polydata().GetPointData().GetTCoords() # not working
#if ptxt:
# ntxt = vtk_to_numpy(ptxt)
# print(len(cobjct.faces()), cobjct.points().shape, ntxt.shape)
# for vt in ntxt:
# outF.write('vt '+ str(vt[0]) +" "+ str(vt[1])+ ' 0\n')
for f in cobjct.faces():
fs = ''
for fi in f:
fs += " "+str(fi+1)
outF.write('f' + fs + '\n')
#ldata = cobjct.polydata().GetLines().GetData()
#print(cobjct.polydata().GetLines())
#if ldata:
# ndata = vtk_to_numpy(ldata)
# print(ndata)
# for l in ndata:
# ls = ''
# for li in l:
# ls += str(li+1)+" "
# outF.write('l '+ ls + '\n')
outF.close()
return objct
elif fr.endswith(".xml"): # write tetrahedral dolfin xml
vertices = objct.points().astype(str)
faces = np.array(objct.faces()).astype(str)
ncoords = vertices.shape[0]
outF = open(fileoutput, "w")
outF.write('<?xml version="1.0" encoding="UTF-8"?>\n')
outF.write('<dolfin xmlns:dolfin="http://www.fenicsproject.org">\n')
if len(faces[0]) == 4:# write tetrahedral mesh
ntets = faces.shape[0]
outF.write(' <mesh celltype="tetrahedron" dim="3">\n')
outF.write(' <vertices size="' + str(ncoords) + '">\n')
for i in range(ncoords):
x, y, z = vertices[i]
outF.write(' <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'" z="'+z+'"/>\n')
outF.write(' </vertices>\n')
outF.write(' <cells size="' + str(ntets) + '">\n')
for i in range(ntets):
v0, v1, v2, v3 = faces[i]
outF.write(' <tetrahedron index="'+str(i)
+ '" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'" v3="'+v3+'"/>\n')
elif len(faces[0]) == 3:# write triangle mesh
ntri = faces.shape[0]
outF.write(' <mesh celltype="triangle" dim="2">\n')
outF.write(' <vertices size="' + str(ncoords) + '">\n')
for i in range(ncoords):
x, y, dummy_z = vertices[i]
outF.write(' <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'"/>\n')
outF.write(' </vertices>\n')
outF.write(' <cells size="' + str(ntri) + '">\n')
for i in range(ntri):
v0, v1, v2 = faces[i]
outF.write(' <triangle index="'+str(i)+'" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'"/>\n')
outF.write(' </cells>\n')
outF.write(" </mesh>\n")
outF.write("</dolfin>\n")
outF.close()
return objct
else:
colors.printc("~noentry Unknown format", fileoutput, "file not saved.", c="r")
return objct
try:
if hasattr(writer, 'SetFileTypeToBinary'):
if binary:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
writer.SetInputData(obj)
writer.SetFileName(fileoutput)
writer.Write()
except Exception as e:
colors.printc("~noentry Error saving: " + fileoutput, "\n", e, c="r")
return objct
# 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 = vtk.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
interactor.Initialize()
render_window.Render()
def plotResult3D_OS(self, dpt, T, gt3Dorig, joint3D, visibility=None, filename=None, showGT=True, showPC=True,
niceColors=False, width=300, height=300):
"""
Plot 3D point cloud
:param dpt: depth image
:param T: 2D image transformation
:param gt3Dorig: groundtruth 3D pose
:param joint3D: 3D joint data
:param visibility: plot different markers for visible/non-visible joints, visible are marked as 1, non-visible 0
:param filename: name of file to save, if None return image
:param showGT: show groundtruth annotation
:param showPC: show point cloud
:param width: width of window
:param height: height of window
:return: None, or image if filename=None
"""
import vtk
from vtk.util.numpy_support import vtk_to_numpy
from util.vtkpointcloud import VtkPointCloud
# Renderer
renderer = vtk.vtkRenderer()
renderer.SetBackground(1.0, 1.0, 1.0)
if showPC is True:
pointCloud = VtkPointCloud()
pcl = self.getPCL(dpt, T)
for k in xrange(pcl.shape[0]):
point = pcl[k]
pointCloud.addPoint(point)
renderer.AddActor(pointCloud.vtkActor)
renderer.ResetCamera()
self.vtkPlotHand(renderer, joint3D, visibility, 'nice' if niceColors is True else (1, 0, 0))
if showGT:
self.vtkPlotHand(renderer, gt3Dorig, visibility, 'nice' if niceColors is True else (0, 0, 1))
# setup camera position
camera = renderer.GetActiveCamera()
camera.Pitch(self.VTKviewport[0])
camera.Yaw(self.VTKviewport[1])
camera.Roll(self.VTKviewport[2])
camera.Azimuth(self.VTKviewport[3])
camera.Elevation(self.VTKviewport[4])
# Render Window
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetOffScreenRendering(1)
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(width, height)
if showPC is False:
renderer.ResetCamera()
# setup camera position
camera = renderer.GetActiveCamera()
camera.Pitch(self.VTKviewport[0])
camera.Yaw(self.VTKviewport[1])
camera.Roll(self.VTKviewport[2])
camera.Azimuth(self.VTKviewport[3])
camera.Elevation(self.VTKviewport[4])
# Render window
renderWindow.Render()
if filename is not None:
im = vtk.vtkWindowToImageFilter()
writer = vtk.vtkPNGWriter()
im.SetInput(renderWindow)
im.Update()
writer.SetInputConnection(im.GetOutputPort())
writer.SetFileName('{}/{}.png'.format(self.subfolder, filename))
writer.Write()
else:
im = vtk.vtkWindowToImageFilter()
im.SetInput(renderWindow)
im.Update()
vtk_image = im.GetOutput()
height, width, _ = vtk_image.GetDimensions()
vtk_array = vtk_image.GetPointData().GetScalars()
components = vtk_array.GetNumberOfComponents()
return vtk_to_numpy(vtk_array).reshape(height, width, components)
maptocolor = vtk.vtkImageMapToColors()
maptocolor.SetOutputFormatToRGB()
maptocolor.SetInput(itfmap.GetOutput())
maptocolor.SetLookupTable(ctf1)
mip = vtkbxd.vtkImageSimpleMIP()
print "Feeding merge to MIP", elapsed()
mip.SetInput(merge.GetOutput())
#flip =vtk.vtkImageFlip()
#flip.SetFilteredAxis(1)
#flip.SetInput(mip.GetOutput())
writer = vtk.vtkPNGWriter()
writer.SetFileName("ITFmapped.png")
writer.SetInput(mip.GetOutput())
print "Feeding MIP to writer ", elapsed()
writer.Update()
writer.Write()
print "Wrote PNG ", elapsed()
mip2 = vtkbxds.vtkImageSimpleMIP()
mip2.SetInput(maptocolor.GetOutput())
writer2 = vtk.vtkPNGWriter()
writer2.SetFileName("ITFmapped2.png")
writer2.SetInput(mip2.GetOutput())
writer2.Update()
writer2.Write()
mip.Update()
def DisplayCone(nc):
'''
Create a cone, contour it using the banded contour filter and
color it with the primary additive and subtractive colors.
:param: nc: The vtkNamedColor class
:return: The render window interactor.
'''
# Create a cone
coneSource = vtk.vtkConeSource()
coneSource.SetCenter(0.0, 0.0, 0.0)
coneSource.SetRadius(5.0)
coneSource.SetHeight(10)
coneSource.SetDirection(0, 1, 0)
coneSource.Update()
bounds = [1.0, -1.0, 1.0, -1.0, 1.0, -1.0]
coneSource.GetOutput().GetBounds(bounds)
elevation = vtk.vtkElevationFilter()
elevation.SetInputConnection(coneSource.GetOutputPort())
elevation.SetLowPoint(0, bounds[2], 0)
elevation.SetHighPoint(0, bounds[3], 0)
bcf = vtk.vtkBandedPolyDataContourFilter()
bcf.SetInputConnection(elevation.GetOutputPort())
bcf.SetScalarModeToValue()
bcf.GenerateContourEdgesOn()
bcf.GenerateValues(7, elevation.GetScalarRange())
# Build a simple lookup table of
# primary additive and subtractive colors.
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(7)
# Test setting and getting a color here.
# We are also modifying alpha.
# Convert to a list so that
# SetColor(name,rgba) works.
rgba = list(nc.GetColor4d("Red"))
rgba[3] = 0.5
nc.SetColor("My Red", rgba)
rgba = nc.GetColor4d("My Red")
lut.SetTableValue(0, rgba)
# Does "My Red" match anything?
match = FindSynonyms(nc, "My Red")
print("Matching colors to My Red:", match)
rgba = nc.GetColor4d("DarkGreen")
rgba[3] = 0.3
lut.SetTableValue(1, rgba)
# Alternatively we can use our wrapper functions:
lut.SetTableValue(2, nc.GetColor4d("Blue"))
lut.SetTableValue(3, nc.GetColor4d("Cyan"))
lut.SetTableValue(4, nc.GetColor4d("Magenta"))
lut.SetTableValue(5, nc.GetColor4d("Yellow"))
lut.SetTableValue(6, nc.GetColor4d("White"))
lut.SetTableRange(elevation.GetScalarRange())
lut.Build()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(bcf.GetOutputPort())
mapper.SetLookupTable(lut)
mapper.SetScalarModeToUseCellData()
contourLineMapper = vtk.vtkPolyDataMapper()
contourLineMapper.SetInputData(bcf.GetContourEdgesOutput())
contourLineMapper.SetScalarRange(elevation.GetScalarRange())
contourLineMapper.SetResolveCoincidentTopologyToPolygonOffset()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
contourLineActor = vtk.vtkActor()
actor.SetMapper(mapper)
contourLineActor.SetMapper(contourLineMapper)
contourLineActor.GetProperty().SetColor(nc.GetColor3d("black"))
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(actor)
renderer.AddActor(contourLineActor)
renderer.SetBackground(nc.GetColor3d("SteelBlue"))
renderWindow.Render()
fnsave = "TestNamedColorsIntegration.png"
renLgeIm = vtk.vtkRenderLargeImage()
imgWriter = vtk.vtkPNGWriter()
renLgeIm.SetInput(renderer)
renLgeIm.SetMagnification(1)
imgWriter.SetInputConnection(renLgeIm.GetOutputPort())
imgWriter.SetFileName(fnsave)
# imgWriter.Write()
return renderWindowInteractor
def draw_old(self, screenshot_data, bsd, screenshot_name):
# drawing_params = DrawingParameters()
# bsd = BasicSimulationData()
# drawing_params.bsd = bsd
#
# drawing_params.plane = 'XY'
# drawing_params.planePos = 0
# drawing_params.fieldName = 'CellField'
# drawing_params.fieldType = 'CellField'
# self.drawModel2D.setDrawingParametersObject(drawing_params)
# self.ren = vtk.vtkRenderer()
# renWin = vtk.vtkRenderWindow()
# renWin.SetOffScreenRendering(1)
# renWin.AddRenderer(self.ren)
# renderWindowInteractor = vtk.vtkRenderWindowInteractor()
# renderWindowInteractor.SetRenderWindow(renderWindow)
drawing_params = DrawingParameters()
drawing_params.screenshot_data = screenshot_data
drawing_params.bsd = bsd
drawing_params.plane = screenshot_data.projection
drawing_params.planePosition = screenshot_data.projectionPosition
drawing_params.planePos = screenshot_data.projectionPosition
drawing_params.fieldName = screenshot_data.plotData[0] # e.g. plotData = ('Cell_Field','CellField')
drawing_params.fieldType = screenshot_data.plotData[0]
model, view = self.get_model_view(screenshot_data.spaceDimension)
model.setDrawingParametersObject(drawing_params)
view.drawCellFieldLocalNew(drawing_params, None)
# self.draw_model_2D.setDrawingParametersObject(drawing_params)
#
# self.draw_view_2D.drawCellFieldLocalNew(drawing_params, None)
# # self.draw2D.drawCellFieldLocalNew_1(self.ren)
# coneSource = vtk.vtkConeSource()
# coneSource.SetResolution(60)
# coneSource.SetCenter(-2, 0, 0)
# # Create a mapper and actor
# mapper = vtk.vtkPolyDataMapper()
# mapper.SetInputConnection(coneSource.GetOutputPort())
# actor = vtk.vtkActor()
# actor.SetMapper(mapper)
#
# # Visualize
# renderer = vtk.vtkRenderer()
# renWin = vtk.vtkRenderWindow()
# renWin.SetOffScreenRendering(1)
# renWin.AddRenderer(renderer)
# renderWindowInteractor = vtk.vtkRenderWindowInteractor()
# renderWindowInteractor.SetRenderWindow(renderWindow)
# # OK
# coneSource = vtk.vtkConeSource()
# coneSource.SetResolution(60)
# coneSource.SetCenter(-2, 0, 0)
#
# # Create a mapper and actor
# mapper = vtk.vtkPolyDataMapper()
# mapper.SetInputConnection(coneSource.GetOutputPort())
# actor = vtk.vtkActor()
# actor.SetMapper(mapper)
#
# # Visualize
# renderer = vtk.vtkRenderer()
# renWin = vtk.vtkRenderWindow()
# renWin.SetOffScreenRendering(1)
# renWin.AddRenderer(renderer)
# # renderWindowInteractor = vtk.vtkRenderWindowInteractor()
# # renderWindowInteractor.SetRenderWindow(renderWindow)
#
# renderer.AddActor(actor)
# # renderer.SetBackground(.1, .2, .3) # Background color dark blue
# # renderer.SetBackground(.3, .2, .1) # Background color dark red
# renWin.Render()
# # OK
# coneSource = vtk.vtkConeSource()
# coneSource.SetResolution(60)
# coneSource.SetCenter(-2, 0, 0)
#
# # Create a mapper and actor
# mapper = vtk.vtkPolyDataMapper()
# mapper.SetInputConnection(coneSource.GetOutputPort())
# actor = vtk.vtkActor()
# actor.SetMapper(mapper)
#
# # Visualize
# # renderer = vtk.vtkRenderer()
# renderer = self.ren
# renWin = vtk.vtkRenderWindow()
# renWin.SetOffScreenRendering(1)
# renWin.AddRenderer(renderer)
# # renderWindowInteractor = vtk.vtkRenderWindowInteractor()
# # renderWindowInteractor.SetRenderWindow(renderWindow)
#
# renderer.AddActor(actor)
# # renderer.SetBackground(.1, .2, .3) # Background color dark blue
# # renderer.SetBackground(.3, .2, .1) # Background color dark red
# renWin.Render()
renWin = vtk.vtkRenderWindow()
renWin.SetOffScreenRendering(1)
renWin.AddRenderer(self.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_name))
writer.SetInputConnection(windowToImageFilter.GetOutputPort())
writer.Write()
def main():
"""This demo shows RPN proposals and MLOD predictions in the
3D point cloud.
Keys:
F1: Toggle proposals
F2: Toggle predictions
F3: Toggle 3D voxel grid
F4: Toggle point cloud
F5: Toggle easy ground truth objects (Green)
F6: Toggle medium ground truth objects (Orange)
F7: Toggle hard ground truth objects (Red)
F8: Toggle all ground truth objects (default off)
F9: Toggle ground slice filter (default off)
F10: Toggle offset slice filter (default off)
"""
##############################
# Options
##############################
rpn_score_threshold = 0.1
mlod_score_threshold = 0.1
proposals_line_width = 1.0
predictions_line_width = 3.0
show_orientations = True
point_cloud_source = 'lidar'
# Config file folder, default (<mlod_root>/data/outputs/<checkpoint_name>)
config_dir = None
checkpoint_name = 'mlod_fpn_people_n_m'
global_step = 135000 # Latest checkpoint
#data_split = 'val_half'
#data_split = 'val'
data_split = 'test'
# Show 3D iou text
draw_ious_3d = False
sample_name = '000031'
# # # Cars # # #
# sample_name = '000050'
# sample_name = '000104'
# sample_name = '000169'
# sample_name = '000191'
# sample_name = '000360'
# sample_name = '001783'
# sample_name = '001820'
# val split
# sample_name = '000181'
# sample_name = '000751'
# sample_name = '000843'
# sample_name = '000944'
# sample_name = '006338'
# # # People # # #
# val_half split
# sample_name = '000001' # Hard, 1 far cyc
# sample_name = '000005' # Easy, 1 ped
# sample_name = '000122' # Easy, 1 cyc
# sample_name = '000134' # Hard, lots of people
# sample_name = '000167' # Medium, 1 ped, 2 cycs
# sample_name = '000187' # Medium, 1 ped on left
# sample_name = '000381' # Easy, 1 ped
# sample_name = '000398' # Easy, 1 ped
# sample_name = '000401' # Hard, obscured peds
# sample_name = '000407' # Easy, 1 ped
# sample_name = '000448' # Hard, several far people
# sample_name = '000486' # Hard 2 obscured peds
# sample_name = '000509' # Easy, 1 ped
# sample_name = '000718' # Hard, lots of people
# sample_name = '002216' # Easy, 1 cyc
# val split
# sample_name = '000015'
# sample_name = '000048'
# sample_name = '000058'
# sample_name = '000076' # Medium, few ped, 1 cyc
# sample_name = '000108'
# sample_name = '000118'
# sample_name = '000145'
# sample_name = '000153'
# sample_name = '000186'
# sample_name = '000195'
# sample_name = '000199'
# sample_name = '000397'
# sample_name = '004425'
# sample_name = '004474' # Hard, many ped, 1 cyc
# sample_name = '004657' # Hard, Few cycl, few ped
# sample_name = '006071'
# sample_name = '006828' # Hard, Few cycl, few ped
# sample_name = '006908' # Hard, Few cycl, few ped
# sample_name = '007412'
# sample_name = '007318' # Hard, Few cycl, few ped
##############################
# End of Options
##############################
if data_split == 'test':
draw_ious_3d = False
if config_dir is None:
config_dir = mlod.root_dir() + '/data/outputs/' + checkpoint_name
# Parse experiment config
pipeline_config_file = \
config_dir + '/' + checkpoint_name + '.config'
_, _, _, dataset_config = \
config_builder_util.get_configs_from_pipeline_file(
pipeline_config_file, is_training=False)
dataset_config.data_split = data_split
if data_split == 'test':
dataset_config.data_split_dir = 'testing'
dataset_config.has_labels = False
dataset = DatasetBuilder.build_kitti_dataset(dataset_config,
use_defaults=False)
# Random sample
if sample_name is None:
sample_idx = np.random.randint(0, dataset.num_samples)
sample_name = dataset.sample_names[sample_idx]
##############################
# Setup Paths
##############################
img_idx = int(sample_name)
# Text files directory
proposals_and_scores_dir = mlod.root_dir() + \
'/data/outputs/' + checkpoint_name + '/predictions' + \
'/proposals_and_scores/' + dataset.data_split
predictions_and_scores_dir = mlod.root_dir() + \
'/data/outputs/' + checkpoint_name + '/predictions' + \
'/final_predictions_and_scores/' + dataset.data_split
# Get checkpoint step
steps = os.listdir(proposals_and_scores_dir)
steps.sort(key=int)
print('Available steps: {}'.format(steps))
# Use latest checkpoint if no index provided
if global_step is None:
global_step = steps[-1]
# Output images directory
img_out_dir = mlod.root_dir() + '/data/outputs/' + checkpoint_name + \
'/predictions/images_3d/{}/{}/{}'.format(dataset.data_split,
global_step,
rpn_score_threshold)
if not os.path.exists(img_out_dir):
os.makedirs(img_out_dir)
##############################
# Proposals
##############################
# Load proposals from files
proposals_and_scores = np.loadtxt(
proposals_and_scores_dir +
"/{}/{}.txt".format(global_step, sample_name))
proposals = proposals_and_scores[:, 0:7]
proposal_scores = proposals_and_scores[:, 7]
rpn_score_mask = proposal_scores > rpn_score_threshold
proposals = proposals[rpn_score_mask]
proposal_scores = proposal_scores[rpn_score_mask]
print('Proposals:', len(proposal_scores), proposal_scores)
proposal_objs = \
[box_3d_encoder.box_3d_to_object_label(proposal,
obj_type='Proposal')
for proposal in proposals]
##############################
# Predictions
##############################
# Load proposals from files
predictions_and_scores = np.loadtxt(
predictions_and_scores_dir +
"/{}/{}.txt".format(global_step, sample_name)).reshape(-1, 9)
prediction_boxes_3d = predictions_and_scores[:, 0:7]
prediction_scores = predictions_and_scores[:, 7]
prediction_types = np.asarray(predictions_and_scores[:, 8], dtype=np.int32)
mlod_score_mask = prediction_scores >= mlod_score_threshold
prediction_boxes_3d = prediction_boxes_3d[mlod_score_mask]
prediction_scores = prediction_scores[mlod_score_mask]
print('Predictions: ', len(prediction_scores), prediction_scores)
final_predictions = np.copy(prediction_boxes_3d)
# # Swap l, w for predictions where w > l
# swapped_indices = predictions[:, 4] > predictions[:, 3]
# final_predictions[swapped_indices, 3] = predictions[swapped_indices, 4]
# final_predictions[swapped_indices, 4] = predictions[swapped_indices, 3]
prediction_objs = []
dataset.classes = ['Pedestrian', 'Cyclist', 'Car']
for pred_idx in range(len(final_predictions)):
prediction_box_3d = final_predictions[pred_idx]
prediction_type = dataset.classes[prediction_types[pred_idx]]
prediction_obj = box_3d_encoder.box_3d_to_object_label(
prediction_box_3d, obj_type=prediction_type)
prediction_objs.append(prediction_obj)
##############################
# Ground Truth
##############################
dataset.has_labels = False
if dataset.has_labels:
# Get ground truth labels
easy_gt_objs, medium_gt_objs, \
hard_gt_objs, all_gt_objs = \
demo_utils.get_gts_based_on_difficulty(dataset, img_idx)
else:
easy_gt_objs = medium_gt_objs = hard_gt_objs = all_gt_objs = []
##############################
# 3D IoU
##############################
if draw_ious_3d:
# Convert to box_3d
all_gt_boxes_3d = [
box_3d_encoder.object_label_to_box_3d(gt_obj)
for gt_obj in all_gt_objs
]
pred_boxes_3d = [
box_3d_encoder.object_label_to_box_3d(pred_obj)
for pred_obj in prediction_objs
]
max_ious_3d = demo_utils.get_max_ious_3d(all_gt_boxes_3d,
pred_boxes_3d)
##############################
# Point Cloud
##############################
image_path = dataset.get_rgb_image_path(sample_name)
image = cv2.imread(image_path)
point_cloud = dataset.kitti_utils.get_point_cloud(point_cloud_source,
img_idx,
image_shape=image.shape)
point_cloud = np.asarray(point_cloud)
# Filter point cloud to extents
area_extents = np.asarray([[-40, 40], [-5, 3], [0, 70]])
bev_extents = area_extents[[0, 2]]
points = point_cloud.T
point_filter = obj_utils.get_point_filter(point_cloud, area_extents)
points = points[point_filter]
point_colours = vis_utils.project_img_to_point_cloud(
points, image, dataset.calib_dir, img_idx)
# Voxelize the point cloud for visualization
voxel_grid = VoxelGrid()
voxel_grid.voxelize(points, voxel_size=0.1, create_leaf_layout=False)
# Ground plane
ground_plane = obj_utils.get_road_plane(img_idx, dataset.planes_dir)
##############################
# Visualization
##############################
# Create VtkVoxelGrid
vtk_voxel_grid = VtkVoxelGrid()
vtk_voxel_grid.set_voxels(voxel_grid)
vtk_point_cloud = VtkPointCloud()
vtk_point_cloud.set_points(points, point_colours)
# Create VtkAxes
vtk_axes = vtk.vtkAxesActor()
vtk_axes.SetTotalLength(5, 5, 5)
# Create VtkBoxes for proposal boxes
vtk_proposal_boxes = VtkBoxes()
vtk_proposal_boxes.set_line_width(proposals_line_width)
vtk_proposal_boxes.set_objects(proposal_objs, COLOUR_SCHEME_PREDICTIONS)
# Create VtkBoxes for prediction boxes
vtk_prediction_boxes = VtkPyramidBoxes()
vtk_prediction_boxes.set_line_width(predictions_line_width)
vtk_prediction_boxes.set_objects(prediction_objs,
COLOUR_SCHEME_PREDICTIONS,
show_orientations)
# Create VtkBoxes for ground truth
vtk_hard_gt_boxes = VtkBoxes()
vtk_medium_gt_boxes = VtkBoxes()
vtk_easy_gt_boxes = VtkBoxes()
vtk_all_gt_boxes = VtkBoxes()
vtk_hard_gt_boxes.set_objects(hard_gt_objs, COLOUR_SCHEME_PREDICTIONS,
show_orientations)
vtk_medium_gt_boxes.set_objects(medium_gt_objs, COLOUR_SCHEME_PREDICTIONS,
show_orientations)
vtk_easy_gt_boxes.set_objects(easy_gt_objs, COLOUR_SCHEME_PREDICTIONS,
show_orientations)
vtk_all_gt_boxes.set_objects(all_gt_objs, VtkBoxes.COLOUR_SCHEME_KITTI,
show_orientations)
# Create VtkTextLabels for 3D ious
vtk_text_labels = VtkTextLabels()
if draw_ious_3d and len(all_gt_boxes_3d) > 0:
gt_positions_3d = np.asarray(all_gt_boxes_3d)[:, 0:3]
vtk_text_labels.set_text_labels(
gt_positions_3d,
['{:0.3f}'.format(iou_3d) for iou_3d in max_ious_3d])
# Create VtkGroundPlane
vtk_ground_plane = VtkGroundPlane()
vtk_slice_bot_plane = VtkGroundPlane()
vtk_slice_top_plane = VtkGroundPlane()
vtk_ground_plane.set_plane(ground_plane, bev_extents)
vtk_slice_bot_plane.set_plane(ground_plane + [0, 0, 0, -0.2], bev_extents)
vtk_slice_top_plane.set_plane(ground_plane + [0, 0, 0, -2.0], bev_extents)
# Create Voxel Grid Renderer in bottom half
vtk_renderer = vtk.vtkRenderer()
vtk_renderer.AddActor(vtk_voxel_grid.vtk_actor)
vtk_renderer.AddActor(vtk_point_cloud.vtk_actor)
vtk_renderer.AddActor(vtk_proposal_boxes.vtk_actor)
vtk_renderer.AddActor(vtk_prediction_boxes.vtk_actor)
vtk_renderer.AddActor(vtk_hard_gt_boxes.vtk_actor)
vtk_renderer.AddActor(vtk_medium_gt_boxes.vtk_actor)
vtk_renderer.AddActor(vtk_easy_gt_boxes.vtk_actor)
vtk_renderer.AddActor(vtk_all_gt_boxes.vtk_actor)
vtk_renderer.AddActor(vtk_text_labels.vtk_actor)
# Add ground plane and slice planes
vtk_renderer.AddActor(vtk_ground_plane.vtk_actor)
vtk_renderer.AddActor(vtk_slice_bot_plane.vtk_actor)
vtk_renderer.AddActor(vtk_slice_top_plane.vtk_actor)
#vtk_renderer.AddActor(vtk_axes)
vtk_renderer.SetBackground(0.2, 0.3, 0.4)
# Set initial properties for some actors
vtk_point_cloud.vtk_actor.GetProperty().SetPointSize(3)
vtk_proposal_boxes.vtk_actor.SetVisibility(0)
vtk_voxel_grid.vtk_actor.SetVisibility(0)
vtk_all_gt_boxes.vtk_actor.SetVisibility(0)
vtk_ground_plane.vtk_actor.SetVisibility(0)
vtk_slice_bot_plane.vtk_actor.SetVisibility(0)
vtk_slice_top_plane.vtk_actor.SetVisibility(0)
vtk_ground_plane.vtk_actor.GetProperty().SetOpacity(0.9)
vtk_slice_bot_plane.vtk_actor.GetProperty().SetOpacity(0.9)
vtk_slice_top_plane.vtk_actor.GetProperty().SetOpacity(0.9)
# Setup Camera
current_cam = vtk_renderer.GetActiveCamera()
current_cam.Pitch(160.0)
current_cam.Roll(180.0)
# Zooms out to fit all points on screen
vtk_renderer.ResetCamera()
# Zoom in slightly
current_cam.Zoom(3.5)
# Reset the clipping range to show all points
vtk_renderer.ResetCameraClippingRange()
# Setup Render Window
vtk_render_window = vtk.vtkRenderWindow()
vtk_render_window.SetWindowName(
"Predictions: Step {}, Sample {}, Min Score {}".format(
global_step,
sample_name,
mlod_score_threshold,
))
vtk_render_window.SetSize(900, 600)
vtk_render_window.AddRenderer(vtk_renderer)
# Setup custom interactor style, which handles mouse and key events
vtk_render_window_interactor = vtk.vtkRenderWindowInteractor()
vtk_render_window_interactor.SetRenderWindow(vtk_render_window)
# Add custom interactor to toggle actor visibilities
custom_interactor = vis_utils.CameraInfoInteractorStyle([
vtk_proposal_boxes.vtk_actor,
vtk_prediction_boxes.vtk_actor,
vtk_voxel_grid.vtk_actor,
vtk_point_cloud.vtk_actor,
vtk_easy_gt_boxes.vtk_actor,
vtk_medium_gt_boxes.vtk_actor,
vtk_hard_gt_boxes.vtk_actor,
vtk_all_gt_boxes.vtk_actor,
vtk_ground_plane.vtk_actor,
vtk_slice_bot_plane.vtk_actor,
vtk_slice_top_plane.vtk_actor,
vtk_text_labels.vtk_actor,
])
vtk_render_window_interactor.SetInteractorStyle(custom_interactor)
# Render in VTK
vtk_render_window.Render()
# Take a screenshot
window_to_image_filter = vtk.vtkWindowToImageFilter()
window_to_image_filter.SetInput(vtk_render_window)
window_to_image_filter.Update()
png_writer = vtk.vtkPNGWriter()
file_name = img_out_dir + "/{}.png".format(sample_name)
png_writer.SetFileName(file_name)
png_writer.SetInputData(window_to_image_filter.GetOutput())
png_writer.Write()
print('Screenshot saved to ', file_name)
vtk_render_window_interactor.Start() # Blocking
def build_jpeg_preview(
self,
file_path: str,
preview_name: str,
cache_path: str,
page_id: int,
extension: str = ".jpg",
size: ImgDims = None,
mimetype: str = "",
) -> None:
if not size:
size = self.default_size
colors = vtkNamedColors()
if not mimetype:
guessed_mimetype, _ = mimetypes_storage.guess_type(file_path,
strict=False)
# INFO - G.M - 2019-11-22 - guessed_mimetype can be None
mimetype = guessed_mimetype or ""
reader = self._get_vtk_reader(mimetype)
reader.SetFileName(file_path)
mapper = vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtkActor()
actor.SetMapper(mapper)
rotation = (-70, 0, 45)
R_x, R_y, R_z = rotation # TODO set a good looking default orientation
actor.RotateX(R_x)
actor.RotateY(R_y)
actor.RotateZ(R_z)
# Create a rendering window and renderer
ren = vtkRenderer()
renWin = vtkRenderWindow()
renWin.OffScreenRenderingOn()
renWin.AddRenderer(ren)
renWin.SetSize(size.width, size.height)
ren.SetBackground(colors.GetColor3d("white"))
# Assign actor to the renderer
ren.AddActor(actor)
renWin.Render()
# Write image
windowto_image_filter = vtkWindowToImageFilter()
windowto_image_filter.SetInput(renWin)
# windowto_image_filter.SetScale(scale) # image scale
windowto_image_filter.SetInputBufferTypeToRGBA()
with tempfile.NamedTemporaryFile("w+b",
prefix="preview-generator-",
suffix=".png") as tmp_png:
writer = vtkPNGWriter()
writer.SetFileName(tmp_png.name)
writer.SetInputConnection(windowto_image_filter.GetOutputPort())
writer.Write()
return ImagePreviewBuilderPillow().build_jpeg_preview(
tmp_png.name, preview_name, cache_path, page_id, extension,
size, mimetype)
def write(objct, fileoutput, binary=True):
"""
Write 3D object to file. (same as `save()`).
Possile extensions are:
- vtk, vti, npy, ply, obj, stl, byu, vtp, vti, mhd, xyz, tif, png, bmp.
"""
obj = objct
if isinstance(obj, Actor): # picks transformation
obj = objct.polydata(True)
elif isinstance(obj, (vtk.vtkActor, vtk.vtkVolume)):
obj = objct.GetMapper().GetInput()
elif isinstance(obj, (vtk.vtkPolyData, vtk.vtkImageData)):
obj = objct
fr = fileoutput.lower()
if ".vtk" in fr:
writer = vtk.vtkPolyDataWriter()
elif ".ply" in fr:
writer = vtk.vtkPLYWriter()
pscal = obj.GetPointData().GetScalars()
if not pscal:
pscal = obj.GetCellData().GetScalars()
if pscal and pscal.GetName():
writer.SetArrayName(pscal.GetName())
#writer.SetColorMode(0)
lut = objct.GetMapper().GetLookupTable()
if lut:
writer.SetLookupTable(lut)
elif ".stl" in fr:
writer = vtk.vtkSTLWriter()
elif ".obj" in fr:
writer = vtk.vtkOBJWriter()
elif ".vtp" in fr:
writer = vtk.vtkXMLPolyDataWriter()
elif ".vtm" in fr:
g = vtk.vtkMultiBlockDataGroupFilter()
for ob in objct:
g.AddInputData(ob)
g.Update()
mb = g.GetOutputDataObject(0)
wri = vtk.vtkXMLMultiBlockDataWriter()
wri.SetInputData(mb)
wri.SetFileName(fileoutput)
wri.Write()
return mb
elif ".xyz" in fr:
writer = vtk.vtkSimplePointsWriter()
elif ".facet" in fr:
writer = vtk.vtkFacetWriter()
elif ".tif" in fr:
writer = vtk.vtkTIFFWriter()
writer.SetFileDimensionality(len(obj.GetDimensions()))
elif ".vti" in fr:
writer = vtk.vtkXMLImageDataWriter()
elif ".mhd" in fr:
writer = vtk.vtkMetaImageWriter()
elif ".nii" in fr:
writer = vtk.vtkNIFTIImageWriter()
elif ".png" in fr:
writer = vtk.vtkPNGWriter()
elif ".jpg" in fr:
writer = vtk.vtkJPEGWriter()
elif ".bmp" in fr:
writer = vtk.vtkBMPWriter()
elif ".npy" in fr:
if utils.isSequence(objct):
objslist = objct
else:
objslist = [objct]
dicts2save = []
for obj in objslist:
dicts2save.append( _np_dump(obj) )
np.save(fileoutput, dicts2save)
return dicts2save
elif ".xml" in fr: # write tetrahedral dolfin xml
vertices = objct.coordinates().astype(str)
faces = np.array(objct.faces()).astype(str)
ncoords = vertices.shape[0]
outF = open(fileoutput, "w")
outF.write('<?xml version="1.0" encoding="UTF-8"?>\n')
outF.write('<dolfin xmlns:dolfin="http://www.fenicsproject.org">\n')
if len(faces[0]) == 4:# write tetrahedral mesh
ntets = faces.shape[0]
outF.write(' <mesh celltype="tetrahedron" dim="3">\n')
outF.write(' <vertices size="' + str(ncoords) + '">\n')
for i in range(ncoords):
x, y, z = vertices[i]
outF.write(' <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'" z="'+z+'"/>\n')
outF.write(' </vertices>\n')
outF.write(' <cells size="' + str(ntets) + '">\n')
for i in range(ntets):
v0, v1, v2, v3 = faces[i]
outF.write(' <tetrahedron index="'+str(i)
+ '" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'" v3="'+v3+'"/>\n')
elif len(faces[0]) == 3:# write triangle mesh
ntri = faces.shape[0]
outF.write(' <mesh celltype="triangle" dim="2">\n')
outF.write(' <vertices size="' + str(ncoords) + '">\n')
for i in range(ncoords):
x, y, dummy_z = vertices[i]
outF.write(' <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'"/>\n')
outF.write(' </vertices>\n')
outF.write(' <cells size="' + str(ntri) + '">\n')
for i in range(ntri):
v0, v1, v2 = faces[i]
outF.write(' <triangle index="'+str(i)+'" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'"/>\n')
outF.write(' </cells>\n')
outF.write(" </mesh>\n")
outF.write("</dolfin>\n")
outF.close()
return objct
else:
colors.printc("~noentry Unknown format", fileoutput, "file not saved.", c="r")
return objct
try:
if hasattr(writer, 'SetFileTypeToBinary'):
if binary:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
writer.SetInputData(obj)
writer.SetFileName(fileoutput)
writer.Write()
colors.printc("~save Saved file: " + fileoutput, c="g")
except Exception as e:
colors.printc("~noentry Error saving: " + fileoutput, "\n", e, c="r")
return objct
def write(objct, fileoutput, binary=True):
"""
Write 3D object to file. (same as `save()`).
Possile extensions are:
- vtk, vti, ply, obj, stl, byu, vtp, vti, mhd, xyz, tif, png, bmp.
"""
obj = objct
if isinstance(obj, Actor): # picks transformation
obj = objct.polydata(True)
elif isinstance(obj, (vtk.vtkActor, vtk.vtkVolume)):
obj = objct.GetMapper().GetInput()
elif isinstance(obj, (vtk.vtkPolyData, vtk.vtkImageData)):
obj = objct
fr = fileoutput.lower()
if ".vtk" in fr:
w = vtk.vtkPolyDataWriter()
elif ".ply" in fr:
w = vtk.vtkPLYWriter()
elif ".stl" in fr:
w = vtk.vtkSTLWriter()
elif ".vtp" in fr:
w = vtk.vtkXMLPolyDataWriter()
elif ".vtm" in fr:
g = vtk.vtkMultiBlockDataGroupFilter()
for ob in objct:
g.AddInputData(ob)
g.Update()
mb = g.GetOutputDataObject(0)
wri = vtk.vtkXMLMultiBlockDataWriter()
wri.SetInputData(mb)
wri.SetFileName(fileoutput)
wri.Write()
return mb
elif ".xyz" in fr:
w = vtk.vtkSimplePointsWriter()
elif ".facet" in fr:
w = vtk.vtkFacetWriter()
elif ".tif" in fr:
w = vtk.vtkTIFFWriter()
w.SetFileDimensionality(len(obj.GetDimensions()))
elif ".vti" in fr:
w = vtk.vtkXMLImageDataWriter()
elif ".mhd" in fr:
w = vtk.vtkMetaImageWriter()
elif ".png" in fr:
w = vtk.vtkPNGWriter()
elif ".jpg" in fr:
w = vtk.vtkJPEGWriter()
elif ".bmp" in fr:
w = vtk.vtkBMPWriter()
elif ".xml" in fr: # write tetrahedral dolfin xml
vertices = obj.coordinates()
faces = obj.cells()
ncoords = vertices.shape[0]
ntets = faces.shape[0]
outF = open(fileoutput, "w")
outF.write('<?xml version="1.0" encoding="UTF-8"?>\n')
outF.write('<dolfin xmlns:dolfin="http://www.fenicsproject.org">\n')
outF.write(' <mesh celltype="tetrahedron" dim="3">\n')
outF.write(' <vertices size="' + str(ncoords) + '">\n')
for i in range(ncoords):
x, y, z = vertices[i]
outF.write(' <vertex index="' + str(i) + '" x="' + str(x) +
'" y="' + str(y) + '" z="' + str(z) + '"/>\n')
outF.write(' </vertices>\n')
outF.write(' <cells size="' + str(ntets) + '">\n')
for i in range(ntets):
v0, v1, v2, v3 = faces[i]
outF.write(' <tetrahedron index="' + str(i) + '" v0="' +
str(v0) + '" v1="' + str(v1) + '" v2="' + str(v2) +
'" v3="' + str(v3) + '"/>\n')
outF.write(' </cells>\n')
outF.write(" </mesh>\n")
outF.write("</dolfin>\n")
outF.close()
return objct
else:
colors.printc("~noentry Unknown format",
fileoutput,
"file not saved.",
c="r")
return objct
try:
if hasattr(w, 'SetFileTypeToBinary'):
if binary:
w.SetFileTypeToBinary()
else:
w.SetFileTypeToASCII()
w.SetInputData(obj)
w.SetFileName(fileoutput)
w.Write()
colors.printc("~save Saved file: " + fileoutput, c="g")
except Exception as e:
colors.printc("~noentry Error saving: " + fileoutput, "\n", e, c="r")
return objct
def compareImageWithSavedImage(src_img, img_fname, threshold=10):
"""Compares a source image (src_img, which is a vtkImageData) with
the saved image file whose name is given in the second argument.
If the image file does not exist the image is generated and
stored. If not the source image is compared to that of the
figure. This function also handles multiple images and finds the
best matching image.
"""
global _NO_IMAGE
if _NO_IMAGE:
return
f_base, f_ext = os.path.splitext(img_fname)
if not os.path.isfile(img_fname):
# generate the image
pngw = vtk.vtkPNGWriter()
pngw.SetFileName(_getTempImagePath(img_fname))
pngw.SetInputConnection(src_img.GetOutputPort())
pngw.Write()
_printCDashImageNotFoundError(img_fname)
msg = "Missing baseline image: " + img_fname + "\nTest image created: " + _getTempImagePath(
img_fname)
sys.tracebacklimit = 0
raise RuntimeError(msg)
pngr = vtk.vtkPNGReader()
pngr.SetFileName(img_fname)
pngr.Update()
idiff = vtk.vtkImageDifference()
idiff.SetInputConnection(src_img.GetOutputPort())
idiff.SetImageConnection(pngr.GetOutputPort())
idiff.Update()
min_err = idiff.GetThresholdedError()
img_err = min_err
err_index = 0
count = 0
if min_err > threshold:
count = 1
test_failed = 1
err_index = -1
while 1: # keep trying images till we get the best match.
new_fname = f_base + "_%d.png" % count
if not os.path.exists(new_fname):
# no other image exists.
break
# since file exists check if it matches.
pngr.SetFileName(new_fname)
pngr.Update()
idiff.Update()
alt_err = idiff.GetThresholdedError()
if alt_err < threshold:
# matched,
err_index = count
test_failed = 0
min_err = alt_err
img_err = alt_err
break
else:
if alt_err < min_err:
# image is a better match.
err_index = count
min_err = alt_err
img_err = alt_err
count = count + 1
# closes while loop.
if test_failed:
_handleFailedImage(idiff, pngr, img_fname)
# Print for CDash.
_printCDashImageError(img_err, err_index, f_base)
msg = "Failed image test: %f\n" % idiff.GetThresholdedError()
sys.tracebacklimit = 0
raise RuntimeError(msg)
# output the image error even if a test passed
_printCDashImageSuccess(img_err, err_index)
def generateSnapshots(fname):
DISTANCE_FACTOR = 1.3
PARAMS = get_parameters()
print(PARAMS.K)
## VTK pipeline ...
colors = vtk.vtkNamedColors()
reader = vtk.vtkPLYReader()
reader.SetFileName(fname)
reader.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
#We compute the bounding box of the model.
diff = []
#GetBounds essentially returns (xmin,xmax,ymin,ymax,zmin,zmax)
limits = list(mapper.GetBounds())
diff.append(limits[1] - limits[0])
diff.append(limits[3] - limits[2])
diff.append(limits[5] - limits[4])
#We define the radius with respect to the bounding box.
radius = DISTANCE_FACTOR * np.max(diff)
#Single, frontal projection.
if PARAMS.mode == 'frontal':
coordinates = ((radius, 0, 0), )
#6-vertex projection.
elif PARAMS.mode == 'cube':
coordinates = [(radius, 0, 0), (-radius, 0, 0), (0, radius, 0),
(0, -radius, 0), (0, 0, radius), (0, 0, -radius)]
#K-level icosahedron projections.
elif PARAMS.mode == 'icoK':
generatePoints = ico.Icosahedron(radius)
coordinates = generatePoints.subdivide(int(PARAMS.K))
else:
exit()
coordinates = list(coordinates)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(colors.GetColor3d('Tan'))
if (PARAMS.lighting == 'off'):
actor.GetProperty().LightingOff()
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
cameras = [vtk.vtkCamera() for elem in coordinates]
f = open('coordinates.txt', 'w')
f.write('\n'.join(map((lambda x: str(x)), coordinates)))
f.close()
print(len(coordinates))
print(cameras)
renWin = vtk.vtkRenderWindow()
#Generate captures.
for i in range(len(coordinates)):
cameras[i].ParallelProjectionOn()
cameras[i].SetParallelScale(radius / 2)
#Set the focal point to the center of the bounding box
cameras[i].SetFocalPoint(limits[0] + (diff[0]) / 2,
limits[2] + (diff[1]) / 2,
limits[4] + (diff[2]) / 2)
cameras[i].SetClippingRange((0.001, 5000))
#Certain coordinates required a specific View-Up vector.
if (coordinates[i][0] == 0 and coordinates[i][2] == 0):
cameras[i].SetViewUp(0.0, 0.0, 1.0)
else:
cameras[i].SetViewUp(0.0, 1.0, 0.0)
cameras[i].SetPosition((coordinates[i]))
renderer.SetActiveCamera(cameras[i])
renWin.OffScreenRenderingOn()
renWin.AddRenderer(renderer)
renWin.SetSize(1920, 1080)
renWin.Render()
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renWin)
w2if.SetInputBufferTypeToRGBA()
w2if.ReadFrontBufferOff()
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetInputConnection(w2if.GetOutputPort())
writer.SetFileName('img' + fname[:-4] + ' %d.png' % i)
writer.Write()
os.system("ffmpeg -f image2 -pattern_type glob -framerate 1 -i 'img" +
fname[:-4] + "*.png' -s 1920x1080 " + fname[:-4] +
".avi") #psnr / [:-4] removes the extension
# Create a renderwindowinteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Assign actor to the renderer
ren.AddActor(actor)
#arrowRen.AddActor(arrowActor)
ren.AddActor(arrowActor)
renWin.SetSize(500, 500)
ren.GetActiveCamera().Zoom(1)
ren.GetActiveCamera().SetFocalDisk(0.5)
renWin.Render()
# try saving the current scene (must launch renWin.Render() first)
writer = vtk.vtkPNGWriter() #define the extension writer
#define a filter
ImFilter = vtk.vtkWindowToImageFilter()
ImFilter.SetInput(renWin)
ImFilter.SetScale(1)
ImFilter.SetInputBufferTypeToRGBA()
#ImFilter.SetInputBufferTypeToRGB() # alternative
#Read the buffer
ImFilter.ReadFrontBufferOff()
ImFilter.Update()
#File name, link and save
writer.SetFileName("essai.png")
writer.SetInputConnection(ImFilter.GetOutputPort())
def main(filename="frame/f.png"):
print(ocl.revision())
myscreen = camvtk.VTKScreen()
myscreen.camera.SetPosition(20, 12, 20)
myscreen.camera.SetFocalPoint(0, 0, 0)
# axis arrows
camvtk.drawArrows(myscreen, center=(2, 2, 2))
# screenshot writer
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(myscreen.renWin)
lwr = vtk.vtkPNGWriter()
lwr.SetInput(w2if.GetOutput())
c = ocl.CylCutter(1) # cutter
c.length = 3
print("cutter length=", c.length)
p1 = ocl.CLPoint(-0.2, -0.2, 0.2) # start of move
p2 = ocl.CLPoint(-0.2, 0.2, 0.0) # end of move
p3 = ocl.CLPoint(0.5, 0.0, -0.5)
clpoints = []
clpoints.append(p1)
clpoints.append(p2)
clpoints.append(p3)
f = ocl.Ocode()
f.set_depth(6) # depth and scale set here.
f.set_scale(1)
# cube
cube1 = ocl.CubeOCTVolume()
cube1.side = 2.123
cube1.center = ocl.Point(0, 0, 0)
cube1.calcBB()
stock = ocl.LinOCT()
stock.init(3)
stock.build(cube1)
# draw initial octree
tlist = pyocl.octree2trilist(stock)
surf = camvtk.STLSurf(triangleList=tlist)
myscreen.addActor(surf)
Nmoves = len(clpoints)
print(Nmoves, "CL-points to process")
for n in range(0, Nmoves - 1):
#if n<Nmoves-1:
print(n, " to ", n + 1)
startp = clpoints[n]
endp = clpoints[n + 1]
sweep = ocl.LinOCT()
sweep.init(3)
g1vol = ocl.CylMoveOCTVolume(c, ocl.Point(startp.x, startp.y,
startp.z),
ocl.Point(endp.x, endp.y, endp.z))
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))
sweep.build(g1vol)
stock.diff(sweep)
myscreen.removeActor(surf)
tlist = pyocl.octree2trilist(stock)
surf = camvtk.STLSurf(triangleList=tlist)
surf.SetColor(camvtk.cyan)
surf.SetOpacity(1.0)
myscreen.addActor(surf)
myscreen.render()
time.sleep(0.2)
#exit()
# draw trees
#print "drawing trees"
#camvtk.drawTree2(myscreen, stock, opacity=1, color=camvtk.cyan)
# box around octree
oct_cube = camvtk.Cube(center=(0, 0, 0),
length=4 * f.get_scale(),
color=camvtk.white)
oct_cube.SetWireframe()
myscreen.addActor(oct_cube)
# OCL text
title = camvtk.Text()
title.SetPos((myscreen.width - 350, myscreen.height - 30))
title.SetText("OpenCAMLib " +
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
myscreen.addActor(title)
print(" render()...", )
myscreen.render()
print("done.")
lwr.SetFileName(filename)
time.sleep(0.2)
#lwr.Write()
myscreen.iren.Start()
