def RenderVTKVolume(image, volprops):
volmap = vtk.vtkVolumeRayCastMapper()
volmap.SetVolumeRayCastFunction(vtk.vtkVolumeRayCastCompositeFunction())
volmap.SetInputConnection(image.GetOutputPort())
vol = vtk.vtkVolume()
vol.SetMapper(volmap)
vol.SetProperty(volprops)
#Standard VTK stuff
ren = vtk.vtkRenderer()
ren.AddVolume(vol)
ren.SetBackground((1, 1, 1))
renwin = vtk.vtkRenderWindow()
renwin.AddRenderer(ren)
istyle = vtk.vtkInteractorStyleSwitch()
istyle.SetCurrentStyleToTrackballCamera()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renwin)
iren.SetInteractorStyle(istyle)
renwin.Render()
iren.Start()
def testStyleJoystickActor(self):
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
testStyleBaseSpike = TestStyleBaseSpike.StyleBaseSpike(
ren, renWin, iRen)
# Set interactor style
inStyle = vtk.vtkInteractorStyleSwitch()
iRen.SetInteractorStyle(inStyle)
# Switch to Joystick+Actor mode
iRen.SetKeyEventInformation(0, 0, 'j', 0)
iRen.InvokeEvent("CharEvent")
iRen.SetKeyEventInformation(0, 0, 'a', 0)
iRen.InvokeEvent("CharEvent")
# Test style
testStyleBase = TestStyleBase.TestStyleBase(ren)
testStyleBase.test_style(inStyle.GetCurrentStyle())
# render and interact with data
img_file = "TestStyleJoystickActor.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
def __init__(self, gfx, frame):
self.renderer = vtk.vtkOpenGLRenderer()
self.renwin = vtk.vtkXOpenGLRenderWindow()
self.renwin.AddRenderer(self.renderer)
self.renwin.SetStereoTypeToAnaglyph()
self.iren = vtkTkRenderWindowInteractor(frame,
rw=self.renwin,
width=500,
height=500)
self.istyle = vtk.vtkInteractorStyleSwitch()
self.iren.SetInteractorStyle(self.istyle)
self.istyle.SetCurrentStyleToTrackballCamera()
self.iren.Initialize()
self.iren.pack(side='bottom', fill='both', expand=0)
self.iren.Start()
self.camera = vtk.vtkCamera()
self.camera.SetFocalPoint(0, 0, 0)
self.camera.SetPosition(0, 0, 250)
self.camera.SetViewUp(0, 0, 0)
self.camera.SetEyeAngle(5.0)
self.tm = None
self.renderer.SetActiveCamera(self.camera)
self.renwin.Render()
self.currentmod = None
self.nbstep = None
self.oldon = None
self.tloop = None
self.tloopobs = None
self.gfx = gfx
def testStyleJoystickActor(self):
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
testStyleBaseSpike = TestStyleBaseSpike.StyleBaseSpike(ren, renWin, iRen)
# Set interactor style
inStyle = vtk.vtkInteractorStyleSwitch()
iRen.SetInteractorStyle(inStyle)
# Switch to Joystick+Actor mode
iRen.SetKeyEventInformation(0, 0, "j", 0)
iRen.InvokeEvent("CharEvent")
iRen.SetKeyEventInformation(0, 0, "a", 0)
iRen.InvokeEvent("CharEvent")
# Test style
testStyleBase = TestStyleBase.TestStyleBase(ren)
testStyleBase.test_style(inStyle.GetCurrentStyle())
# render and interact with data
img_file = "TestStyleJoystickActor.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def __set_up_renderer(self, volume, mask_volume):
self.img_ren = vtk.vtkRenderer()
self.img_ren.AddActor(self.actor)
self.img_ren.AddActor(self.mask_actor)
self.img_ren.ResetCamera()
self.img_ren.SetViewport([0.0, 0.0, 1.0, 0.5
]) # slicer renderer position - bottom half
self.vol_ren = vtk.vtkRenderer()
self.vol_ren.AddVolume(volume)
self.vol_ren.AddVolume(mask_volume)
self.vol_ren.ResetCamera()
self.vol_ren.SetViewport(0.0, 0.5, 1.0,
1.0) # volume renderer position
self.vol_ren.SetBackground(0.0, 0.01, 0.05)
self.win = vtk.vtkRenderWindow()
self.win.SetSize(400, 800)
self.win.AddRenderer(self.img_ren)
self.win.AddRenderer(self.vol_ren)
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetRenderWindow(self.win)
# set styles for interactor
self.image_style = vtk.vtkInteractorStyleImage()
self.image_style.AddObserver("RightButtonReleaseEvent",
self.switch_axis_call_back)
self.image_style.SetDefaultRenderer(self.img_ren)
self.volume_style = vtk.vtkInteractorStyleSwitch()
self.volume_style.SetDefaultRenderer(self.vol_ren)
self.iren.AddObserver("MouseMoveEvent", self.switch_interactor_style)
def setenv(self, root):
self.renderer = vtk.vtkOpenGLRenderer()
#self.renderer.SetBackground(1,1,1)
self.renwin = vtk.vtkXOpenGLRenderWindow()
self.renwin.AddRenderer(self.renderer)
#self.renwin.SetStereoTypeToRedBlue()
#self.renwin.StereoCapableWindowOn()
#self.renwin.SetStereoTypeToCrystalEyes()
#self.renwin.StereoRenderOn() #activer la stereoscopie
self.renwin.SetStereoTypeToAnaglyph()
#self.renwin.SetAnaglyphColorMask(4,2) #gauche,droite | r=4, v=2 ,b=1
self.iren = vtkTkRenderWindowInteractor(root,
rw=self.renwin,
width=1000,
height=800)
self.istyle = vtk.vtkInteractorStyleSwitch()
self.iren.SetInteractorStyle(self.istyle)
self.istyle.SetCurrentStyleToTrackballCamera()
self.iren.Initialize()
self.iren.pack(side='top', fill='both', expand=1)
self.addobservers()
self.setcam()
self.setaxes()
#self.make_fog() #charger le fog par defaut ? /!\ modifier la variable has_fog
self.iren.Start()
self.display_ascii_logo()
def RenderVTKVolume(image, volprops):
volmap = vtk.vtkVolumeRayCastMapper()
volmap.SetVolumeRayCastFunction(vtk.vtkVolumeRayCastCompositeFunction())
volmap.SetInputConnection(image.GetOutputPort())
vol = vtk.vtkVolume()
vol.SetMapper(volmap)
vol.SetProperty(volprops)
#Standard VTK stuff
ren = vtk.vtkRenderer()
ren.AddVolume(vol)
ren.SetBackground((1, 1, 1))
renwin = vtk.vtkRenderWindow()
renwin.AddRenderer(ren)
istyle = vtk.vtkInteractorStyleSwitch()
istyle.SetCurrentStyleToTrackballCamera()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renwin)
iren.SetInteractorStyle(istyle)
renwin.Render()
iren.Start()
def __init__(self, parent):
QVTKRenderWindowInteractor.__init__(self, parent)
self.renderer = vtk.vtkRenderer()
self.GetRenderWindow().AddRenderer(self.renderer)
interactor = vtk.vtkInteractorStyleSwitch()
self._Iren.SetInteractorStyle(interactor)
self.surface = None
# Remainng calls set up axes.
tprop = vtk.vtkTextProperty()
tprop.SetColor(1,1,1)
# Create a faint outline to go with the axes.
self.outline = vtk.vtkOutlineFilter()
# Initially set up with a box as input. This will be changed
# to a plot once the user clicks something.
self.box = vtk.vtkBox()
self.box.SetBounds(0,10,0,10,0,10)
sample = vtk.vtkSampleFunction()
sample.SetImplicitFunction(self.box)
sample.SetSampleDimensions(2,2,2)
sample.SetModelBounds(0,10,0,10,0,5)
sample.ComputeNormalsOff()
self.outline.SetInputConnection(sample.GetOutputPort())
mapOutline = vtk.vtkPolyDataMapper()
mapOutline.SetInputConnection(self.outline.GetOutputPort())
self.outlineActor = vtk.vtkActor()
self.outlineActor.SetMapper(mapOutline)
self.outlineActor.GetProperty().SetColor(1,1,1)
self.outlineActor.GetProperty().SetOpacity(.25)
self.renderer.AddActor(self.outlineActor)
self.axes = vtk.vtkCubeAxesActor2D()
self.axes.SetCamera(self.renderer.GetActiveCamera())
self.axes.SetFlyModeToOuterEdges()
self.axes.SetLabelFormat("%6.4g")
self.axes.SetFontFactor(0.8)
self.axes.SetAxisTitleTextProperty(tprop)
self.axes.SetAxisLabelTextProperty(tprop)
self.axes.SetXLabel("MPI Rank")
self.axes.SetYLabel("Progress")
self.axes.SetZLabel("Effort")
self.axes.SetInput(sample.GetOutput())
self.renderer.AddViewProp(self.axes)
# Keep original camera around in case it gets changed
self.originalCamera = self.renderer.GetActiveCamera()
self.renderer.GetActiveCamera().Pitch(90) # Want effort to be vertical
self.renderer.GetActiveCamera().OrthogonalizeViewUp()
self.renderer.ResetCamera()
self.renderer.GetActiveCamera().Elevation(15) # Be slightly above the data
def showImage(inputFileName):
imgData = None
dataType = None
renderer = vtk.vtkRenderer()
if type(inputFileName) == str:
fileName, fileExtension = os.path.splitext(inputFileName)
fileExtension = fileExtension.lower()
if fileExtension in ['.mha', '.mhd']:
reader = vtk.vtkMetaImageReader()
reader.SetFileName(inputFileName)
reader.Update()
elif fileExtension in ['.png']:
reader = vtk.vtkPNGReader()
reader.SetFileName(inputFileName)
reader.Update()
else:
raise Exception("Unknown extension - update this program")
imgData = reader.GetOutput()
dataType = vtk.vtkImageData
elif type(inputFileName) == vtk.vtkImageData:
imgData = inputFileName
dataType = vtk.vtkImageData
elif type(inputFileName) == vtk.vtkPolyData:
imgData = inputFileName
dataType = vtk.vtkPolyData
if dataType == vtk.vtkImageData:
low, high = imgData.GetPointData().GetScalars().GetRange()
print("low: %f, high: %f" % (low, high))
print(imgData.GetDimensions())
image = vtk.vtkImageActor()
image.GetMapper().SetInputData(imgData)
image.GetProperty().SetColorWindow(high - low)
image.GetProperty().SetColorLevel(0.5 * (low + high))
renderer.AddActor(image)
style = vtk.vtkInteractorStyleImage()
else:
style = vtk.vtkInteractorStyleSwitch()
surfActor = vtk.vtkActor()
surfMapper = vtk.vtkPolyDataMapper()
surfMapper.SetInputData(imgData)
surfActor.SetMapper(surfMapper)
renderer.AddActor(surfActor)
window = vtk.vtkRenderWindow()
window.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(window)
interactor.SetInteractorStyle(style)
#print(image.GetMapper().GetInput())
interactor.Start()
def initRen(title):
renId = 1
renWin = [None]*2
renWin[0] = title
renWin[1] = vtk.vtkRenderWindow()
renWin[1].SetWindowName(title)
ren = [None]*2
ren[0] = "%s_ren%d" % (renWin[0], renId)
ren[1] = vtk.vtkRenderer()
renWin[1].AddRenderer(ren[1])
ren[1].SetBackground(0,0,0)
# add generic interactors
try:
delattr(vis, "genericInteractor_"+ren[0])
delattr(vis, "genericInteractorStyle_"+ren[0])
except:
pass
genericInteractor = [None]*2
genericInteractorStyle = [None]*2
genericInteractor[0] = "iren_"+ren[0]
genericInteractorStyle[0] = "irenStyle_"+ren[0]
genericInteractor[1] = vtk.vtkRenderWindowInteractor()
genericInteractorStyle[1] = vtk.vtkInteractorStyleSwitch()
genericInteractorStyle[1].SetCurrentStyleToTrackballCamera()
genericInteractor[1].SetInteractorStyle(genericInteractorStyle[1])
genericInteractor[1].SetRenderWindow(renWin[1])
setattr(vis, ren[0],ren)
setattr(vis, renWin[0],renWin)
setattr(vis, genericInteractor[0], genericInteractor)
setattr(vis, genericInteractorStyle[0], genericInteractorStyle)
return ren, renWin
#proc ::vis::deletePickedActor {ren} {
#
# #@author Nathan Wilson
# #@c Deletes the currently selected actor from the renderer
# #@a ren: renderer
#
# ::vis::tkDeselectPickedActor
# ::vis::actorRm $::vis::tkvars(PickedAssemblyRenderer) $::vis::tkvars(PickedAssembly)
#
#}
def __renderVolumn(self, shift, viewer_range):
self.iren.SetInteractorStyle(vtk.vtkInteractorStyleSwitch())
ren = vtk.vtkRenderer()
ren.SetViewport(viewer_range)
self.renWin.AddRenderer(ren)
self.iren.SetRenderWindow(self.renWin)
# # Create transfer mapping scalar value to opacity
# opacityTransferFunction = vtk.vtkPiecewiseFunction()
# opacityTransferFunction.AddPoint(20, 0.0)
# opacityTransferFunction.AddPoint(255, 0.2)
#
# # Create transfer mapping scalar value to color
# colorTransferFunction = vtk.vtkColorTransferFunction()
# colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0)
# colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.0, 0.0)
# colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0)
# colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0)
# colorTransferFunction.AddRGBPoint(255.0, 0.0, 0.2, 0.0)
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(0, 0.0)
opacityTransferFunction.AddPoint(50, 0.05)
opacityTransferFunction.AddPoint(100, 0.1)
opacityTransferFunction.AddPoint(150, 0.2)
# This class stores color data and can create color tables from a few color points. For this demo, we want the three cubes
# to be of the colors red green and blue.
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(50, 1.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(100, 0.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(150, 0.0, 0.0, 1.0)
# The property describes how the data will look
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
# The mapper / ray cast function know how to render the data
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(shift.GetOutputPort())
# The volume holds the mapper and the property and
# can be used to position/orient the volume
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
ren.AddVolume(volume)
self.renWin.Render()
def initRen(title):
renId = 1
renWin = [None] * 2
renWin[0] = title
renWin[1] = vtk.vtkRenderWindow()
renWin[1].SetWindowName(title)
ren = [None] * 2
ren[0] = "%s_ren%d" % (renWin[0], renId)
ren[1] = vtk.vtkRenderer()
renWin[1].AddRenderer(ren[1])
ren[1].SetBackground(0, 0, 0)
# add generic interactors
try:
delattr(vis, "genericInteractor_" + ren[0])
delattr(vis, "genericInteractorStyle_" + ren[0])
except:
pass
genericInteractor = [None] * 2
genericInteractorStyle = [None] * 2
genericInteractor[0] = "iren_" + ren[0]
genericInteractorStyle[0] = "irenStyle_" + ren[0]
genericInteractor[1] = vtk.vtkRenderWindowInteractor()
genericInteractorStyle[1] = vtk.vtkInteractorStyleSwitch()
genericInteractorStyle[1].SetCurrentStyleToTrackballCamera()
genericInteractor[1].SetInteractorStyle(genericInteractorStyle[1])
genericInteractor[1].SetRenderWindow(renWin[1])
setattr(vis, ren[0], ren)
setattr(vis, renWin[0], renWin)
setattr(vis, genericInteractor[0], genericInteractor)
setattr(vis, genericInteractorStyle[0], genericInteractorStyle)
return ren, renWin
#proc ::vis::deletePickedActor {ren} {
#
# #@author Nathan Wilson
# #@c Deletes the currently selected actor from the renderer
# #@a ren: renderer
#
# ::vis::tkDeselectPickedActor
# ::vis::actorRm $::vis::tkvars(PickedAssemblyRenderer) $::vis::tkvars(PickedAssembly)
#
#}
def __init__(self, obj):
self.vtkObj = volScalarFieldSource(obj)
self.getVTKWindows()
self.internalMesh = vtk.vtkObject(self.vtkObj.internalMesh().__hex__())
self.getVTKActor(self.internalMesh)
self.mapper.SetScalarModeToUseCellData()
self.istyle = vtk.vtkInteractorStyleSwitch()
self.istyle.SetCurrentStyleToTrackballCamera()
self.iren.SetInteractorStyle(self.istyle)
self.update()
self.iren.Start()
def vis_with_renderer(renderer):
# Renderer
# renderer.SetBackground(.2, .3, .4)
renderer.SetBackground(1, 1, 1)
renderer.ResetCamera()
transform = vtk.vtkTransform()
transform.Translate(1.0, 0.0, 0.0)
axes = vtk.vtkAxesActor()
renderer.AddActor(axes)
# Render Window
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
# Interactor
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
def get_camera_info(obj, ev):
if renderWindowInteractor.GetKeyCode() == "s":
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renderWindow)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName("screenshot.png")
if vtk.VTK_MAJOR_VERSION == 5:
writer.SetInput(w2if.GetOutput())
else:
writer.SetInputData(w2if.GetOutput())
writer.Write()
print("screenshot saved")
style = vtk.vtkInteractorStyleSwitch()
renderWindowInteractor.SetInteractorStyle(style)
# style.SetCurrentStyleToTrackballActor()
style.SetCurrentStyleToTrackballCamera()
# Begin Interaction
renderWindowInteractor.AddObserver(vtk.vtkCommand.KeyPressEvent,
get_camera_info, 1)
renderWindow.Render()
renderWindowInteractor.Start()
def open(self):
# window
ren = vtk.vtkRenderer()
ren.SetBackground(0.1, 0.2, 0.4)
win = vtk.vtkRenderWindow()
win.SetSize(640, 480)
win.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
sw = vtk.vtkInteractorStyleSwitch()
sw.SetCurrentStyleToTrackballCamera()
iren.SetInteractorStyle(sw)
iren.SetRenderWindow(win)
for a in self.actors:
ren.AddActor(a)
ax_actor = vtk.vtkAxesActor()
ax_actor.SetShaftTypeToCylinder()
ax_actor.SetXAxisLabelText("x")
ax_actor.SetYAxisLabelText("y")
ax_actor.SetZAxisLabelText("z")
ax_actor.AxisLabelsOn()
ax_actor.SetTotalLength(1.5, 1.5, 1.5)
ax_widget = vtk.vtkOrientationMarkerWidget()
ax_widget.SetOrientationMarker(ax_actor)
ax_widget.SetViewport(0.0, 0.0, 0.15, 0.3)
ax_widget.SetInteractor(iren)
ax_widget.SetEnabled(1)
ax_widget.InteractiveOff()
ren.ResetCamera()
cam1 = ren.GetActiveCamera()
cam1.Elevation(-90)
cam1.SetViewUp(0, 0, 1)
cam1.Azimuth(45)
ren.ResetCameraClippingRange()
iren.Initialize()
win.Render()
iren.Start()
def __init__(self,frame): self.renderer = vtk.vtkOpenGLRenderer() self.renwin = vtk.vtkXOpenGLRenderWindow() self.renwin.AddRenderer(self.renderer) self.renwin.SetStereoTypeToAnaglyph() #self.renwin.SetAnaglyphColorMask(4,2) self.iren = vtkTkRenderWindowInteractor(frame,rw=self.renwin, width=300, height=300 ) self.istyle = vtk.vtkInteractorStyleSwitch() self.iren.SetInteractorStyle(self.istyle) self.istyle.SetCurrentStyleToTrackballCamera() self.iren.Initialize() self.iren.pack(side='bottom', fill='none', expand=0) self.iren.Start() self.camera=vtk.vtkCamera() self.camera.SetFocalPoint(0, 0, 0) self.camera.SetPosition(0, 0, 250) self.camera.SetViewUp(0, 0, 0) self.camera.SetEyeAngle(5.0) self.renderer.SetActiveCamera(self.camera) self.renwin.Render()
def setenv(self,root): self.renderer = vtk.vtkOpenGLRenderer() #self.renderer.SetBackground(1,1,1) self.renwin = vtk.vtkXOpenGLRenderWindow() self.renwin.AddRenderer(self.renderer) #self.renwin.SetStereoTypeToRedBlue() #self.renwin.StereoCapableWindowOn() #self.renwin.SetStereoTypeToCrystalEyes() #self.renwin.StereoRenderOn() #activer la stereoscopie self.renwin.SetStereoTypeToAnaglyph() #self.renwin.SetAnaglyphColorMask(4,2) #gauche,droite | r=4, v=2 ,b=1 self.iren = vtkTkRenderWindowInteractor(root,rw=self.renwin, width=1000, height=800) self.istyle = vtk.vtkInteractorStyleSwitch() self.iren.SetInteractorStyle(self.istyle) self.istyle.SetCurrentStyleToTrackballCamera() self.iren.Initialize() self.iren.pack(side='top', fill='both', expand=1) self.addobservers() self.setcam() self.setaxes() #self.make_fog() #charger le fog par defaut ? /!\ modifier la variable has_fog self.iren.Start() self.display_ascii_logo()
def cutterWidget(obj,
outputname='clipped.vtk',
c=(0.2, 0.2, 1),
alpha=1,
bc=(0.7, 0.8, 1),
legend=None):
'''Pop up a box widget to cut parts of actor. Return largest part.'''
apd = polydata(obj)
planes = vtk.vtkPlanes()
planes.SetBounds(apd.GetBounds())
clipper = vtk.vtkClipPolyData()
setInput(clipper, apd)
clipper.SetClipFunction(planes)
clipper.InsideOutOn()
clipper.GenerateClippedOutputOn()
# check if color string contains a float, in this case ignore alpha
al = colors.getAlpha(c)
if al: alpha = al
act0Mapper = vtk.vtkPolyDataMapper() # the part which stays
act0Mapper.SetInputConnection(clipper.GetOutputPort())
act0 = vtk.vtkActor()
act0.SetMapper(act0Mapper)
act0.GetProperty().SetColor(colors.getColor(c))
act0.GetProperty().SetOpacity(alpha)
backProp = vtk.vtkProperty()
backProp.SetDiffuseColor(colors.getColor(bc))
backProp.SetOpacity(alpha)
act0.SetBackfaceProperty(backProp)
act0.GetProperty().SetInterpolationToFlat()
assignPhysicsMethods(act0)
assignConvenienceMethods(act0, legend)
act1Mapper = vtk.vtkPolyDataMapper() # the part which is cut away
act1Mapper.SetInputConnection(clipper.GetClippedOutputPort())
act1 = vtk.vtkActor()
act1.SetMapper(act1Mapper)
act1.GetProperty().SetColor(colors.getColor(c))
act1.GetProperty().SetOpacity(alpha / 10.)
act1.GetProperty().SetRepresentationToWireframe()
act1.VisibilityOn()
ren = vtk.vtkRenderer()
ren.SetBackground(1, 1, 1)
ren.AddActor(act0)
ren.AddActor(act1)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(600, 700)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
istyl = vtk.vtkInteractorStyleSwitch()
istyl.SetCurrentStyleToTrackballCamera()
iren.SetInteractorStyle(istyl)
def SelectPolygons(vobj, event):
vobj.GetPlanes(planes)
boxWidget = vtk.vtkBoxWidget()
boxWidget.OutlineCursorWiresOn()
boxWidget.GetSelectedOutlineProperty().SetColor(1, 0, 1)
boxWidget.GetOutlineProperty().SetColor(0.1, 0.1, 0.1)
boxWidget.GetOutlineProperty().SetOpacity(0.8)
boxWidget.SetPlaceFactor(1.05)
boxWidget.SetInteractor(iren)
setInput(boxWidget, apd)
boxWidget.PlaceWidget()
boxWidget.AddObserver("InteractionEvent", SelectPolygons)
boxWidget.On()
colors.printc('\nCutterWidget:\n Move handles to cut parts of the actor',
'm')
colors.printc(' Press q to continue, Escape to exit', 'm')
colors.printc((" Press X to save file to", outputname), 'm')
def cwkeypress(obj, event):
key = obj.GetKeySym()
if key == "q" or key == "space" or key == "Return":
iren.ExitCallback()
elif key == "X":
confilter = vtk.vtkPolyDataConnectivityFilter()
setInput(confilter, clipper.GetOutput())
confilter.SetExtractionModeToLargestRegion()
confilter.Update()
cpd = vtk.vtkCleanPolyData()
setInput(cpd, confilter.GetOutput())
cpd.Update()
w = vtk.vtkPolyDataWriter()
setInput(w, cpd.GetOutput())
w.SetFileName(outputname)
w.Write()
colors.printc("Saved file: " + outputname, 'g')
elif key == "Escape":
exit(0)
iren.Initialize()
iren.AddObserver("KeyPressEvent", cwkeypress)
iren.Start()
boxWidget.Off()
return act0
def main():
cubeSource = vtk.vtkCubeSource()
cubeSource.SetCenter(0, 0, 0)
cubeSource.SetXLength(2.5)
cubeSource.SetYLength(3.5)
cubeSource.SetZLength(4.5)
# Create a mapper and actor
mapper_1 = vtk.vtkPolyDataMapper()
mapper_1.SetInputConnection(cubeSource.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper_1)
actor.GetProperty().SetColor(255, 0, 0)
cubeSource_2 = vtk.vtkCubeSource()
cubeSource_2.SetCenter(0, 10, 0)
cubeSource_2.SetXLength(2.5)
cubeSource_2.SetYLength(3.5)
cubeSource_2.SetZLength(4.5)
mapper_2 = vtk.vtkPolyDataMapper()
mapper_2.SetInputConnection(cubeSource_2.GetOutputPort())
actor_2 = vtk.vtkActor()
actor_2.SetMapper(mapper_2)
actor_2.GetProperty().SetColor(0, 255, 0)
cubeSource_3 = vtk.vtkCubeSource()
cubeSource_3.SetCenter(10, 0, 0)
cubeSource_3.SetXLength(2.5)
cubeSource_3.SetYLength(3.5)
cubeSource_3.SetZLength(4.5)
mapper_3 = vtk.vtkPolyDataMapper()
mapper_3.SetInputConnection(cubeSource_3.GetOutputPort())
actor_3 = vtk.vtkActor()
actor_3.SetMapper(mapper_3)
actor_3.GetProperty().SetColor(0, 0, 255)
cubeSource_4 = vtk.vtkCubeSource()
cubeSource_4.SetCenter(10, 10, 0)
cubeSource_4.SetXLength(2.5)
cubeSource_4.SetYLength(3.5)
cubeSource_4.SetZLength(4.5)
mapper_4 = vtk.vtkPolyDataMapper()
mapper_4.SetInputConnection(cubeSource_4.GetOutputPort())
actor_4 = vtk.vtkActor()
actor_4.SetMapper(mapper_4)
actor_4.GetProperty().SetColor(255, 255, 0)
# Add lights
light = vtk.vtkLight()
light.SetLightTypeToSceneLight()
light.SetColor(255, 255, 255)
light_2 = vtk.vtkLight()
light.SetLightTypeToSceneLight()
light.SetColor(0, 0, 255)
light_3 = vtk.vtkLight()
light.SetLightTypeToSceneLight()
light.SetColor(255, 0, 0)
#Visualize
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.AddActor(actor_2)
renderer.AddActor(actor_3)
renderer.AddActor(actor_4)
renderer.AddLight(light)
renderer.AddLight(light_2)
renderer.AddLight(light_3)
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
istyle = vtk.vtkInteractorStyleSwitch()
interactor.SetInteractorStyle(istyle)
istyle.SetCurrentStyleToTrackballCamera()
interactor.Initialize()
interactor.Start()
def __init__(self, parent=None, wflags=QtCore.Qt.WindowFlags(), **kw):
# the current button
self._ActiveButton = QtCore.Qt.NoButton
# private attributes
self.__oldFocus = None
self.__saveX = 0
self.__saveY = 0
self.__saveModifiers = QtCore.Qt.NoModifier
self.__saveButtons = QtCore.Qt.NoButton
# do special handling of some keywords:
# stereo, rw
stereo = 0
if kw.has_key('stereo'):
if kw['stereo']:
stereo = 1
rw = None
if kw.has_key('rw'):
rw = kw['rw']
# create qt-level widget
QtGui.QWidget.__init__(self, parent, wflags|QtCore.Qt.MSWindowsOwnDC)
#QtOpenGL.QGLWidget.__init__(self, parent)
if rw: # user-supplied render window
# print MODULENAME, ' predefd rw'
self._RenderWindow = rw
else:
# print MODULENAME, ' NOT predefd rw'
self._RenderWindow = vtk.vtkRenderWindow()
# print MODULENAME,' winSize = ',self._RenderWindow.GetSize()
# ---- QVTKRenderWindowInteractor_mac.py: NOT predefd rw
# ---- QVTKRenderWindowInteractor_mac.py: winSize = (0, 0)
self._RenderWindow.SetWindowInfo(str(int(self.winId())))
if stereo: # stereo mode
self._RenderWindow.StereoCapableWindowOn()
self._RenderWindow.SetStereoTypeToCrystalEyes()
self._Iren = vtk.vtkGenericRenderWindowInteractor()
self._Iren.SetRenderWindow(self._RenderWindow)
self._Iren.SetRenderWindow(self._RenderWindow)
# self.interactorStyle=vtk.vtkInteractorStyleJoystickCamera()
self.interactorStyle=vtk.vtkInteractorStyleSwitch()
# self.interactorStyle.SetCurrentStyleToTrackballActor()
self.interactorStyle.SetCurrentStyleToTrackballCamera()
self._Iren.SetInteractorStyle(self.interactorStyle)
# do all the necessary qt setup
self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent)
self.setAttribute(QtCore.Qt.WA_PaintOnScreen)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.setMouseTracking(True) # get all mouse events
self.setFocusPolicy(QtCore.Qt.WheelFocus)
self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding))
self._Timer = QtCore.QTimer(self)
self.connect(self._Timer, QtCore.SIGNAL('timeout()'), self.TimerEvent)
self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer)
self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer)
self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent',
self.CursorChangedEvent)
self.mousePressEventFcn=self.mousePressEvent2DStyle
def __init__(self, parent=None, **kw):
# the current button
self._ActiveButton = Qt.NoButton
# private attributes
self.__saveX = 0
self.__saveY = 0
self.__saveModifiers = Qt.NoModifier
self.__saveButtons = Qt.NoButton
self.__wheelDelta = 0
# do special handling of some keywords:
# stereo, rw
try:
stereo = bool(kw['stereo'])
except KeyError:
stereo = False
try:
rw = kw['rw']
except KeyError:
rw = None
# create base qt-level widget
if QVTKRWIBase == "QWidget":
if "wflags" in kw:
wflags = kw['wflags']
else:
wflags = Qt.WindowFlags()
QWidget.__init__(self, parent, wflags | Qt.MSWindowsOwnDC)
elif QVTKRWIBase == "QGLWidget":
QGLWidget.__init__(self, parent)
if rw: # user-supplied render window
self._RenderWindow = rw
else:
self._RenderWindow = vtk.vtkRenderWindow()
WId = self.winId()
# Python2
if type(WId).__name__ == 'PyCObject':
from ctypes import pythonapi, c_void_p, py_object
pythonapi.PyCObject_AsVoidPtr.restype = c_void_p
pythonapi.PyCObject_AsVoidPtr.argtypes = [py_object]
WId = pythonapi.PyCObject_AsVoidPtr(WId)
# Python3
elif type(WId).__name__ == 'PyCapsule':
from ctypes import pythonapi, c_void_p, py_object, c_char_p
pythonapi.PyCapsule_GetName.restype = c_char_p
pythonapi.PyCapsule_GetName.argtypes = [py_object]
name = pythonapi.PyCapsule_GetName(WId)
pythonapi.PyCapsule_GetPointer.restype = c_void_p
pythonapi.PyCapsule_GetPointer.argtypes = [py_object, c_char_p]
WId = pythonapi.PyCapsule_GetPointer(WId, name)
self._RenderWindow.SetWindowInfo(str(int(WId)))
#
# if stereo: # stereo mode
# self._RenderWindow.StereoCapableWindowOn()
# self._RenderWindow.SetStereoTypeToCrystalEyes()
try:
self._Iren = kw['iren']
except KeyError:
self._Iren = vtk.vtkGenericRenderWindowInteractor()
self._Iren.SetRenderWindow(self._RenderWindow)
# this is needed to get nice'n'smooth mouse interaction
self.interactorStyle = vtk.vtkInteractorStyleSwitch()
# self.interactorStyle.SetCurrentStyleToTrackballActor()
self.interactorStyle.SetCurrentStyleToTrackballCamera()
self._Iren.SetInteractorStyle(self.interactorStyle)
# do all the necessary qt setup
self.setAttribute(Qt.WA_OpaquePaintEvent)
self.setAttribute(Qt.WA_PaintOnScreen)
self.setMouseTracking(True) # get all mouse events
self.setFocusPolicy(Qt.WheelFocus)
self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
self._Timer = QTimer(self)
self._Timer.timeout.connect(self.TimerEvent)
self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer)
self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer)
self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent',
self.CursorChangedEvent)
#Create a hidden child widget and connect its destroyed signal to its
#parent ``Finalize`` slot. The hidden children will be destroyed before
#its parent thus allowing cleanup of VTK elements.
self._hidden = QWidget(self)
self._hidden.hide()
self._hidden.destroyed.connect(self.Finalize)
self.mousePressEventFcn = self.mousePressEvent2DStyle
def __init__(self):
# Create the RenderWindow, Renderer and both Actors
self.renderer = vtk.vtkRenderer()
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(self.renderer)
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetRenderWindow(self.renWin)
self.iren.SetInteractorStyle(vtk.vtkInteractorStyleSwitch())
self.iren.GetInteractorStyle().SetCurrentStyleToTrackballCamera()
# Start by loading some data.
input_fname = sys.argv[1]
if len(sys.argv) > 2: # selector have been provided
self.selector = sys.argv[2]
self.data = np.load(input_fname, mmap_mode='r')
assert self.select_slice()
else: # selector have NOT been provided
self.selector = False
self.data = np.load(input_fname)
if not (
self.data.ndim == 2
): # If dim not compatible with elevation, ask for a selector
print('Incompatible data dimentionality : ', self.data.shape)
self.selector = raw_input(
'Enter selector to cast input as 2D array (e.g. [42,:,:]) -> '
)
assert self.select_slice()
convertor = npy_converter()
self.image = convertor.convert(self.data)
self.mi, self.ma = self.image.GetScalarRange()
self.warp_factor = 0.
self.warp_step = 0.001
geometry = vtk.vtkImageDataGeometryFilter()
if vtk.vtkVersion.GetVTKMajorVersion() < 6:
geometry.SetInput(self.image)
else:
geometry.SetInputData(self.image)
self.warp = vtk.vtkWarpScalar()
self.warp.SetInputConnection(geometry.GetOutputPort())
self.warp.SetScaleFactor(1)
self.warp.UseNormalOn()
self.warp.SetNormal(1, 0, 0)
self.warp.Update()
lut = vtk.vtkLookupTable()
lut.SetTableRange(self.image.GetScalarRange())
lut.SetNumberOfColors(256)
lut.SetHueRange(0.7, 0)
lut.Build()
merge = vtk.vtkMergeFilter()
if vtk.vtkVersion.GetVTKMajorVersion() < 6:
merge.SetGeometry(self.warp.GetOutput())
merge.SetScalars(self.image)
else:
merge.SetGeometryInputData(self.warp.GetOutput())
merge.SetScalarsData(self.image)
merge.Update()
self.outline = vtk.vtkOutlineFilter()
self.outline.SetInputConnection(merge.GetOutputPort())
self.outline.Update()
outlineMapper = vtk.vtkPolyDataMapper()
if vtk.vtkVersion.GetVTKMajorVersion() < 6:
outlineMapper.SetInputConnection(self.outline.GetOutputPort())
else:
outlineMapper.SetInputData(self.outline.GetOutputDataObject(0))
box = vtk.vtkActor()
box.SetMapper(outlineMapper)
box.GetProperty().SetColor(0, 0, 0)
self.renderer.AddActor(box)
mapper = vtk.vtkPolyDataMapper()
mapper.SetLookupTable(lut)
mapper.SetScalarRange(self.image.GetScalarRange())
mapper.SetInputConnection(merge.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().ShadingOff()
self.renderer.AddActor(actor)
scalarBar = vtk.vtkScalarBarActor()
scalarBar.SetTitle("")
scalarBar.SetWidth(0.1)
scalarBar.SetHeight(0.9)
scalarBar.SetLookupTable(lut)
#self.renderer.AddActor2D(scalarBar)
self.build_axes()
self.warp.SetScaleFactor(self.warp_factor)
self.warp.Update()
self.outline.Update()
self.renderer.ResetCameraClippingRange()
self.renderer.SetBackground(1, 1, 1)
self.renWin.SetSize(500, 500)
self.camera = self.renderer.GetActiveCamera()
self.center_on_actor(actor)
self.iren.AddObserver("CharEvent", self.on_keyboard_input)
self.iren.Initialize()
self.renWin.Render()
self.iren.Start()
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
# create a rendering window and renderer
renderer = vtk.vtkRenderer()
renderer.SetBackground(0, 0, 0)
window = vtk.vtkRenderWindow()
window.SetSize(512, 512)
window.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(window)
interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
style = vtk.vtkInteractorStyleSwitch()
style.SetCurrentStyleToMultiTouchCamera()
tc = vtk.vtkInteractorStyleTrackballCamera()
tc.OnRightButtonDown = tc.OnMiddleButtonDown
tc.OnRightButtonUp = tc.OnMiddleButtonUp
tc.Pan()
renderer.AddVolume(volume)
window.Render()
def runMovie(interactor, event):
key = interactor.GetKeySym()
print("key pressed: {:s}".format(key))
if key == "s":
class Ui_MainWindow(object):
cameraMode = 0
currentQuestion = 0
initial = 0
radioButtons = []
files = [('soldier_vox10_0690_vox10.vtk','tmc13_soldier_vox10_0690_dec_geom03_text03_octree-raht.vtk'),('soldier_vox10_0690_vox10.vtk','tmc13_soldier_vox10_0690_dec_geom02_text02_octree-raht.vtk'),('soldier_vox10_0690_vox10.vtk','tmc13_soldier_vox10_0690_dec_geom03_text03_octree-predlift.vtk')]
answersTab = [None] * len(files)
rendererLeft = vtk.vtkRenderer()
rendererRight = vtk.vtkRenderer()
mapperLeft = vtk.vtkPolyDataMapper()
mapperRight = vtk.vtkPolyDataMapper()
readerLeft = vtk.vtkDataSetReader()
readerRight = vtk.vtkDataSetReader()
actorLeft = vtk.vtkActor()
actorRight = vtk.vtkActor()
rendererLeft.SetActiveCamera(rendererRight.GetActiveCamera())
interactionStyle = vtk.vtkInteractorStyleSwitch()
interactionStyle.SetCurrentStyleToTrackballActor()
def setupUi(self, MainWindow):
self.MainWindow = MainWindow
MainWindow.setObjectName("MainWindow")
MainWindow.resize(2880, 1800)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.verticalLayoutWidget = QtWidgets.QWidget(self.centralwidget)
self.verticalLayoutWidget.setGeometry(QtCore.QRect(0, 210, 131, 141))
self.verticalLayoutWidget.setObjectName("verticalLayoutWidget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.verticalLayoutWidget)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setObjectName("verticalLayout")
for i in range(9):
self.radioButtons.append(QtWidgets.QRadioButton(self.verticalLayoutWidget))
self.radioButtons[i].setObjectName("radioButton_%d" % i)
self.verticalLayout.addWidget(self.radioButtons[i])
self.radioButtons[i].setChecked(False)
self.radioButtons[i].setStyleSheet('QRadioButton{font: 10pt Helvetica MS;} QRadioButton::indicator { width: 10px; height: 10px;};')
self.radioButtons[i].clicked.connect(self.enablenext)
self.commandLinkButton = QtWidgets.QCommandLinkButton(
self.centralwidget)
self.commandLinkButton.setGeometry(QtCore.QRect(0, 360, 131, 41))
self.commandLinkButton.setObjectName("commandLinkButton")
self.labelLeft = QtWidgets.QLabel(MainWindow)
self.labelRight = QtWidgets.QLabel(MainWindow)
self.imgref = QtGui.QPixmap('REF2.png')
self.imgdist =QtGui.QPixmap('DIST2.png')
self.labelLeft.setPixmap(self.imgref)
self.labelRight.setPixmap(self.imgdist)
self.labelLeft.setFixedSize(self.imgref.size())
self.labelRight.setFixedSize(self.imgdist.size())
self.labelLeft.move(QtCore.QPoint(150,0))
self.labelRight.move(QtCore.QPoint(795,0))
self.textBrowser = QtWidgets.QTextBrowser(self.centralwidget)
self.textBrowser.setGeometry(QtCore.QRect(0, 0, 150, 70))
self.textBrowser.setObjectName("textBrowser")
#self.frame = QtWidgets.QFrame(MainWindow)
self.vtkSection = QVTKRenderWindowInteractor(MainWindow)
self.rendererLeft.GetActiveCamera().ParallelProjectionOn()
self.rendererRight.GetActiveCamera().ParallelProjectionOn()
#self.frame.setGeometry(QtCore.QRect(131, 0, 2880, 1800))
self.vtkSection.setGeometry(QtCore.QRect(150, 40, 1290,860))
self.commandLinkButton.clicked.connect(self.registerAnswer)
self.commandLinkButton.setEnabled(False)
# b =map(lambda x: str(x),self.files)
# print('\n'.join(b))
# print("-------------------------")
self.iren = self.vtkSection.GetRenderWindow().GetInteractor()
if (self.initial == 0):
self.dispContents(0,camMode.OFF)
self.initial = 1
self.iren.ReInitialize()
MainWindow.setCentralWidget(self.centralwidget)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def enablenext(self):
self.commandLinkButton.setEnabled(True)
def writeAnswers(self):
return 1
def endOfExp(self):
self.writeAnswers()
sys.exit()
def registerAnswer(self):
a = np.argwhere([elem.isChecked() for elem in self.radioButtons]).flatten()[0]
self.answersTab[self.currentQuestion] = 9 - a
self.changeQuestion()
def changeQuestion(self):
if (self.currentQuestion == len(self.files) - 1):
self.endOfExp()
else:
for elem in self.radioButtons:
elem.setChecked(False)
self.currentQuestion += 1
self.dispContents(self.currentQuestion,camMode.OFF)
def dispContents(self,current,cameraMode):
self.rendererLeft.SetViewport(0,0,0.5,1)
self.rendererRight.SetViewport(0.5,0,1,1)
self.vtkSection.GetRenderWindow().AddRenderer(self.rendererLeft)
self.vtkSection.GetRenderWindow().AddRenderer(self.rendererRight)
self.readerLeft.SetFileName(self.files[current][0])
self.readerRight.SetFileName(self.files[current][1])
self.readerLeft.Update()
self.readerRight.Update()
self.mapperLeft.SetInputConnection(self.readerLeft.GetOutputPort())
self.mapperRight.SetInputConnection(self.readerRight.GetOutputPort())
self.actorLeft.SetMapper(self.mapperLeft)
self.actorRight.SetMapper(self.mapperRight)
self.rendererLeft.AddActor(self.actorLeft)
self.rendererRight.AddActor(self.actorRight)
if (cameraMode == camMode.OFF):
self.actorLeft.GetProperty().LightingOff()
self.actorRight.GetProperty().LightingOff()
self.actorLeft.GetProperty().SetInterpolationToPhong()
self.rendererLeft.ResetCamera()
self.rendererRight.ResetCamera()
self.iren.ReInitialize()
self.commandLinkButton.setEnabled(False)
print(self.answersTab[self.currentQuestion-1])
print(self.files[current][0]+' '+ self.files[current][1])
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.radioButtons[0].setText(_translate("MainWindow"," 9 - Imperceptible"))
self.radioButtons[1].setText(_translate("MainWindow","8"))
self.radioButtons[2].setText(_translate("MainWindow","7 - Perceptible but not \n Annoying"))
self.radioButtons[3].setText(_translate("MainWindow","6"))
self.radioButtons[4].setText(_translate("MainWindow","5 - Slightly Annoying"))
self.radioButtons[5].setText(_translate("MainWindow","4"))
self.radioButtons[6].setText(_translate("MainWindow","3 - Annoying "))
self.radioButtons[7].setText(_translate("MainWindow","2"))
self.radioButtons[8].setText(_translate("MainWindow","1 - Very Annoying"))
self.commandLinkButton.setText(_translate("MainWindow", "Next"))
self.textBrowser.setHtml(
_translate(
"MainWindow",
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n"
"<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\n"
"p, li { white-space: pre-wrap; }\n"
"</style></head><body style=\" font-family:\'Noto Sans\'; font-size:9pt; font-weight:400; font-style:normal;\">\n"
"<p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">Welcome !</p>\n"
"<p style=\"-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><br /></p>\n"
"<p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">How would you rate the level of impairment of the distorted content with respect to the reference? </p></body></html>"
))
def run(self):
doImports()
self.renWin = vtk.vtkRenderWindow()
self.ren = vtk.vtkRenderer()
self.renWin.AddRenderer(self.ren)
self.renWin.SetSize(600, 600)
self.ren.SetBackground(0.7, 0.7, 0.7)
self.ren.ResetCamera()
self.cam = self.ren.GetActiveCamera()
self.axes = vtk.vtkCubeAxesActor2D()
self.axes.SetCamera(self.ren.GetActiveCamera())
self.undefinedActor=vtk.vtkTextActor()
self.undefinedActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay()
self.undefinedActor.GetPositionCoordinate().SetValue(0.05,0.2)
self.undefinedActor.GetTextProperty().SetColor(1.,0.,0.)
self.undefinedActor.SetInput("")
try:
self.readFile()
except Exception:
e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e'
warning("While reading",self.parser.getArgs()[0],"this happened:",e)
raise e
self.ren.ResetCamera()
self.root = tkinter.Tk()
self.root.withdraw()
# Create the toplevel window
self.top = tkinter.Toplevel(self.root)
self.top.title("blockMesh-Viewer")
self.top.protocol("WM_DELETE_WINDOW", self.quit)
# Create some frames
self.f1 = tkinter.Frame(self.top)
self.f2 = tkinter.Frame(self.top)
self.f1.pack(side="top", anchor="n", expand=1, fill="both")
self.f2.pack(side="bottom", anchor="s", expand="f", fill="x")
# Create the Tk render widget, and bind the events
self.rw = vtkTkRenderWindowInteractor(self.f1, width=400, height=400, rw=self.renWin)
self.rw.pack(expand="t", fill="both")
self.blockHigh=tkinter.IntVar()
self.blockHigh.set(-1)
self.oldBlock=-1
self.blockActor=None
self.blockTextActor=None
self.patchHigh=tkinter.IntVar()
self.patchHigh.set(-1)
self.oldPatch=-1
self.patchActor=None
self.patchTextActor=vtk.vtkTextActor()
self.patchTextActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay()
self.patchTextActor.GetPositionCoordinate().SetValue(0.05,0.1)
self.patchTextActor.GetTextProperty().SetColor(0.,0.,0.)
self.patchTextActor.SetInput("Patch: <none>")
self.scroll=tkinter.Scale(self.f2,orient='horizontal',
from_=-1,to=len(self.blocks)-1,resolution=1,tickinterval=1,
label="Block (-1 is none)",
variable=self.blockHigh,command=self.colorBlock)
self.scroll.pack(side="top", expand="t", fill="x")
self.scroll2=tkinter.Scale(self.f2,orient='horizontal',
from_=-1,to=len(list(self.patches.keys()))-1,resolution=1,tickinterval=1,
label="Patch (-1 is none)",
variable=self.patchHigh,command=self.colorPatch)
self.scroll2.pack(side="top", expand="t", fill="x")
self.f3 = tkinter.Frame(self.f2)
self.f3.pack(side="bottom", anchor="s", expand="f", fill="x")
self.b1 = tkinter.Button(self.f3, text="Quit", command=self.quit)
self.b1.pack(side="left", expand="t", fill="x")
self.b2 = tkinter.Button(self.f3, text="Reread blockMeshDict", command=self.reread)
self.b2.pack(side="left", expand="t", fill="x")
self.root.update()
self.iren = self.renWin.GetInteractor()
self.istyle = vtk.vtkInteractorStyleSwitch()
self.iren.SetInteractorStyle(self.istyle)
self.istyle.SetCurrentStyleToTrackballCamera()
self.addProps()
self.iren.Initialize()
self.renWin.Render()
self.iren.Start()
self.root.mainloop()
def __init__(self, filename=sys.argv[1]):
# Create the RenderWindow, Renderer and both Actors
self.renderer = vtk.vtkRenderer()
self.renwin = vtk.vtkRenderWindow()
self.renwin.AddRenderer(self.renderer)
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetRenderWindow(self.renwin)
self.iren.SetInteractorStyle(vtk.vtkInteractorStyleSwitch())
self.iren.GetInteractorStyle().SetCurrentStyleToTrackballCamera()
# Start by loading some data.
reader = npy_reader()
self.data = reader.read(filename)
#secondary_data = reader.read(sys.argv[2])
self.compute_isosurf = False
self.lut = vtk.vtkLookupTable()
self.lut.SetHueRange(0.7, 0)
self.mi, self.ma = self.data.GetScalarRange()
self.lut.SetRange(self.mi, self.ma)
self.lut.Build()
#---------------- scalar field code
# Create transfer mapping scalar value to opacity
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(self.mi, 0)
opacityTransferFunction.AddPoint(self.ma, 0.4) #TODO
# Create transfer mapping scalar value to color
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.SetColorSpaceToRGB()
colorTransferFunction.AddRGBPoint(self.mi, 0, 0, 1)
colorTransferFunction.AddRGBPoint(self.ma, 1, 0, 0)
# The property describes how the data will look
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOff()
volumeProperty.SetInterpolationTypeToLinear()
if vtk.vtkVersion.GetVTKMajorVersion() < 6:
# The mapper / ray cast function know how to render the data
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
self.volume_mapper = vtk.vtkVolumeRayCastMapper()
self.volume_mapper.SetVolumeRayCastFunction(compositeFunction)
self.volume_mapper.SetInput(self.data)
else:
self.volume_mapper = vtk.vtkSmartVolumeMapper()
self.volume_mapper.SetRequestedRenderModeToGPU()
self.volume_mapper.SetInputData(self.data) #VTK6+
# which mode ?
#self.volume_mapper.SetRequestedRenderModeToDefault()
#self.volume_mapper.SetRequestedRenderModeToRayCast()
# The volume holds the mapper and the property and
# can be used to position/orient the volume
self.volume = vtk.vtkVolume()
self.volume.SetMapper(self.volume_mapper)
self.volume.SetProperty(volumeProperty)
#---------------- /endof scalar field code
self.coords = []
self.colors = []
self.point_list = []
self.vtkid = []
self.sampling_mode = False
self.picker = vtk.vtkCellPicker()
self.picker.SetTolerance(0.005)
# An outline is shown for context.
outline = vtk.vtkOutlineFilter()
if vtk.vtkVersion.GetVTKMajorVersion() < 6:
outline.SetInput(self.data)
else:
outline.SetInputData(self.data) #VTK6
outline_mapper = vtk.vtkPolyDataMapper()
outline_mapper.SetInputConnection(outline.GetOutputPort())
self.outline_actor = vtk.vtkActor()
self.outline_actor.SetMapper(outline_mapper)
self.outline_actor.PickableOff()
self.outline_actor.GetProperty().SetColor(0, 0, 0)
# Add the actors to the renderer, set the background and size
self.renderer.AddActor(self.outline_actor)
self.renderer.AddVolume(self.volume)
self.build_axes() #TODO
self.renderer.SetBackground(1, 1, 1)
self.renwin.SetSize(600, 600)
bounds = self.data.GetBounds()
shape = [bounds[1], bounds[3], bounds[5]]
self.camera = self.renderer.GetActiveCamera()
self.camera.SetFocalPoint(shape[0] / 2., shape[1] / 2., shape[2] / 2.)
self.camera.SetPosition(-shape[0], shape[1] / 2., shape[2] / 2.)
self.plane_widget = None
self.crop_widget = None
if self.compute_isosurf:
self.surfaces = []
self.surfaces.append(
Isosurface(self.renwin,
data=self.data,
isovalue=32000.,
color=(0, 1, 0),
rendering_type='surface'))
self.iren.Initialize()
self.renwin.Render()
self.iren.RemoveObservers("CharEvent")
self.iren.AddObserver("CharEvent", self.on_keyboard_input)
self.iren.Start()
x, y, z = pt[:3]
for i in range(0, 101, 10):
puzzle.SetPoint(x, y, z)
puzzle.MovePoint(i)
renWin.Render()
root.update()
in_piece_rotation = 0
root.update()
# Modify some bindings, use the interactor style 'switch'
iren = renWin.GetInteractor()
istyle = vtk.vtkInteractorStyleSwitch()
iren.SetInteractorStyle(istyle)
istyle.SetCurrentStyleToTrackballCamera()
iren.AddObserver("MouseMoveEvent", MotionCallback)
iren.AddObserver("CharEvent", CharCallback)
# Shuffle the puzzle
ButtonCallback(218, 195)
ButtonCallback(261, 128)
ButtonCallback(213, 107)
ButtonCallback(203, 162)
ButtonCallback(134, 186)
iren.Initialize()
def vis_ested_pcd_corners(ind=1):
# pair_ind = 9
pcd_result_file = os.path.join(
params['base_dir'], "output/pcd_seg/" +
str(ind).zfill(params["file_name_digits"]) + "_pcd_result.pkl")
csv_file = os.path.join(
params['base_dir'],
"pcd/" + str(ind).zfill(params["file_name_digits"]) + ".csv")
full_arr = np.genfromtxt(csv_file, delimiter=",", skip_header=1)
grid_coords = generate_grid_coords()
with open(os.path.abspath(pcd_result_file), "rb") as f:
pcd_result_ls = cPickle.load(f)
assert pcd_result_ls is not None
rot1 = pcd_result_ls[0]
t1 = pcd_result_ls[1].reshape(1, 3)
rot2 = pcd_result_ls[2]
t2 = pcd_result_ls[3].reshape(1, 3)
trans_grid_ls = []
for coords in grid_coords:
args = [[coord, rot1, rot2, t1, t2] for coord in coords[:3]]
trans_coords = list(map(transform_grid, args))
trans_coords.append(coords[3])
trans_grid_ls.append(trans_coords)
ren = vtk.vtkRenderer()
ren.SetBackground(.2, .3, .4)
ren.SetBackground(0.90196079, 0.96078432, 0.59607846)
# ren.SetBackground(1., 1., 1.)
for i in range(len(trans_grid_ls)):
tmp_actor = draw_one_grd_vtk(trans_grid_ls[i])
tmp_actor.GetProperty().SetOpacity(0.5)
ren.AddActor(tmp_actor)
show_only_marker = True
if show_only_marker:
marker_full_data_arr = exact_full_marker_data(csv_file,
[pcd_result_ls[-1]])
actor2 = vis_3D_points(marker_full_data_arr, color_style="intens_rg")
else:
actor2 = vis_3D_points(full_arr, color_style="intens_rg")
ren.AddActor(actor2)
transform2 = vtk.vtkTransform()
transform2.Translate(0.0, 0.0, 0.0)
axes2 = vtk.vtkAxesActor()
axes2.SetUserTransform(transform2)
ren.AddActor(axes2)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetWindowName(str(i).zfill(params["file_name_digits"]))
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
def get_camera_info(obj, ev):
if iren.GetKeyCode() == "s":
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renWin)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName("screenshot.png")
writer.SetInputData(w2if.GetOutput())
writer.Write()
print("screenshot saved")
style = vtk.vtkInteractorStyleSwitch()
iren.SetRenderWindow(renWin)
iren.SetInteractorStyle(style)
# style.SetCurrentStyleToTrackballActor()
style.SetCurrentStyleToTrackballCamera()
iren.AddObserver(vtk.vtkCommand.KeyPressEvent, get_camera_info, 1)
iren.Initialize()
renWin.Render()
renWin.SetWindowName(str(ind).zfill(params["file_name_digits"]))
iren.Start()
def vis_all_markers(ls=[1]):
import vtk
ren = vtk.vtkRenderer()
# ren.SetBackground(.2, .3, .4)
ren.SetBackground(.5, .6, .7)
for i in ls:
try:
pcd_result_file = os.path.join(
params['base_dir'], "output/pcd_seg/" +
str(i).zfill(params["file_name_digits"]) + "_pcd_result.pkl")
csv_path = os.path.join(
params['base_dir'],
"pcd/" + str(i).zfill(params["file_name_digits"]) + ".csv")
with open(os.path.abspath(pcd_result_file), "rb") as f:
pcd_result_ls = cPickle.load(f)
assert pcd_result_ls is not None
marker_full_data_arr = exact_full_marker_data(
csv_path, [pcd_result_ls[-1]])
marker_arr = marker_full_data_arr[:, :3]
# transformed_pcd = roate_with_rt(np.array(r_t), marker_arr)
if i % 4 == 0:
actor2 = vis_3D_points(np.hstack([
marker_arr + np.array([0, 0, 0]), marker_full_data_arr[:,
3:]
]),
color_style="intens")
elif i % 4 == 1:
actor2 = vis_3D_points(np.hstack([
marker_arr + np.array([0, 0, 0]), marker_full_data_arr[:,
3:]
]),
color_style="autumn")
elif i % 4 == 2:
actor2 = vis_3D_points(np.hstack([
marker_arr + np.array([0, 0, 0]), marker_full_data_arr[:,
3:]
]),
color_style="cool")
else:
actor2 = vis_3D_points(np.hstack([
marker_arr + np.array([0, 0, 0]), marker_full_data_arr[:,
3:]
]),
color_style="intens_rg")
ren.AddActor(actor2)
except:
print(i, "-th pcd corners are not found!")
continue
transform2 = vtk.vtkTransform()
transform2.Translate(0.0, 0.0, 0.0)
axes2 = vtk.vtkAxesActor()
axes2.SetUserTransform(transform2)
ren.AddActor(axes2)
cubeAxesActor = vtk.vtkCubeAxesActor()
cubeAxesActor.SetBounds((-3, 3, -3, 3, -2, 2))
cubeAxesActor.SetCamera(ren.GetActiveCamera())
cubeAxesActor.GetTitleTextProperty(0).SetColor(1.0, 0.0, 0.0)
cubeAxesActor.GetLabelTextProperty(0).SetColor(1.0, 0.0, 0.0)
cubeAxesActor.GetTitleTextProperty(1).SetColor(0.0, 1.0, 0.0)
cubeAxesActor.GetLabelTextProperty(1).SetColor(0.0, 1.0, 0.0)
cubeAxesActor.GetTitleTextProperty(2).SetColor(0.0, 0.0, 1.0)
cubeAxesActor.GetLabelTextProperty(2).SetColor(0.0, 0.0, 1.0)
cubeAxesActor.DrawXGridlinesOn()
cubeAxesActor.DrawYGridlinesOn()
cubeAxesActor.DrawZGridlinesOn()
# if vtk.VTK_MAJOR_VERSION > 5:
# cubeAxesActor.SetGridLineLocation(vtk.VTK_GRID_LINES_FURTHEST)
cubeAxesActor.XAxisMinorTickVisibilityOff()
cubeAxesActor.YAxisMinorTickVisibilityOff()
cubeAxesActor.ZAxisMinorTickVisibilityOff()
# cubeAxesActor.GetProperty().SetColor(0, 255, 0)
cubeAxesActor.GetXAxesLinesProperty().SetColor(0, 255, 0)
cubeAxesActor.GetYAxesLinesProperty().SetColor(0, 255, 0)
cubeAxesActor.GetZAxesLinesProperty().SetColor(0, 255, 0)
ren.AddActor(cubeAxesActor)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleSwitch()
iren.SetInteractorStyle(style)
style.SetCurrentStyleToTrackballCamera()
def get_camera_info(obj, ev):
if iren.GetKeyCode() == "s":
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renWin)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName("screenshot.png")
writer.SetInputData(w2if.GetOutput())
writer.Write()
print("screenshot saved")
# save to pdf
if iren.GetKeyCode() == "s":
exp = vtk.vtkGL2PSExporter()
exp.SetRenderWindow(renWin)
exp.SetFilePrefix("screenpdf")
exp.SetFileFormat(2)
exp.SetCompress(False)
exp.SetLandscape(False)
exp.SetSortToBSP()
# exp.SetSortToSimple() # less expensive sort algorithm
exp.DrawBackgroundOn()
exp.SetWrite3DPropsAsRasterImage(False)
iren.AddObserver(vtk.vtkCommand.KeyPressEvent, get_camera_info, 1)
iren.SetRenderWindow(renWin)
renWin.Render()
# ren.SetActiveCamera(camera)
iren.Initialize()
iren.Start()
def __init__(self, parent):
wx.Dialog.__init__(self,
parent,
style=wx.RESIZE_BORDER | wx.SYSTEM_MENU | wx.CAPTION
| wx.MAXIMIZE_BOX | wx.CLOSE_BOX,
title="Visualisation",
size=(640, 480))
self.SetSizeHints(640, 480, -1, -1)
self.Bind(wx.EVT_CLOSE, self.OnExit)
panelvisual = self.GetParent().nb.GetPage(1)
panelvisual.vtkpanel.Hide()
panelvisual.vtkpanel_holder.Show()
panelvisual.vtkpanel.Layout()
panelvisual.vtkpanel_holder.Layout()
self.FXAA = panelvisual.FXAA
panelvisual.FXAAScene(False)
if panelvisual.linewidget is not None:
self.linewidget_enabled = panelvisual.linewidget.GetEnabled()
if panelvisual.anglewidget is not None:
self.anglewiget_enabled = panelvisual.anglewidget.GetEnabled()
widget_enabled = panelvisual.widget.GetEnabled()
if widget_enabled:
panelvisual.widget.SetEnabled(0)
self.widget_viewport = panelvisual.widget.GetViewport()
self.renderer_amp_real_undocked = vtk.vtkRenderer()
self.renderer_phase_real_undocked = vtk.vtkRenderer()
self.renderer_amp_recip_undocked = vtk.vtkRenderer()
self.renderer_phase_recip_undocked = vtk.vtkRenderer()
from .render import wxVTKRenderWindowInteractor
self.renWin = wxVTKRenderWindowInteractor(self, wx.ID_ANY)
self.renWin.Enable(1)
self.renWin.GetRenderWindow().SetMultiSamples(0)
panelvisual.renderers = panelvisual.renWin.GetRenderWindow(
).GetRenderers()
panelvisual.renderers.InitTraversal()
renderer = panelvisual.renderers.GetFirstRenderer()
while renderer != None:
if renderer is panelvisual.renderer_amp_real:
self.RenderSwitch(panelvisual.renderer_amp_real,
self.renderer_amp_real_undocked)
elif renderer is panelvisual.renderer_phase_real:
self.RenderSwitch(panelvisual.renderer_phase_real,
self.renderer_phase_real_undocked)
elif renderer is panelvisual.renderer_amp_recip:
self.RenderSwitch(panelvisual.renderer_amp_recip,
self.renderer_amp_recip_undocked)
elif renderer is panelvisual.renderer_phase_recip:
self.RenderSwitch(panelvisual.renderer_phase_recip,
self.renderer_phase_recip_undocked)
renderer = panelvisual.renderers.GetNextItem()
panelvisual.renderer_amp_real = self.renderer_amp_real_undocked
panelvisual.renderer_phase_real = self.renderer_phase_real_undocked
panelvisual.renderer_amp_recip = self.renderer_amp_recip_undocked
panelvisual.renderer_phase_recip = self.renderer_phase_recip_undocked
panelvisual.style = panelvisual.renWin.GetInteractorStyle()
self.style2D = vtk.vtkInteractorStyleImage()
self.style3D = vtk.vtkInteractorStyleSwitch()
self.style3D.SetCurrentStyleToTrackballCamera()
if panelvisual.style is panelvisual.style3D:
self.renWin.SetInteractorStyle(self.style3D)
panelvisual.style = self.style3D
else:
self.renWin.SetInteractorStyle(self.style2D)
panelvisual.style = self.style2D
panelvisual.picker = panelvisual.renWinMain.GetPicker()
self.renWin.SetPicker(panelvisual.picker)
panelvisual.renWin = self.renWin
panelvisual.renWinMain.Hide()
panelvisual.vtkvbox.Layout()
panelvisual.RefreshSceneCMD = panelvisual.renWin.Render
if panelvisual.linewidget is not None:
panelvisual.linewidget.SetInteractor(panelvisual.renWin)
panelvisual.linewidget.Modified()
if self.linewidget_enabled:
panelvisual.linewidget.SetEnabled(0)
panelvisual.linewidget.SetEnabled(1)
if panelvisual.anglewidget is not None:
panelvisual.anglewidget.SetInteractor(panelvisual.renWin)
panelvisual.anglewidget.Modified()
if self.anglewiget_enabled:
panelvisual.anglewidget.SetEnabled(0)
panelvisual.anglewidget.SetEnabled(1)
if widget_enabled:
panelvisual.widget.SetEnabled(0)
panelvisual.widget.SetInteractor(panelvisual.renWin)
panelvisual.widget.SetOrientationMarker(panelvisual.axes)
panelvisual.widget.Modified()
panelvisual.widget.SetViewport(self.widget_viewport)
panelvisual.widget.SetEnabled(1)
panelvisual.widget.InteractiveOn()
if self.FXAA:
panelvisual.FXAAScene()
panelvisual.SetBackground()
self.vbox = wx.BoxSizer(wx.VERTICAL)
self.vbox.Add(self.renWin, 1, wx.EXPAND)
self.SetSizer(self.vbox)
self.Fit()
self.Layout()
self.Show()
