def vtkRenderWindowInteractorConeExample():
"""Like it says, just a simple example
"""
# create root window
root = Tkinter.Tk()
# create vtkTkRenderWidget
pane = vtkTkRenderWindowInteractor(root, width=300, height=300)
pane.Initialize()
def quit(obj=root):
obj.quit()
pane.AddObserver("ExitEvent", lambda o,e,q=quit: q())
ren = vtk.vtkRenderer()
pane.GetRenderWindow().AddRenderer(ren)
cone = vtk.vtkConeSource()
cone.SetResolution(8)
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInput(cone.GetOutput())
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# pack the pane into the tk root
pane.pack(fill='both', expand=1)
pane.Start()
# start the tk mainloop
root.mainloop()
def __init__(self, interactor):
self.interactor = interactor
self.window = interactor.GetRenderWindow()
self.renderer = vtk.vtkRenderer()
self.renderer.SetViewport(0, 0, 1, 1)
self.renderer.SetBackground(1, 1, 1)
# Used to overlay actors above widgets
self.actor_renderer = vtk.vtkRenderer()
self.actor_renderer.SetViewport(0, 0, 1, 1)
self.actor_renderer.SetBackground(1, 1, 1)
self.window.AddRenderer(self.renderer)
self.window.AddRenderer(self.actor_renderer)
self.widgets = []
self.timer_listener = self.interactor.AddObserver(
"TimerEvent",
self.__render)
self.window_mod = self.window.AddObserver(
"ModifiedEvent",
self.__place,
30)
self.render_listener = self.window.AddObserver(
"RenderEvent",
self.__rendered)
self.last_size = None
self.timer = None
def create_slice_window(self):
renderer = vtk.vtkRenderer()
renderer.SetLayer(0)
cam = renderer.GetActiveCamera()
overlay_renderer = vtk.vtkRenderer()
overlay_renderer.SetLayer(1)
overlay_renderer.SetActiveCamera(cam)
overlay_renderer.SetInteractive(0)
self.interactor.GetRenderWindow().SetNumberOfLayers(2)
self.interactor.GetRenderWindow().AddRenderer(overlay_renderer)
self.interactor.GetRenderWindow().AddRenderer(renderer)
actor = vtk.vtkImageActor()
# TODO: Create a option to let the user set if he wants to interpolate
# the slice images.
#actor.InterpolateOff()
slice_data = sd.SliceData()
slice_data.SetOrientation(self.orientation)
slice_data.renderer = renderer
slice_data.overlay_renderer = overlay_renderer
slice_data.actor = actor
slice_data.SetBorderStyle(sd.BORDER_ALL)
renderer.AddActor(actor)
renderer.AddActor(slice_data.text.actor)
renderer.AddViewProp(slice_data.box_actor)
return slice_data
def Render(self):
self.Viewport1 = [0.0, 0.0, 0.5, 0.5]
self.Viewport2 = [0.5, 0.0, 1.0, 0.5]
self.Viewport3 = [0.0, 0.5, 0.5, 1.0]
self.Viewport4 = [0.5, 0.5, 1.0, 1.0]
self.Renderer1 = vtk.vtkRenderer()
self.Renderer2 = vtk.vtkRenderer()
self.Renderer3 = vtk.vtkRenderer()
self.Renderer4 = vtk.vtkRenderer()
self.renderWindow.AddRenderer(self.Renderer1)
self.Renderer1.SetViewport(self.Viewport1)
self.Renderer1.SetBackground(0.6, 0.5, 0.3)
self.renderWindow.AddRenderer(self.Renderer2)
self.Renderer2.SetViewport(self.Viewport2)
self.Renderer2.SetBackground(0.5, 0.5, 0.4)
self.renderWindow.AddRenderer(self.Renderer3)
self.Renderer3.SetViewport(self.Viewport3)
self.Renderer3.SetBackground(0.4, 0.5, 0.5)
self.renderWindow.AddRenderer(self.Renderer4)
self.Renderer4.SetViewport(self.Viewport4)
self.Renderer4.SetBackground(0.0, 0.5, 0.6)
self.Renderer1.AddActor(self.inputActor1)
self.Renderer2.AddActor(self.inputActor2)
self.Renderer3.AddActor(self.inputActor3)
self.Renderer4.AddActor(self.inputActor4)
self.camera = vtk.vtkCamera()
self.Renderer1.SetActiveCamera(self.camera)
self.Renderer2.SetActiveCamera(self.camera)
self.Renderer3.SetActiveCamera(self.camera)
self.Renderer4.SetActiveCamera(self.camera)
self.Renderer1.ResetCamera()
self.renderWindow.Render()
self.interactor.Start()
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_Form()
self.ui.setupUi(self)
self.reader = vtk.vtkDICOMImageReader()
#self.viewerL = vtk.vtkImageViewer2()
#self.viewerR = vtk.vtkImageViewer2()
self.renL = vtk.vtkRenderer()
self.ui.leftVtk.GetRenderWindow().AddRenderer(self.renL)
self.renR = vtk.vtkRenderer()
self.ui.rightVtk.GetRenderWindow().AddRenderer(self.renR)
self.mapperL = vtk.vtkImageMapper()
self.mapperL.SetInputConnection(self.reader.GetOutputPort())
self.mapperR = vtk.vtkImageMapper()
self.actorL = vtk.vtkActor2D()
self.actorL.SetMapper(self.mapperL)
self.actorR = vtk.vtkActor2D()
self.actorR.SetMapper(self.mapperR)
self.renL.AddActor2D(self.actorL)
self.renR.AddActor2D(self.actorR)
self.importer = vtk.vtkImageImport()
self.mapperR.SetInputConnection(self.importer.GetOutputPort())
self.loadImage(os.path.join(STARTINGPATH, FILENAME))
self.setWindowingAlg()
def __init__(self):
super(RenderWidget, self).__init__()
# Default volume renderer
self.renderer = vtkRenderer()
self.renderer.SetBackground2(0.4, 0.4, 0.4)
self.renderer.SetBackground(0.1, 0.1, 0.1)
self.renderer.SetGradientBackground(True)
self.renderer.SetLayer(0)
# Overlay renderer which is synced with the default renderer
self.rendererOverlay = vtkRenderer()
self.rendererOverlay.SetLayer(1)
self.rendererOverlay.SetInteractive(0)
self.renderer.GetActiveCamera().AddObserver("ModifiedEvent", self._syncCameras)
self.rwi = QVTKRenderWindowInteractor(parent=self)
self.rwi.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
self.rwi.GetRenderWindow().AddRenderer(self.renderer)
self.rwi.GetRenderWindow().AddRenderer(self.rendererOverlay)
self.rwi.GetRenderWindow().SetNumberOfLayers(2)
self.rwi.SetDesiredUpdateRate(0)
self.imagePlaneWidgets = [vtkImagePlaneWidget() for i in range(3)]
for index in range(3):
self.imagePlaneWidgets[index].DisplayTextOn()
self.imagePlaneWidgets[index].SetInteractor(self.rwi)
# Disable the margin for free rotation
self.imagePlaneWidgets[index].SetMarginSizeX(0.0)
self.imagePlaneWidgets[index].SetMarginSizeY(0.0)
self.mapper = vtkOpenGLGPUVolumeRayCastMapper()
self.mapper.SetAutoAdjustSampleDistances(1)
self.volume = None
self.imageData = None
self.VolumeVisualization = None
self.shouldResetCamera = False
self.gridItems = []
self.orientationGridItems = []
self.clippingBox = ClippingBox()
self.clippingBox.setWidget(self)
# Keep track of the base and user transforms
self.baseTransform = vtkTransform()
self.userTransform = vtkTransform()
self.setMinimumWidth(340)
self.setMinimumHeight(340)
layout = QGridLayout(self)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.rwi, 0, 0)
self.setLayout(layout)
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.frame = QtGui.QFrame()
self.vl = QtGui.QGridLayout()
self.vtkWidget_right_femur = QVTKRenderWindowInteractor(self.frame)
self.vtkWidget_right_hip = QVTKRenderWindowInteractor(self.frame)
self.vtkWidget_left_femur = QVTKRenderWindowInteractor(self.frame)
self.vtkWidget_left_hip = QVTKRenderWindowInteractor(self.frame)
title_right_femur = QtGui.QLabel('Femur derecho')
title_right_hip = QtGui.QLabel('Cadera derecha')
title_left_femur = QtGui.QLabel('Femur izquierdo')
title_left_hip = QtGui.QLabel('Cadera izquierda')
self.vl.addWidget(title_right_femur, 0, 0)
self.vl.addWidget(self.vtkWidget_right_femur, 1, 0)
self.vl.addWidget(title_right_hip, 0, 1)
self.vl.addWidget(self.vtkWidget_right_hip, 1, 1)
self.vl.addWidget(title_left_femur, 2, 0)
self.vl.addWidget(self.vtkWidget_left_femur, 3, 0)
self.vl.addWidget(title_left_hip, 2, 1)
self.vl.addWidget(self.vtkWidget_left_hip, 3, 1)
self.ren_right_femur = vtk.vtkRenderer()
self.ren_right_hip = vtk.vtkRenderer()
self.ren_left_femur = vtk.vtkRenderer()
self.ren_left_hip = vtk.vtkRenderer()
self.vtkWidget_right_femur.GetRenderWindow().AddRenderer(self.ren_right_femur)
self.vtkWidget_right_hip.GetRenderWindow().AddRenderer(self.ren_right_hip)
self.vtkWidget_left_femur.GetRenderWindow().AddRenderer(self.ren_left_femur)
self.vtkWidget_left_hip.GetRenderWindow().AddRenderer(self.ren_left_hip)
self.iren_right_femur = self.vtkWidget_right_femur.GetRenderWindow().GetInteractor()
self.iren_right_hip = self.vtkWidget_right_hip.GetRenderWindow().GetInteractor()
self.iren_left_femur = self.vtkWidget_left_femur.GetRenderWindow().GetInteractor()
self.iren_left_hip = self.vtkWidget_left_hip.GetRenderWindow().GetInteractor()
openFile = QtGui.QAction(QtGui.QIcon('open.png'), 'Open', self)
openFile.setShortcut('Ctrl+O')
openFile.setStatusTip('Open new File')
openFile.triggered.connect(self.show_dialog)
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(openFile)
self.image_processing = ImageProcessing()
self.frame.setLayout(self.vl)
self.setCentralWidget(self.frame)
self.setGeometry(50, 50, 1200, 800)
self.show()
def renderers(window, rows=1, cols=1):
renderer = vtk.vtkRenderer()
rows = np.linspace(0,1,rows+1)
cols = np.linspace(0,1,cols+1)
rows, cols = np.meshgrid(rows, cols)
renderers = []
for r, c in zip(range(rows.shape[0]-1), range(cols.shape[1]-1)):
viewport = rows[r, r], cols[c, c], rows[r+1, r+1], cols[c+1, c+1]
renderers.append(vtk.vtkRenderer())
window.AddRenderer(renderers[-1])
renderers[-1].SetViewport(viewport)
renderers[-1].SetBackground(1., 1., 1.)
return renderers
def clean_gui(self):
self.ren_right_femur = vtk.vtkRenderer()
self.ren_right_hip = vtk.vtkRenderer()
self.ren_left_femur = vtk.vtkRenderer()
self.ren_left_hip = vtk.vtkRenderer()
self.vtkWidget_right_femur.GetRenderWindow().AddRenderer(self.ren_right_femur)
self.vtkWidget_right_hip.GetRenderWindow().AddRenderer(self.ren_right_hip)
self.vtkWidget_left_femur.GetRenderWindow().AddRenderer(self.ren_left_femur)
self.vtkWidget_left_hip.GetRenderWindow().AddRenderer(self.ren_left_hip)
self.iren_right_femur = self.vtkWidget_right_femur.GetRenderWindow().GetInteractor()
self.iren_right_hip = self.vtkWidget_right_hip.GetRenderWindow().GetInteractor()
self.iren_left_femur = self.vtkWidget_left_femur.GetRenderWindow().GetInteractor()
self.iren_left_hip = self.vtkWidget_left_hip.GetRenderWindow().GetInteractor()
def build_vtk_renderer(self):
# offscreen rendering
if (vtk.vtkVersion().GetVTKMajorVersion() == 5.0):
graphics_factory = vtk.vtkGraphicsFactory()
graphics_factory.SetOffScreenOnlyMode( 1);
graphics_factory.SetUseMesaClasses( 1 );
imaging_factory = vtk.vtkImagingFactory()
imaging_factory.SetUseMesaClasses( 1 );
self.renderer = vtk.vtkRenderer()
self.renderer.SetBackground(1, 1, 1)
self.render_window = vtk.vtkRenderWindow()
# offscreen rendering
self.render_window.SetOffScreenRendering(1)
self.render_window.AddRenderer(self.renderer)
# create a renderwindowinteractor
#if self.interact:
#self.iren = vtk.vtkRenderWindowInteractor()
#self.iren.SetRenderWindow(self.render_window)
# scalar bar
self.scalarbar = vtk.vtkScalarBarActor()
# To avoid uninitialized warning in VTK 6
self.scalarbar.SetTitle("")
# black text since background is white for printing
self.scalarbar.GetLabelTextProperty().SetColor(0, 0, 0)
self.scalarbar.GetTitleTextProperty().SetColor(0, 0, 0)
def plotvtk(mesh,boundary):
meshMapper = vtk.vtkPolyDataMapper()
meshMapper.SetInputConnection(mesh.GetOutputPort())
meshActor = vtk.vtkActor()
meshActor.SetMapper(meshMapper)
meshActor.GetProperty().SetEdgeColor(0, 0, 1)
meshActor.GetProperty().SetInterpolationToFlat()
meshActor.GetProperty().SetRepresentationToWireframe()
boundaryMapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
boundaryMapper.SetInputConnection(boundary.GetProducerPort())
else:
boundaryMapper.SetInputData(boundary)
boundaryActor = vtk.vtkActor()
boundaryActor.SetMapper(boundaryMapper)
boundaryActor.GetProperty().SetColor(1, 0, 0)
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(meshActor)
renderer.AddActor(boundaryActor)
renderer.SetBackground(.3, .6, .3)
renderWindowInteractor.Initialize()
renderWindow.Render()
renderWindowInteractor.Start()
def testFixedPointRayCasterLinearCropped(self):
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
iRen = vtk.vtkRenderWindowInteractor()
tFPRCN = TestFixedPointRayCasterNearest.FixedPointRayCasterNearest(ren, renWin, iRen)
volumeProperty = tFPRCN.GetVolumeProperty()
volumeMapper = tFPRCN.GetVolumeMapper()
for j in range(0, 5):
for i in range(0, 5):
volumeMapper[i][j].SetCroppingRegionPlanes(10, 20, 10, 20, 10, 20)
volumeMapper[i][j].SetCroppingRegionFlags(253440)
volumeMapper[i][j].CroppingOn()
volumeProperty[i][j].SetInterpolationTypeToLinear()
# render and interact with data
renWin.Render()
img_file = "TestFixedPointRayCasterLinearCropped.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=10)
vtk.test.Testing.interact()
def __init__(self):
GtkGLExtVTKRenderWindowInteractor.__init__(self)
EventHandler().attach(self)
self.interactButtons = (1,2,3)
self.renderOn = 1
self.Initialize()
self.Start()
self.renderer = vtk.vtkRenderer()
self.renWin = self.GetRenderWindow()
self.renWin.AddRenderer(self.renderer)
self.interactor = self.renWin.GetInteractor()
#self.camera = self.renderer.GetActiveCamera()
self.pressFuncs = {1 : self._Iren.LeftButtonPressEvent,
2 : self._Iren.MiddleButtonPressEvent,
3 : self._Iren.RightButtonPressEvent}
self.releaseFuncs = {1 : self._Iren.LeftButtonReleaseEvent,
2 : self._Iren.MiddleButtonReleaseEvent,
3 : self._Iren.RightButtonReleaseEvent}
self.pressHooks = {}
self.releaseHooks = {}
self.lastLabel = None
self.vtk_interact_mode = False
def main():
'''One render window, multiple viewports'''
iren_list = []
rw = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(rw)
# Define viewport ranges
xmins=[0,.5,0,.5]
xmaxs=[0.5,1,0.5,1]
ymins=[0,0,.5,.5]
ymaxs=[0.5,0.5,1,1]
for i in range(4):
ren = vtk.vtkRenderer()
rw.AddRenderer(ren)
ren.SetViewport(xmins[i],ymins[i],xmaxs[i],ymaxs[i])
#Create a sphere
sphereSource = vtk.vtkSphereSource()
sphereSource.SetCenter(0.0, 0.0, 0.0)
sphereSource.SetRadius(5)
#Create a mapper and actor
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(sphereSource.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
ren.AddActor(actor)
ren.ResetCamera()
rw.Render()
rw.SetWindowName('RW: Multiple ViewPorts')
iren.Start()
def QVTKRenderWidgetConeExample():
"""A simple example that uses the QVTKRenderWindowInteractor
class. """
# every QT app needs an app
app = qt.QApplication(['QVTKRenderWindowInteractor'])
# create the widget
widget = QVTKRenderWindowInteractor()
widget.Initialize()
widget.Start()
# if you dont want the 'q' key to exit comment this.
widget.AddObserver("ExitEvent", lambda o, e, a=app: a.quit())
ren = vtk.vtkRenderer()
widget.GetRenderWindow().AddRenderer(ren)
cone = vtk.vtkConeSource()
cone.SetResolution(8)
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# show the widget
widget.show()
# close the application when window is closed
app.setMainWidget(widget)
# start event processing
app.exec_loop()
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 initialize(self, VTKWebApp, args):
if not VTKWebApp.view:
# VTK specific code
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.GetInteractorStyle().SetCurrentStyleToTrackballCamera()
cone = vtk.vtkConeSource()
mapper = vtk.vtkPolyDataMapper()
actor = vtk.vtkActor()
mapper.SetInputConnection(cone.GetOutputPort())
actor.SetMapper(mapper)
renderer.AddActor(actor)
renderer.ResetCamera()
renderWindow.Render()
# VTK Web application specific
VTKWebApp.view = renderWindow
self.Application.GetObjectIdMap().SetActiveObject("VIEW", renderWindow)
def __init__(self, file_list,spacing_list,feature_type,irad = 1.2, h_th=-200,
glyph_type='sphere', glyph_scale_factor=1,use_field_data=True, opacity_list=[],
color_list=[], lung=[]):
assert feature_type == "ridge_line" or feature_type == "valley_line" \
or feature_type == "ridge_surface" or feature_type == "valley_surface" \
or feature_type == "vessel" or feature_type == "airway" \
or feature_type == "fissure", "Invalid feature type"
if feature_type == "airway":
feature_type = "valley_line"
elif feature_type == "vessel":
feature_type = "ridge_line"
elif feature_type == "fissure":
feature_type = "ridge_surface"
self.mapper_list = list()
self.actor_list = list()
self.glyph_list = list()
self.glyph_type = glyph_type
self.file_list = file_list
self.spacing_list = spacing_list
self.opacity_list = opacity_list
self.irad = irad
self.h_th = h_th
self.color_list = color_list
self.lung = lung
self.use_field_data = use_field_data
self.feature_type = feature_type
self.normal_map=dict()
self.normal_map['ridge_line'] = "hevec0"
self.normal_map['valley_line'] = "hevec2"
self.normal_map['ridge_surface'] = "hevec2"
self.normal_map['valley_surface'] = "hevec0"
self.strength_map=dict()
self.strength_map['ridge_line'] = "h1"
self.strength_map['valley_line'] = "h1"
self.strength_map['ridge_surface'] = "h2"
self.strength_map['valley_surface'] = "h0"
if feature_type == 'ridge_line' or feature_type == 'valley_line':
self.height = irad
self.radius = 0.5
elif feature_type == 'ridge_surface' or feature_type == 'valley_surface':
self.height = 0.5
self.radius = irad
self.min_rad = 0.5
self.max_rad = 6
self.glyph_scale_factor = glyph_scale_factor
self.capture_prefix = ""
self.capture_count = 1
# VTK Objects
self.ren = vtk.vtkRenderer()
self.renWin = vtk.vtkRenderWindow()
self.iren = vtk.vtkRenderWindowInteractor()
self.image_count = 1
def __init__(self, volume):
super(InteractiveIsosurface, self).__init__()
self._default_size = (600, 600)
self.resize(*self._default_size)
#self._volume = numpy.ascontiguousarray(volume, dtype="float32")
self._surface_object = IsoSurface(volume)
self._central_widget = QtGui.QWidget(self)
self._vtk_widget = QVTKRenderWindowInteractor(self._central_widget)
self._vtk_widget.SetInteractorStyle(_vtk.vtkInteractorStyleRubberBandPick())
self._renderer = _vtk.vtkRenderer()
self._renderer.SetBackground(0., 0., 0.)
self._surface_object.set_renderer(self._renderer)
self._THRESHOLD_SLIDER_MAXIMUM = 1000
self._THRESHOLD_SLIDER_INIT = self._THRESHOLD_SLIDER_MAXIMUM/2
self._threshold_table = self._adaptive_slider_values(volume, self._THRESHOLD_SLIDER_MAXIMUM, volume.min(), volume.max())
self._threshold_slider = QtGui.QSlider(QtCore.Qt.Horizontal)
self._threshold_slider.setMaximum(self._THRESHOLD_SLIDER_MAXIMUM)
self._layout = QtGui.QVBoxLayout()
self._layout.addWidget(self._vtk_widget)
self._layout.addWidget(self._threshold_slider)
self._central_widget.setLayout(self._layout)
self.setCentralWidget(self._central_widget)
def view(stlfilename):
reader = vtk.vtkSTLReader()
reader.SetFileName(stlfilename)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Create a rendering window and renderer
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
# Create a renderwindowinteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Assign actor to the renderer
ren.AddActor(actor)
# Enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
def __init__(self, input=None, MinOpacity=0.0, MaxOpacity=0.1) :
import qt
import vtk
from vtk.qt.QVTKRenderWindowInteractor import QVTKRenderWindowInteractor
self.__MinOpacity__ = MinOpacity
self.__MaxOpacity__ = MaxOpacity
# every QT app needs an app
self.__app__ = qt.QApplication(['itkviewer'])
# create the widget
self.__widget__ = QVTKRenderWindowInteractor()
self.__ren__ = vtk.vtkRenderer()
self.__widget__.GetRenderWindow().AddRenderer(self.__ren__)
self.__itkvtkConverter__ = None
self.__volumeMapper__ = vtk.vtkVolumeTextureMapper2D()
self.__volume__ = vtk.vtkVolume()
self.__volumeProperty__ = vtk.vtkVolumeProperty()
self.__volume__.SetMapper(self.__volumeMapper__)
self.__volume__.SetProperty(self.__volumeProperty__)
self.__ren__.AddVolume(self.__volume__)
self.__outline__ = None
self.__outlineMapper__ = None
self.__outlineActor__ = None
self.AdaptColorAndOpacity(0, 255)
if input :
self.SetInput(input)
self.AdaptColorAndOpacity()
def draw(self):
# Update location and movement
self.update()
# create a rendering window and renderer
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetSize(1200, 900)
renWin.AddRenderer(ren)
# Create camera
camera = vtk.vtkCamera()
#camera.SetPosition(0.5,10.0,0.0);
#camera.Roll(-90)
#ren.SetActiveCamera(camera)
# create a renderwindowinteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add actors
ren.AddActor(self.modelActor)
ren.AddActor(self.axesActor)
# enable user interface interactor
iren.Initialize()
renWin.Render()
style = vtk.vtkInteractorStyleMultiTouchCamera()
iren.SetInteractorStyle(style)
iren.Start()
def initialize(self):
global renderer, renderWindow, renderWindowInteractor, cone, mapper, actor
# Bring used components
self.registerVtkWebProtocol(protocols.vtkWebMouseHandler())
self.registerVtkWebProtocol(protocols.vtkWebViewPort())
self.registerVtkWebProtocol(protocols.vtkWebViewPortImageDelivery())
self.registerVtkWebProtocol(protocols.vtkWebViewPortGeometryDelivery())
# Create default pipeline (Only once for all the session)
if not _WebCone.view:
# VTK specific code
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.GetInteractorStyle().SetCurrentStyleToTrackballCamera()
cone = vtk.vtkConeSource()
mapper = vtk.vtkPolyDataMapper()
actor = vtk.vtkActor()
mapper.SetInputConnection(cone.GetOutputPort())
actor.SetMapper(mapper)
renderer.AddActor(actor)
renderer.ResetCamera()
renderWindow.Render()
# VTK Web application specific
_WebCone.view = renderWindow
self.Application.GetObjectIdMap().SetActiveObject("VIEW", renderWindow)
def __init__(self, parent = None):
super(VTKFrame, self).__init__(parent)
self.vl = QtGui.QVBoxLayout(self)
self.vl.setContentsMargins(0,0,0,0)
self.vtkWidget = QVTKRenderWindowInteractor(self)
self.vl.addWidget(self.vtkWidget)
self._renderer = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self._renderer)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
#Create an style
self._interactorStyle = MouseInteractorActor()
self._interactorStyle.SetDefaultRenderer(self._renderer)
self.vtkWidget.SetInteractorStyle(self._interactorStyle)
self._actor1 = self.createActor1()
self._actor2 = self.createActor2()
self._renderer.AddActor(self._actor1)
self._renderer.AddActor(self._actor2)
self._renderer.ResetCamera()
self._renderer.SetBackground(.1, .2, .3)
self._initialized = False
def __init__(self, id):
wx.Frame.__init__(self, id, title='My first VTKwx example', style =wx.DEFAULT_FRAME_STYLE)
## Add a menubar
menuBar = wx.MenuBar()
menuF = wx.Menu()
menuBar.Append(menuF, "File")
self.draw = menuF.Append(wx.ID_OPEN, 'Draw')
self.SetMenuBar(menuBar)
self.sb = self.CreateStatusBar()
self.sb.SetFieldsCount(2)
# Add the vtk window widget
self.widget = wxVTKRenderWindowInteractor(self, -1)
self.widget.Enable(1)
# Layout
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.widget, 1, wx.EXPAND)
self.SetSizer(sizer)
self.Layout()
# Ad a renderer
self.ren = vtk.vtkRenderer()
self.widget.GetRenderWindow().AddRenderer(self.ren)
# Bind the menu
self.Bind(wx.EVT_MENU, self.onDraw, self.draw)
def _create_renderer(self):
renderer = vtk.vtkRenderer()
renderer.SetViewport(0.0, 0.0, 1., 1.)
renderer.SetActiveCamera(self._create_camera())
renderer.SetBackground(self.settings.image_background_color)
self._add_lights_to_renderer(renderer)
return renderer
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 run(self):
self.vtk_renderer = vtkRenderer()
self.setup_gui()
self.setup_grid()
# Handle any deferred configuration
# Overlaid polygons
for args in self.conf_overlaidPolygons:
self.overlay_polygon_internal(*args)
# Draw (and maybe alter) the axes
if self.vtk_drawAxes:
self.vtk_axes = vtkCubeAxesActor2D()
# Perform all of the alterations required, by applying func to the vtk_axes instance (with the given args).
for func, args in self.conf_axesAlterations:
func(*((self.vtk_axes,) + args))
# Alter the Tk root as necessary.
for func, args in self.conf_tkAlterations:
func(*((self.tk_root,) + args))
# Finished with deferred configuration.
# Draw Height Quantities
for q in self.height_quantities:
self.update_height_quantity(q, self.height_dynamic[q])
self.draw_height_quantity(q)
self.tk_root.mainloop()
def add(**kwargs):
ren = vtk.vtkRenderer()
ren.SetBackground(0.5, 0.5, 0.5)
#ren.SetViewport(0, 0, 0.5, 1)
renWin.AddRenderer(ren)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(elev.GetOutputPort())
mapper.SetLookupTable(lut)
mapper.SetInterpolateScalarsBeforeMapping(kwargs['interpolate_scalars_before_mapping'])
mapper.SetScalarMaterialMode(kwargs["material_mode"])
actor = vtk.vtkActor()
actor.SetMapper(mapper)
ren.AddActor(actor)
prop = actor.GetProperty()
prop.SetAmbient(kwargs['ambient'])
prop.SetDiffuse(kwargs['diffuse'])
prop.SetAmbientColor(1, 0, 0)
prop.SetDiffuseColor(0, 1, 0)
textActorL = vtk.vtkTextActor()
txt = " InterpolateScalarsBeforeMapping: %d\n"\
" ScalarMaterialMode: %s\n"\
" Ambient: %.2f\t Ambient Color: 1, 0, 0\n"\
" Diffuse: %.2f\t Diffuse Color: 0, 1, 0"
txt = txt % (kwargs['interpolate_scalars_before_mapping'],
mapper.GetScalarMaterialModeAsString(), prop.GetAmbient(), prop.GetDiffuse())
textActorL.SetInput(txt)
ren.AddActor(textActorL)
return (ren, actor, mapper)
def __test_adjust_sphere():
import vtk
n_points = 4
points = []
for i in xrange(n_points):
p = np.random.random(3) * 100
points.append(p)
r, ctr = adjust_sphere(points)
r2 = r / 10
ren_win = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
iren.SetRenderWindow(ren_win)
ren = vtk.vtkRenderer()
ren_win.AddRenderer(ren)
# draw points
for p in points:
__add_sphere_to_ren(p, r2, ren)
#draw big sphere
ac = __add_sphere_to_ren(ctr, r, ren)
ac.GetProperty().SetColor((1, 0, 0))
iren.Initialize()
iren.Start()
def ParametricObjects(self):
parametricObjects = list()
parametricObjects.append(vtk.vtkParametricBoy())
parametricObjects.append(vtk.vtkParametricConicSpiral())
parametricObjects.append(vtk.vtkParametricCrossCap())
parametricObjects.append(vtk.vtkParametricDini())
parametricObjects.append(vtk.vtkParametricEllipsoid())
parametricObjects[-1].SetXRadius(0.5)
parametricObjects[-1].SetYRadius(2.0)
parametricObjects.append(vtk.vtkParametricEnneper())
parametricObjects.append(vtk.vtkParametricFigure8Klein())
parametricObjects.append(vtk.vtkParametricKlein())
parametricObjects.append(vtk.vtkParametricMobius())
parametricObjects.append(vtk.vtkParametricRandomHills())
parametricObjects[-1].AllowRandomGenerationOff()
parametricObjects.append(vtk.vtkParametricRoman())
parametricObjects.append(vtk.vtkParametricSuperEllipsoid())
parametricObjects[-1].SetN1(0.5)
parametricObjects[-1].SetN2(0.1)
parametricObjects.append(vtk.vtkParametricSuperToroid())
parametricObjects[-1].SetN1(0.2)
parametricObjects[-1].SetN2(3.0)
parametricObjects.append(vtk.vtkParametricTorus())
parametricObjects.append(vtk.vtkParametricSpline())
# Add some points to the parametric spline.
# You can use vtkRandom instead of the python random methods.
inputPoints = vtk.vtkPoints()
random.seed(8775070)
for i in range(10):
x = random.uniform(0.0, 1.0)
y = random.uniform(0.0, 1.0)
z = random.uniform(0.0, 1.0)
inputPoints.InsertNextPoint(x, y, z)
parametricObjects[-1].SetPoints(inputPoints)
# There are only 15 objects.
#parametricObjects.append(vtk.??)
parametricFunctionSources = list()
renderers = list()
mappers = list()
actors = list()
textmappers = list()
textactors = list()
# Create a common text property.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(10)
textProperty.SetJustificationToCentered()
# Create a parametric function source, renderer, mapper
# and actor for each object.
for idx, item in enumerate(parametricObjects):
parametricFunctionSources.append(vtk.vtkParametricFunctionSource())
parametricFunctionSources[idx].SetParametricFunction(item)
parametricFunctionSources[idx].Update()
mappers.append(vtk.vtkPolyDataMapper())
mappers[idx].SetInputConnection(
parametricFunctionSources[idx].GetOutputPort())
actors.append(vtk.vtkActor())
actors[idx].SetMapper(mappers[idx])
textmappers.append(vtk.vtkTextMapper())
textmappers[idx].SetInput(item.GetClassName())
textmappers[idx].SetTextProperty(textProperty)
textactors.append(vtk.vtkActor2D())
textactors[idx].SetMapper(textmappers[idx])
textactors[idx].SetPosition(100, 16)
renderers.append(vtk.vtkRenderer())
gridDimensions = 4
for idx in range(len(parametricObjects)):
if idx < gridDimensions * gridDimensions:
renderers.append(vtk.vtkRenderer)
rendererSize = 200
# Create the RenderWindow
#
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(rendererSize * gridDimensions,
rendererSize * gridDimensions)
# Add and position the renders to the render window.
viewport = list()
for row in range(gridDimensions):
for col in range(gridDimensions):
idx = row * gridDimensions + col
viewport[:] = []
viewport.append(
float(col) * rendererSize /
(gridDimensions * rendererSize))
viewport.append(
float(gridDimensions - (row + 1)) * rendererSize /
(gridDimensions * rendererSize))
viewport.append(
float(col + 1) * rendererSize /
(gridDimensions * rendererSize))
viewport.append(
float(gridDimensions - row) * rendererSize /
(gridDimensions * rendererSize))
if idx > (len(parametricObjects) - 1):
continue
renderers[idx].SetViewport(viewport)
renderWindow.AddRenderer(renderers[idx])
renderers[idx].AddActor(actors[idx])
renderers[idx].AddActor(textactors[idx])
renderers[idx].SetBackground(0.2, 0.3, 0.4)
renderers[idx].ResetCamera()
renderers[idx].GetActiveCamera().Azimuth(30)
renderers[idx].GetActiveCamera().Elevation(-30)
renderers[idx].ResetCameraClippingRange()
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
def main():
colors = vtk.vtkNamedColors()
fileName = get_program_parameters()
polyData = ReadPolyData(fileName)
# A renderer.
renderer = vtk.vtkRenderer()
renderer.SetBackground(colors.GetColor3d("White"))
# Create background colors for each viewport.
backgroundColors = list()
backgroundColors.append(colors.GetColor3d("Cornsilk"))
backgroundColors.append(colors.GetColor3d("NavajoWhite"))
backgroundColors.append(colors.GetColor3d("Tan"))
# Create a renderer for each view port.
ren = list()
ren.append(vtk.vtkRenderer())
ren.append(vtk.vtkRenderer())
ren.append(vtk.vtkRenderer())
ren[0].SetViewport(0, 0, 1.0 / 3.0, 1) # Input
ren[1].SetViewport(1.0 / 3.0, 0, 2.0 / 3.0, 1) # Normals (no split)
ren[2].SetViewport(2.0 / 3.0, 0, 1, 1) # Normals (split)
# Shared camera.
camera = vtk.vtkCamera()
normals = vtk.vtkPolyDataNormals()
normals.SetInputData(polyData)
normals.SetFeatureAngle(30.0)
for i in range(0, 3):
if i == 0:
normals.ComputePointNormalsOff()
elif i == 1:
normals.ComputePointNormalsOn()
normals.SplittingOff()
else:
normals.ComputePointNormalsOn()
normals.SplittingOn()
print(normals)
normals.Update()
normalsPolyData = vtk.vtkPolyData()
normalsPolyData.DeepCopy(normals.GetOutput())
# mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(normalsPolyData)
mapper.ScalarVisibilityOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetDiffuseColor(colors.GetColor3d("Peacock"))
actor.GetProperty().SetDiffuse(.7)
actor.GetProperty().SetSpecularPower(20)
actor.GetProperty().SetSpecular(.5)
# add the actor
ren[i].SetBackground(backgroundColors[i])
ren[i].SetActiveCamera(camera)
ren[i].AddActor(actor)
# Render window.
renwin = vtk.vtkRenderWindow()
renwin.AddRenderer(ren[0])
renwin.AddRenderer(ren[1])
renwin.AddRenderer(ren[2])
# An interactor.
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renwin)
renwin.SetSize(900, 300)
ren[0].GetActiveCamera().SetFocalPoint(0, 0, 0)
ren[0].GetActiveCamera().SetPosition(1, 0, 0)
ren[0].GetActiveCamera().SetViewUp(0, 0, -1)
ren[0].ResetCamera()
ren[0].GetActiveCamera().Azimuth(120)
ren[0].GetActiveCamera().Elevation(30)
ren[0].GetActiveCamera().Dolly(1.1)
ren[0].ResetCameraClippingRange()
renwin.Render()
ren[0].ResetCamera()
renwin.Render()
# Start.
interactor.Initialize()
interactor.Start()
def testFinancialField(self):
"""
Demonstrate the use and manipulation of fields and use of
vtkProgrammableDataObjectSource. This creates fields the hard way
(as compared to reading a vtk field file), but shows you how to
interface to your own raw data.
The image should be the same as financialField.tcl
"""
xAxis = "INTEREST_RATE"
yAxis = "MONTHLY_PAYMENT"
zAxis = "MONTHLY_INCOME"
scalar = "TIME_LATE"
# Parse an ascii file and manually create a field. Then construct a
# dataset from the field.
dos = vtk.vtkProgrammableDataObjectSource()
def parseFile():
f = open(VTK_DATA_ROOT + "/Data/financial.txt", "r")
line = f.readline().split()
# From the size calculate the number of lines.
numPts = int(line[1])
numLines = (numPts - 1) / 8 + 1
# create the data object
field = vtk.vtkFieldData()
field.AllocateArrays(4)
# read TIME_LATE - dependent variable
while True:
line = f.readline().split()
if len(line) > 0:
break
timeLate = vtk.vtkFloatArray()
timeLate.SetName(line[0])
for i in range(0, numLines):
line = f.readline().split()
for j in line:
timeLate.InsertNextValue(float(j))
field.AddArray(timeLate)
# MONTHLY_PAYMENT - independent variable
while True:
line = f.readline().split()
if len(line) > 0:
break
monthlyPayment = vtk.vtkFloatArray()
monthlyPayment.SetName(line[0])
for i in range(0, numLines):
line = f.readline().split()
for j in line:
monthlyPayment.InsertNextValue(float(j))
field.AddArray(monthlyPayment)
# UNPAID_PRINCIPLE - skip
while True:
line = f.readline().split()
if len(line) > 0:
break
for i in range(0, numLines):
line = f.readline()
# LOAN_AMOUNT - skip
while True:
line = f.readline().split()
if len(line) > 0:
break
for i in range(0, numLines):
line = f.readline()
# INTEREST_RATE - independent variable
while True:
line = f.readline().split()
if len(line) > 0:
break
interestRate = vtk.vtkFloatArray()
interestRate.SetName(line[0])
for i in range(0, numLines):
line = f.readline().split()
for j in line:
interestRate.InsertNextValue(float(j))
field.AddArray(interestRate)
# MONTHLY_INCOME - independent variable
while True:
line = f.readline().split()
if len(line) > 0:
break
monthlyIncome = vtk.vtkFloatArray()
monthlyIncome.SetName(line[0])
for i in range(0, numLines):
line = f.readline().split()
for j in line:
monthlyIncome.InsertNextValue(float(j))
field.AddArray(monthlyIncome)
dos.GetOutput().SetFieldData(field)
dos.SetExecuteMethod(parseFile)
# Create the dataset
do2ds = vtk.vtkDataObjectToDataSetFilter()
do2ds.SetInputConnection(dos.GetOutputPort())
do2ds.SetDataSetTypeToPolyData()
#format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize
do2ds.DefaultNormalizeOn()
do2ds.SetPointComponent(0, xAxis, 0)
do2ds.SetPointComponent(1, yAxis, 0)
do2ds.SetPointComponent(2, zAxis, 0)
do2ds.Update()
rf = vtk.vtkRearrangeFields()
rf.SetInputConnection(do2ds.GetOutputPort())
rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA")
rf.RemoveOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA")
rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA")
rf.RemoveAllOperations()
rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA")
rf.Update()
max = rf.GetOutput().GetPointData().GetArray(scalar).GetRange(0)[1]
calc = vtk.vtkArrayCalculator()
calc.SetInputConnection(rf.GetOutputPort())
calc.SetAttributeModeToUsePointData()
calc.SetFunction("s / %f" % max)
calc.AddScalarVariable("s", scalar, 0)
calc.SetResultArrayName("resArray")
aa = vtk.vtkAssignAttribute()
aa.SetInputConnection(calc.GetOutputPort())
aa.Assign("resArray", "SCALARS", "POINT_DATA")
aa.Update()
rf2 = vtk.vtkRearrangeFields()
rf2.SetInputConnection(aa.GetOutputPort())
rf2.AddOperation("COPY", "SCALARS", "POINT_DATA", "DATA_OBJECT")
# construct pipeline for original population
popSplatter = vtk.vtkGaussianSplatter()
popSplatter.SetInputConnection(rf2.GetOutputPort())
popSplatter.SetSampleDimensions(50, 50, 50)
popSplatter.SetRadius(0.05)
popSplatter.ScalarWarpingOff()
popSurface = vtk.vtkContourFilter()
popSurface.SetInputConnection(popSplatter.GetOutputPort())
popSurface.SetValue(0, 0.01)
popMapper = vtk.vtkPolyDataMapper()
popMapper.SetInputConnection(popSurface.GetOutputPort())
popMapper.ScalarVisibilityOff()
popMapper.ImmediateModeRenderingOn()
popActor = vtk.vtkActor()
popActor.SetMapper(popMapper)
popActor.GetProperty().SetOpacity(0.3)
popActor.GetProperty().SetColor(.9, .9, .9)
# construct pipeline for delinquent population
lateSplatter = vtk.vtkGaussianSplatter()
lateSplatter.SetInputConnection(aa.GetOutputPort())
lateSplatter.SetSampleDimensions(50, 50, 50)
lateSplatter.SetRadius(0.05)
lateSplatter.SetScaleFactor(0.05)
lateSurface = vtk.vtkContourFilter()
lateSurface.SetInputConnection(lateSplatter.GetOutputPort())
lateSurface.SetValue(0, 0.01)
lateMapper = vtk.vtkPolyDataMapper()
lateMapper.SetInputConnection(lateSurface.GetOutputPort())
lateMapper.ScalarVisibilityOff()
lateActor = vtk.vtkActor()
lateActor.SetMapper(lateMapper)
lateActor.GetProperty().SetColor(1.0, 0.0, 0.0)
# create axes
popSplatter.Update()
bounds = popSplatter.GetOutput().GetBounds()
axes = vtk.vtkAxes()
axes.SetOrigin(bounds[0], bounds[2], bounds[4])
axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(axes.GetScaleFactor() / 25.0)
axesTubes.SetNumberOfSides(6)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# label the axes
XText = vtk.vtkVectorText()
XText.SetText(xAxis)
XTextMapper = vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor = vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(0.02, .02, .02)
XActor.SetPosition(0.35, -0.05, -0.05)
XActor.GetProperty().SetColor(0, 0, 0)
YText = vtk.vtkVectorText()
YText.SetText(yAxis)
YTextMapper = vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor = vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(0.02, .02, .02)
YActor.SetPosition(-0.05, 0.35, -0.05)
YActor.GetProperty().SetColor(0, 0, 0)
ZText = vtk.vtkVectorText()
ZText.SetText(zAxis)
ZTextMapper = vtk.vtkPolyDataMapper()
ZTextMapper.SetInputConnection(ZText.GetOutputPort())
ZActor = vtk.vtkFollower()
ZActor.SetMapper(ZTextMapper)
ZActor.SetScale(0.02, .02, .02)
ZActor.SetPosition(-0.05, -0.05, 0.35)
ZActor.GetProperty().SetColor(0, 0, 0)
# Graphics stuff
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetWindowName("vtk(-, Field.Data")
renWin.SetSize(300, 300)
# Add the actors to the renderer, set the background and size
#
ren.AddActor(axesActor)
ren.AddActor(lateActor)
ren.AddActor(XActor)
ren.AddActor(YActor)
ren.AddActor(ZActor)
ren.AddActor(popActor) #it's last because its translucent)
ren.SetBackground(1, 1, 1)
camera = vtk.vtkCamera()
camera.SetClippingRange(.274, 13.72)
camera.SetFocalPoint(0.433816, 0.333131, 0.449)
camera.SetPosition(-1.96987, 1.15145, 1.49053)
camera.SetViewUp(0.378927, 0.911821, 0.158107)
ren.SetActiveCamera(camera)
XActor.SetCamera(camera)
YActor.SetCamera(camera)
ZActor.SetCamera(camera)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
renWin.Render()
img_file = "financialField3.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
def __init__(self,
name='',
create_interactor=True,
style=VisualizerInteractionStyle()):
self._interactor = vtk.vtkRenderWindowInteractor()
self._update_fps = _FPSCallback(self)
self._stopped = False
self._timer_id = 0
self._exit_main_loop_timer_callback = None
self._exit_callback = None
self._rens = vtk.RendererCollection()
self._win = None
self._style = style
self._cloud_actor_map = dict()
self._shape_actor_map = dict()
self._coordinate_actor_map = dict()
self._camera_set = False
self._camera_file_loaded = False
# Create a Renderer
ren = vtk.vtkRenderer()
ren.AddObserver(vtk.vtkCommand.EndEvent, self._update_fps)
self._rens.AddItem(ren)
# FPS callback
txt = vtk.vtkTextActor()
self._update_fps.actor = txt
self._update_fps.pcl_visualizer = self
self._update_fps.decimated = False
ren.AddActor(txt)
txt.SetInput('0 FPS')
# Create a RendererWindow
self._win = vtk.vtkRendererWindow()
self._win.SetWindowName(name)
# Get screen size
scr_size_x, scr_size_y = self._win.GetScreenSize()
# Set the window size as 1/2 of the screen size
self._win.SetSize(scr_size_x / 2, scr_size_y / 2)
# By default, don't use vertex buffer objects
self._use_vbox = False
# Add all renderers to the window
self._rens.InitTraversal()
while True:
renderer = self._rens.GetNextItem()
if renderer is None:
break
self._win.AddRenderer(renderer)
# Set renderer window in case no interactor is created
self._style.render_window = self._win
# Create the interactor style
self._style.initialize()
self._style.renderer_collection = self._rens
self._style.cloud_actor_map = self._cloud_actor_map
self._style.shape_actor_map = self._shape_actor_map
self._style.user_timers_on()
self._style.use_vbos = self._use_vbos
if create_interactor:
self.create_interactor()
self._win.SetWindowName(name) # XXX duplicate?
__author__ = 'Su Lei' import vtk from vtk.util.colors import tomato cylinder = vtk.vtkCylinderSource() cylinder.SetResolution(8) cylinderMapper = vtk.vtkPolyDataMapper() cylinderMapper.SetInputConnection(cylinder.GetOutputPort()) cylinderActor = vtk.vtkActor() cylinderActor.SetMapper(cylinderMapper) cylinderActor.GetProperty().SetColor(tomato) cylinderActor.RotateX(30.0) cylinderActor.RotateY(-45.0) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.AddActor(cylinderActor) ren.SetBackground(0.1, 0.2, 0.4) renWin.SetSize(200, 200) iren.Initialize() ren.ResetCamera() ren.GetActiveCamera().Zoom(1.5) renWin.Render() iren.Start()
def main():
colors = vtk.vtkNamedColors()
source = vtk.vtkSphereSource()
source.SetPhiResolution(31)
source.SetThetaResolution(31)
source.Update()
bounds = source.GetOutput().GetBounds()
print("Bounds: " + str(bounds[0]) + ", " + str(bounds[2]) + ", " +
str(bounds[3]) + ", " + str(bounds[1]) + ", " + str(bounds[3]) +
", " + str(bounds[5]))
center = source.GetOutput().GetCenter()
print("Center: " + str(center[0]) + ", " + str(center[1]) + ", " +
str(center[2]))
# Create the axis actor
axis = vtk.vtkAxisActor()
axis.SetPoint1(-1.1, 0.0, 0.0)
axis.SetPoint2(1.1, 0.0, 0.0)
axis.SetTickLocationToBoth()
axis.SetAxisTypeToX()
axis.SetTitle("A Sphere")
axis.SetTitleScale(0.2)
axis.TitleVisibilityOn()
axis.SetMajorTickSize(0.05)
axis.SetMinorTickSize(1)
axis.DrawGridlinesOff()
axis.GetTitleTextProperty().SetColor(colors.GetColor3d("banana"))
axis.GetLabelTextProperty().SetColor(colors.GetColor3d("orange"))
labels = vtk.vtkStringArray()
labels.SetNumberOfTuples(1)
labels.SetValue(0, "x Axis")
axis.SetLabels(labels)
axis.SetLabelScale(.1)
axis.MinorTicksVisibleOn()
axis.SetDeltaMajor(0, .1)
axis.SetCalculateTitleOffset(0)
axis.SetCalculateLabelOffset(0)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(source.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# actor.GetProperty().SetDiffuseColor(colors.GetColor4d("Tomato"))
actor.GetProperty().SetDiffuseColor(colors.GetColor3d("Tomato"))
# Create the RenderWindow, Renderer and both Actors
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetWindowName("AxisActor")
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
axis.SetCamera(renderer.GetActiveCamera())
renderer.AddActor(actor)
renderer.AddActor(axis)
# renderer.SetBackground(colors.GetColor4d("SlateGray"))
renderer.SetBackground(colors.GetColor3d("SlateGray"))
renderWindow.SetSize(640, 480)
renderer.ResetCamera()
renderer.ResetCameraClippingRange()
# render the image
renderWindow.Render()
interactor.Initialize()
interactor.Start()
def create_render_window(actors, callbacks, **kwargs):
""" Creates VTK render window with an interactor.
:param actors: list of VTK actors
:type actors: list, tuple
:param callbacks: callback functions for registering custom events
:type callbacks: dict
"""
# Get keyword arguments
figure_size = kwargs.get('figure_size', (800, 600))
camera_position = kwargs.get('camera_position', (0, 0, 100))
# Find camera focal point
center_points = []
for actor in actors:
center_points.append(actor.GetCenter())
camera_focal_point = linalg.vector_mean(*center_points)
# Create camera
camera = vtk.vtkCamera()
camera.SetPosition(*camera_position)
camera.SetFocalPoint(*camera_focal_point)
# Create renderer
renderer = vtk.vtkRenderer()
renderer.SetActiveCamera(camera)
renderer.SetBackground(1.0, 1.0, 1.0)
# Add actors to the scene
for actor in actors:
renderer.AddActor(actor)
# Render window
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window.SetSize(*figure_size)
# Render window interactor
window_interactor = vtk.vtkRenderWindowInteractor()
window_interactor.SetRenderWindow(render_window)
# Add event observers
for cb in callbacks:
window_interactor.AddObserver(
cb, callbacks[cb][0],
callbacks[cb][1]) # cb name, cb function ref, cb priority
# Render actors
render_window.Render()
# Set window name after render() is called
render_window.SetWindowName("geomdl")
# Use trackball camera
interactor_style = vtk.vtkInteractorStyleTrackballCamera()
window_interactor.SetInteractorStyle(interactor_style)
# Start interactor
window_interactor.Start()
# Return window interactor instance
return window_interactor
def main():
xyzFile, qFile = get_program_parameters()
colors = vtk.vtkNamedColors()
# Create pipeline. Read structured grid data.
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(xyzFile)
pl3d.SetQFileName(qFile)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
pl3dOutput = pl3d.GetOutput().GetBlock(0)
# A convenience
extract = vtk.vtkExtractGrid()
extract.SetVOI(1, 55, -1000, 1000, -1000, 1000)
extract.SetInputData(pl3dOutput)
# The plane is used to do the cutting
plane = vtk.vtkPlane()
plane.SetOrigin(0, 4, 2)
plane.SetNormal(0, 1, 0)
# compositing.
cutter = vtk.vtkCutter()
cutter.SetInputConnection(extract.GetOutputPort())
cutter.SetCutFunction(plane)
cutter.GenerateCutScalarsOff()
cutter.SetSortByToSortByCell()
clut = vtk.vtkLookupTable()
clut.SetHueRange(0, 0.67)
clut.Build()
cutterMapper = vtk.vtkPolyDataMapper()
cutterMapper.SetInputConnection(cutter.GetOutputPort())
cutterMapper.SetScalarRange(0.18, 0.7)
cutterMapper.SetLookupTable(clut)
cut = vtk.vtkActor()
cut.SetMapper(cutterMapper)
# Add in some surface geometry for interest.
iso = vtk.vtkContourFilter()
iso.SetInputData(pl3dOutput)
iso.SetValue(0, .22)
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(iso.GetOutputPort())
normals.SetFeatureAngle(60)
isoMapper = vtk.vtkPolyDataMapper()
isoMapper.SetInputConnection(normals.GetOutputPort())
isoMapper.ScalarVisibilityOff()
isoActor = vtk.vtkActor()
isoActor.SetMapper(isoMapper)
isoActor.GetProperty().SetDiffuseColor(colors.GetColor3d("Tomato"))
isoActor.GetProperty().SetSpecularColor(colors.GetColor3d("White"))
isoActor.GetProperty().SetDiffuse(0.8)
isoActor.GetProperty().SetSpecular(0.5)
isoActor.GetProperty().SetSpecularPower(30)
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3dOutput)
outlineStrip = vtk.vtkStripper()
outlineStrip.SetInputConnection(outline.GetOutputPort())
outlineTubes = vtk.vtkTubeFilter()
outlineTubes.SetInputConnection(outline.GetOutputPort())
outlineTubes.SetInputConnection(outlineStrip.GetOutputPort())
outlineTubes.SetRadius(0.1)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outlineTubes.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
# Create the RenderWindow, Renderer and Interactor.
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size.
ren1.AddActor(outlineActor)
outlineActor.GetProperty().SetColor(colors.GetColor3d("Banana"))
ren1.AddActor(isoActor)
isoActor.VisibilityOn()
ren1.AddActor(cut)
n = 20
opacity = 1.0 / float(n) * 5.0
cut.GetProperty().SetOpacity(1)
ren1.SetBackground(colors.GetColor3d("SlateGray"))
renWin.SetSize(640, 480)
ren1.GetActiveCamera().SetClippingRange(3.95297, 50)
ren1.GetActiveCamera().SetFocalPoint(9.71821, 0.458166, 29.3999)
ren1.GetActiveCamera().SetPosition(2.7439, -37.3196, 38.7167)
ren1.GetActiveCamera().ComputeViewPlaneNormal()
ren1.GetActiveCamera().SetViewUp(-0.16123, 0.264271, 0.950876)
# Cut: generates n cut planes normal to camera's view plane.
plane.SetNormal(ren1.GetActiveCamera().GetViewPlaneNormal())
plane.SetOrigin(ren1.GetActiveCamera().GetFocalPoint())
cutter.GenerateValues(n, -5, 5)
clut.SetAlphaRange(opacity, opacity)
renWin.Render()
iren.Start()
appendF.AddInputConnection(ps3.GetOutputPort()) appendF.AddInputConnection(ps4.GetOutputPort()) appendF.AddInputConnection(ps5.GetOutputPort()) appendF.AddInputConnection(ps6.GetOutputPort()) #appendF.AddInputConnection(ps7.GetOutputPort()) appendF.AddInputConnection(ps8.GetOutputPort()) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(appendF.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) # Create the RenderWindow, Renderer and Interactive Renderer # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren1.AddActor(actor) ren1.SetBackground(0, 0, 0) renWin.SetSize(300, 300) renWin.Render() ren1.GetActiveCamera().SetPosition(1, 1, 1) ren1.ResetCamera() renWin.Render()
def show_3d(L_box, L_coordinates):
nums = len(L_box)
edge_max = max([max(L_box[i]) for i in range(len(L_box))
]) if max([max(L_box[i])
for i in range(len(L_box))]) > 0 else 1
# 预设参数
gap = 0.01
CL_p = 1.1
CW_p = nums + gap * (nums - 1)
CH_p = 0.01
gap = 0.25
x_re = 0
y_re = 0
z_re = 0
#渲染及渲染窗口，并根据捕捉的鼠标事件执行相应的操作
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(1200, 600)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
"""画容器"""
for i in range(nums):
cube = vtk.vtkCubeSource()
cube.SetXLength(L_box[i][0] / edge_max)
cube.SetYLength(L_box[i][1] / edge_max)
cube.SetZLength(L_box[i][2] / edge_max)
cube.Update()
translation = vtkTransform()
translation.Translate(
L_box[i][0] / edge_max / 2.0 + x_re,
L_box[i][1] / edge_max / 2.0 + i + gap * i + y_re,
L_box[i][2] / edge_max / 2.0 + z_re)
transformFilter = vtkTransformPolyDataFilter()
transformFilter.SetInputConnection(cube.GetOutputPort())
transformFilter.SetTransform(translation)
transformFilter.Update()
transformedMapper = vtkPolyDataMapper()
transformedMapper.SetInputConnection(transformFilter.GetOutputPort())
transformedActor = vtkActor()
transformedActor.SetMapper(transformedMapper)
transformedActor.GetProperty().SetColor((1, 1, 1))
transformedActor.GetProperty().SetRepresentationToWireframe()
ren.AddActor(transformedActor)
"""画托盘"""
cube = vtk.vtkCubeSource()
cube.SetXLength(CL_p)
cube.SetYLength(CW_p)
cube.SetZLength(CH_p)
cube.Update()
translation = vtkTransform()
translation.Translate(CL_p / 2.0 + x_re, CW_p / 2.0 + y_re,
-CH_p / 2.0 + z_re)
transformFilter = vtkTransformPolyDataFilter()
transformFilter.SetInputConnection(cube.GetOutputPort())
transformFilter.SetTransform(translation)
transformFilter.Update()
transformedMapper = vtkPolyDataMapper()
transformedMapper.SetInputConnection(transformFilter.GetOutputPort())
transformedActor = vtkActor()
transformedActor.SetMapper(transformedMapper)
transformedActor.GetProperty().SetColor((0.2, 0.4, 0.8))
ren.AddActor(transformedActor)
for i in range(len(L_coordinates)):
for j in range(len(L_coordinates[i])):
Addcube_3d(ren, L_coordinates[i][j], edge_max, x_re,
i + gap * i + y_re, z_re)
camera = vtk.vtkCamera()
camera.SetViewUp(0, 0, 1) # 设置相机的“上”方向
camera.SetPosition(10, 10, 1) # 位置：世界坐标系，设置相机位置
camera.SetFocalPoint(0, 8, 0)
camera.ComputeViewPlaneNormal()
# camera.SetPosition(5, -0.5, 2)
ren.SetActiveCamera(camera)
iren.Initialize()
renWin.Render()
# 保存过程
png_save(renWin, "result_D3.png")
# 展示
iren.Start()
import random
import vtk
a = []
for i in xrange(5):
b = []
print id(b)
for j in xrange(3):
b.append(random.randint(1, 100))
a.append(b)
print id(a[i])
print a
r = vtk.vtkRenderer()
print r.GetNumberOfPropsRendered()
Actor4a.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784) map4b = vtk.vtkPolyDataMapper() map4b.SetInputData(procrustes3.GetOutput().GetBlock(1)) Actor4b = vtk.vtkActor() Actor4b.SetMapper(map4b) Actor4b.GetProperty().SetDiffuseColor(0.3882, 1.0000, 0.2784) map4c = vtk.vtkPolyDataMapper() map4c.SetInputData(procrustes3.GetOutput().GetBlock(2)) Actor4c = vtk.vtkActor() Actor4c.SetMapper(map4c) Actor4c.GetProperty().SetDiffuseColor(0.3882, 0.2784, 1.0000) # Create the RenderWindow and its four Renderers ren = vtk.vtkRenderer() ren2 = vtk.vtkRenderer() ren3 = vtk.vtkRenderer() ren4 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.AddRenderer(ren2) renWin.AddRenderer(ren3) renWin.AddRenderer(ren4) renWin.SetSize(400, 100) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add the actors to the renderer ren.AddActor(Actor1a) ren.AddActor(Actor1b)
def testGlyphs(self):
"""Test if texturing of the glyphs works correctly."""
# The Glyph
cs = vtk.vtkCubeSource()
cs.SetXLength(2.0)
cs.SetYLength(1.0)
cs.SetZLength(0.5)
# Create input point data.
pts = vtk.vtkPoints()
pts.InsertPoint(0, (1, 1, 1))
pts.InsertPoint(1, (0, 0, 0))
pts.InsertPoint(2, (-1, -1, -1))
polys = vtk.vtkCellArray()
polys.InsertNextCell(1)
polys.InsertCellPoint(0)
polys.InsertNextCell(1)
polys.InsertCellPoint(1)
polys.InsertNextCell(1)
polys.InsertCellPoint(2)
pd = vtk.vtkPolyData()
pd.SetPoints(pts)
pd.SetPolys(polys)
# Orient the glyphs as per vectors.
vec = vtk.vtkFloatArray()
vec.SetNumberOfComponents(3)
vec.InsertTuple3(0, 1, 0, 0)
vec.InsertTuple3(1, 0, 1, 0)
vec.InsertTuple3(2, 0, 0, 1)
pd.GetPointData().SetVectors(vec)
# The glyph filter.
g = vtk.vtkGlyph3D()
g.SetScaleModeToDataScalingOff()
g.SetVectorModeToUseVector()
g.SetInputData(pd)
g.SetSourceConnection(cs.GetOutputPort())
m = vtk.vtkPolyDataMapper()
m.SetInputConnection(g.GetOutputPort())
a = vtk.vtkActor()
a.SetMapper(m)
# The texture.
img_file = os.path.join(Testing.VTK_DATA_ROOT, "Data", "masonry.bmp")
img_r = vtk.vtkBMPReader()
img_r.SetFileName(img_file)
t = vtk.vtkTexture()
t.SetInputConnection(img_r.GetOutputPort())
t.InterpolateOn()
a.SetTexture(t)
# Renderer, RenderWindow etc.
ren = vtk.vtkRenderer()
ren.SetBackground(0.5, 0.5, 0.5)
ren.AddActor(a)
ren.ResetCamera()
cam = ren.GetActiveCamera()
cam.Azimuth(-90)
cam.Zoom(1.4)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
rwi = vtk.vtkRenderWindowInteractor()
rwi.SetRenderWindow(renWin)
rwi.Initialize()
rwi.Render()
def main():
colors = vtk.vtkNamedColors()
lineColor = colors.GetColor3d("peacock")
modelColor = colors.GetColor3d("silver")
backgroundColor = colors.GetColor3d("wheat")
modelSource = vtk.vtkSphereSource()
plane = vtk.vtkPlane()
cutter = vtk.vtkCutter()
cutter.SetInputConnection(modelSource.GetOutputPort())
cutter.SetCutFunction(plane)
cutter.GenerateValues(10, -.5, .5)
modelMapper = vtk.vtkPolyDataMapper()
modelMapper.SetInputConnection(modelSource.GetOutputPort())
model = vtk.vtkActor()
model.SetMapper(modelMapper)
model.GetProperty().SetDiffuseColor(modelColor)
model.GetProperty().SetInterpolationToFlat()
stripper = vtk.vtkStripper()
stripper.SetInputConnection(cutter.GetOutputPort())
stripper.JoinContiguousSegmentsOn()
linesMapper = vtk.vtkPolyDataMapper()
linesMapper.SetInputConnection(stripper.GetOutputPort())
lines = vtk.vtkActor()
lines.SetMapper(linesMapper)
lines.GetProperty().SetDiffuseColor(lineColor)
lines.GetProperty().SetLineWidth(3.)
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(640, 480)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
# Add the actors to the renderer.
renderer.AddActor(model)
renderer.AddActor(lines)
renderer.SetBackground(backgroundColor)
# This starts the event loop and as a side effect causes an
# initial render.
renderWindow.Render()
interactor.Start()
# Extract the lines from the polydata.
numberOfLines = cutter.GetOutput().GetNumberOfLines()
print("-----------Lines without using vtkStripper")
print("There are {0} lines in the polydata".format(numberOfLines))
numberOfLines = stripper.GetOutput().GetNumberOfLines()
points = stripper.GetOutput().GetPoints()
cells = stripper.GetOutput().GetLines()
cells.InitTraversal()
print("-----------Lines using vtkStripper")
print("There are {0} lines in the polydata".format(numberOfLines))
indices = vtk.vtkIdList()
lineCount = 0
while cells.GetNextCell(indices):
print("Line {0}:".format(lineCount))
for i in range(indices.GetNumberOfIds()):
point = points.GetPoint(indices.GetId(i))
print("\t({0:0.6f} ,{1:0.6f}, {2:0.6f})".format(
point[0], point[1], point[2]))
lineCount += 1
def main():
fileName = get_program_parameters()
colors = vtk.vtkNamedColors()
# Create the RenderWindow, Renderer and Interactor.
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Create the pipeline.
#
reader = vtk.vtkMetaImageReader()
reader.SetFileName(fileName)
reader.Update()
extractVOI = vtk.vtkExtractVOI()
extractVOI.SetInputConnection(reader.GetOutputPort())
extractVOI.SetVOI(0, 255, 0, 255, 45, 45)
iso = vtk.vtkContourFilter()
iso.SetInputConnection(extractVOI.GetOutputPort())
iso.GenerateValues(12, 500, 1150)
isoMapper = vtk.vtkPolyDataMapper()
isoMapper.SetInputConnection(iso.GetOutputPort())
isoMapper.ScalarVisibilityOff()
isoActor = vtk.vtkActor()
isoActor.SetMapper(isoMapper)
isoActor.GetProperty().SetColor(colors.GetColor3d('Wheat'))
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(extractVOI.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
# Add the actors to the renderer, set the background and size.
#
ren1.AddActor(outlineActor)
ren1.AddActor(isoActor)
ren1.SetBackground(colors.GetColor3d('SlateGray'))
ren1.ResetCamera()
ren1.GetActiveCamera().Dolly(1.5)
ren1.ResetCameraClippingRange()
renWin.SetSize(640, 640)
renWin.SetWindowName('HeadSlice')
renWin.Render()
iren.Start()
def __init__(self, parent=None, originatingWidget=None):
QtGui.QFrame.__init__(self, parent)
# print '\n\n\n\n\n CREATING NEW GRAPHICS FRAME WIDGET ',self
# self.allowSaveLayout = True
self.is_screenshot_widget = False
self.qvtkWidget = QVTKRenderWindowInteractor(self) # a QWidget
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
# MDIFIX
self.parentWidget = originatingWidget
# self.parentWidget = parent
self.plane = None
self.planePos = None
self.lineEdit = QtGui.QLineEdit()
self.__initCrossSectionActions()
self.cstb = self.initCrossSectionToolbar()
layout = QtGui.QBoxLayout(QtGui.QBoxLayout.TopToBottom)
layout.addWidget(self.cstb)
layout.addWidget(self.qvtkWidget)
self.setLayout(layout)
self.setMinimumSize(100, 100) #needs to be defined to resize smaller than 400x400
self.resize(600, 600)
self.qvtkWidget.Initialize()
self.qvtkWidget.Start()
self.ren = vtk.vtkRenderer()
self.renWin = self.qvtkWidget.GetRenderWindow()
self.renWin.AddRenderer(self.ren)
# print MODULENAME,"GraphicsFrameWidget():__init__: parent=",parent
# some objects below create cyclic dependencies - the widget will not free its memory unless in the close event e.g. self.drawModel2D gets set to None
# # # from weakref import ref
# # # self_weakref=ref(self)
# # # self.drawModel2D = MVCDrawModel2D(self_weakref,parent)
# # # self.draw2D = MVCDrawView2D(self.drawModel2D,self_weakref,parent)
# # # self.drawModel3D = MVCDrawModel3D(self_weakref,parent)
# # # self.draw3D = MVCDrawView3D(self.drawModel3D,self_weakref,parent)
# MDIFIX
self.drawModel2D = MVCDrawModel2D(self, self.parentWidget)
self.draw2D = MVCDrawView2D(self.drawModel2D, self, self.parentWidget)
self.drawModel3D = MVCDrawModel3D(self, self.parentWidget)
self.draw3D = MVCDrawView3D(self.drawModel3D, self, self.parentWidget)
# self.drawModel2D = MVCDrawModel2D(self,parent)
# self.draw2D = MVCDrawView2D(self.drawModel2D,self,parent)
#
# self.drawModel3D = MVCDrawModel3D(self,parent)
# self.draw3D = MVCDrawView3D(self.drawModel3D,self,parent)
# self.draw2D=Draw2D(self,parent)
# self.draw3D=Draw3D(self,parent)
self.camera3D = self.ren.MakeCamera()
self.camera2D = self.ren.GetActiveCamera()
self.ren.SetActiveCamera(self.camera2D)
self.currentDrawingObject = self.draw2D
self.draw3DFlag = False
self.usedDraw3DFlag = False
# self.getattrFcn=self.getattrDraw2D
# rwh test
# print MODULENAME,' self.parentWidget.playerSettingsFileName= ',self.parentWidget.playerSettingsFileName
if self.parentWidget.playerSettingsFileName:
# does not work on Windows with Python 2.5
# with open(self.parentWidget.playerSettingsFileName, 'r') as f:
f=None
try:
f=open(self.parentWidget.playerSettingsFileName, 'r')
while True:
l = f.readline()
if l == "": break
v = l.split()
print v
if string.find(v[0], 'CameraPosition') > -1:
self.camera3D.SetPosition(float(v[1]), float(v[2]), float(v[3]))
elif string.find(v[0], 'CameraFocalPoint') > -1:
self.camera3D.SetFocalPoint(float(v[1]), float(v[2]), float(v[3]))
elif string.find(v[0], 'CameraViewUp') > -1:
self.camera3D.SetViewUp(float(v[1]), float(v[2]), float(v[3]))
# elif string.find(v[0], 'ViewPlaneNormal') > -1: # deprecated
# self.camera3D.SetViewPlaneNormal(float(v[1]), float(v[2]), float(v[3]))
elif string.find(v[0], 'CameraClippingRange') > -1:
self.camera3D.SetClippingRange(float(v[1]), float(v[2]))
elif string.find(v[0], 'CameraDistance') > -1:
print 'SetDistance = ',float(v[1])
self.camera3D.SetDistance(float(v[1]))
elif string.find(v[0], 'ViewAngle') > -1:
self.camera3D.SetViewAngle(float(v[1]))
except IOError:
pass
self.screenshotWindowFlag=False
def contour_movie(name):
gridreader = vtk.vtkXMLStructuredGridReader()
#gridreader=vtk.vtkImageReader()
gridreader.SetFileName(name)
gridreader.Update()
grid = gridreader.GetOutput()
data = grid.GetPointData()
points = grid.GetPoints()
dims = grid.GetDimensions()
#velocity=data.GetArray("v")
#phase=data.GetArray("phi")
#print phase
velocity = data.GetArray("Velocity")
phase = data.GetArray("Phase")
#data.SetActiveScalars("Phase")
phase_image = vtk.vtkImageData()
phase_image.SetSpacing(1.0, 1.0, 1.0)
phase_image.SetOrigin(0.0, 0.0, 0.0)
phase_image.SetDimensions(dims[0], dims[1], dims[2])
phase_image.GetPointData().SetScalars(phase)
phase_image.GetPointData().SetVectors(velocity)
outline = vtk.vtkOutlineFilter()
outline.SetInput(phase_image)
outlineMapper = vtk.vtkDataSetMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
extract = vtk.vtkExtractVOI()
extract.SetInput(phase_image)
extract.SetVOI(0, 0, 0, dims[1] - 1, 0, dims[2] - 1)
extract.Update()
contour = vtk.vtkContourFilter()
#contour.SetInputConnection(phase_image.GetOutputPort())
contour.SetInput(phase_image)
contour.SetValue(0, 0.0)
contour.Update()
contourMapper = vtk.vtkPolyDataMapper()
#contourMapper.SetScalarRange(phase.GetRange())
contourMapper.SetInputConnection(contour.GetOutputPort())
contourActor = vtk.vtkActor()
contourActor.SetMapper(contourMapper)
ren = vtk.vtkRenderer()
ren.AddActor(contourActor)
ren.AddActor(outlineActor)
ren.SetBackground(0.1, 0.2, 0.4)
#ren.SetColor(0.1,0.5,0.2)
#ren.SetViewport(0, 0, .3, 1)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(500, 500)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.Initialize()
renWin.Render()
numbers = 720
delta = 2.0 * math.pi / numbers
cam = ren.GetActiveCamera()
#cam.SetPosition(300,0,750)
renWin.Render()
xinit, yinit, zinit = cam.GetPosition()
radius = math.sqrt(xinit**2 + yinit**2 + zinit**2)
print xinit, yinit, zinit
cam.SetViewUp(1.00000, 0.0000001, 0.00000)
cam.Zoom(3)
for counter, alpha in enumerate(numpy.arange(0, 2.0 * math.pi, delta)):
cam.Azimuth(delta * 180.0 / math.pi)
renWin.Render()
im_filter = vtk.vtkWindowToImageFilter()
im_filter.SetInput(renWin)
writer = vtk.vtkJPEGWriter()
file_name = "tmp/contour" + str(0) * (3 - len(str(counter))) + str(
counter) + ".jpg"
writer.SetFileName(file_name)
writer.SetInput(im_filter.GetOutput())
writer.Write()
iren.Start()
def Main():
global ren, sliders, planes, planeCuts, origins
# Create the RenderWindow, Renderer and both Actors
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.RemoveObservers('RightButtonPressEvent')
iren.AddObserver('RightButtonPressEvent', print_camera_settings, 1.0)
iren.AddObserver('RightButtonPressEvent', after_print_camera_settings, -1.0)
print "data: %s %s" % (sys.argv[1], sys.argv[2])
cfdreader = vtk.vtkStructuredPointsReader()
cfdreader.SetFileName(sys.argv[1])
# setup wing data
wingReader = vtk.vtkUnstructuredGridReader()
wingReader.SetFileName(sys.argv[2])
wingReader.Update()
wingMapper = vtk.vtkDataSetMapper()
wingMapper.SetInputConnection(wingReader.GetOutputPort())
wingActor = vtk.vtkActor()
wingActor.SetMapper(wingMapper)
wingActor.GetProperty().SetColor(.4, .4, .4)
planes = [
vtk.vtkPlane(),
vtk.vtkPlane(),
vtk.vtkPlane()
]
planeCuts = [
vtk.vtkCutter(),
vtk.vtkCutter(),
vtk.vtkCutter()
]
normals = [
[1, 0, 0],
[1, 0, 0],
[1, 0, 0]
]
origins = [
[20, 0, 0],
[100, 0, 0],
[190, 0, 0]
]
sliders = [
vtk.vtkSliderRepresentation2D(),
vtk.vtkSliderRepresentation2D(),
vtk.vtkSliderRepresentation2D()
]
sliderWidgets = [
vtk.vtkSliderWidget(),
vtk.vtkSliderWidget(),
vtk.vtkSliderWidget()
]
bPlaneToActor = [True, True, True]
bWingToActor = True
datamin = 0
datamax = 230
lut = vtk.vtkColorTransferFunction()
lut.SetColorSpaceToHSV()
lut.AddHSVPoint(datamin, 0, 1, 1)
dis = (datamax - datamin) / 7
for i in range(0, 8):
lut.AddHSVPoint(datamin + dis * i, 0.1 * i, 1, 1)
for i in range(0, len(planes)):
planes[i].SetOrigin(origins[i])
planes[i].SetNormal(normals[i])
planeCuts[i].SetInputConnection(cfdreader.GetOutputPort())
planeCuts[i].SetCutFunction(planes[i])
arrowSource = vtk.vtkArrowSource()
arrowSource.SetTipLength(0.3)
arrowSource.SetShaftRadius(0.001)
vectorGlyph = vtk.vtkGlyph3D()
vectorGlyph.SetInputConnection(0, planeCuts[i].GetOutputPort())
vectorGlyph.SetInputConnection(1, arrowSource.GetOutputPort())
vectorGlyph.ScalingOn()
vectorGlyph.SetScaleModeToScaleByVector()
vectorGlyph.SetScaleFactor(0.35)
vectorGlyph.OrientOn()
vectorGlyph.ClampingOff()
vectorGlyph.SetVectorModeToUseVector()
vectorGlyph.SetIndexModeToOff()
cutMapper = vtk.vtkDataSetMapper()
cutMapper.SetLookupTable(lut)
cutMapper.SetScalarRange(vectorGlyph.GetRange())
cutMapper.SetInputConnection(vectorGlyph.GetOutputPort())
cutActor = vtk.vtkActor()
cutActor.SetMapper(cutMapper)
cutActor.GetProperty().SetOpacity(0.4);
cutActor.GetProperty().SetColor(0, 1, 0)
if bPlaneToActor[i]:
ren.AddActor(cutActor)
sliders[i].SetMinimumValue(-50)
sliders[i].SetMaximumValue(230)
sliders[i].SetValue(origins[i][0])
sliders[i].SetTitleText("x-axis of plane %d" % i)
sliders[i].GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
sliders[i].GetPoint1Coordinate().SetValue(0.0, 1 - 0.1 * (i + 1))
sliders[i].GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
sliders[i].GetPoint2Coordinate().SetValue(0.2, 1 - 0.1 * (i + 1))
sliders[i].SetSliderLength(0.02)
sliders[i].SetSliderWidth(0.03)
sliders[i].SetEndCapLength(0.01)
sliders[i].SetEndCapWidth(0.03)
sliders[i].SetTubeWidth(0.005)
sliders[i].SetLabelFormat("%3.0lf")
sliders[i].SetTitleHeight(0.02)
sliders[i].SetLabelHeight(0.02)
sliderWidgets[i].SetInteractor(iren)
sliderWidgets[i].SetRepresentation(sliders[i])
sliderWidgets[i].KeyPressActivationOff()
sliderWidgets[i].SetAnimationModeToAnimate()
sliderWidgets[i].SetEnabled(False)
sliderWidgets[i].AddObserver("InteractionEvent", sliderHandler)
if bWingToActor:
ren.AddActor(wingActor)
ren.SetBackground(0, 0, 0)
renWin.SetSize(1600, 900)
ren.ResetCamera()
ren.GetActiveCamera().SetClippingRange(203.2899494251721, 731.8103494457274)
ren.GetActiveCamera().SetFocalPoint(118.72183980792761, 0.00012969970703125, 36.469017028808594)
ren.GetActiveCamera().SetPosition(300.86018729049954, -5.765715551063601, 435.4418666873332)
ren.GetActiveCamera().SetViewUp(-0.802117714199773, -0.005112780752923929, 0.5971440630533839)
# Render
iren.Initialize()
renWin.Render()
iren.Start()
def testFreetypeTextMapper(self):
currentFontSize = 16
defaultText = "ABCDEFGHIJKLMnopqrstuvwxyz 0123456789 !@#$%()-=_+{};:,./<>?"
textColor = [246, 255, 11]
bgColor = [56, 56, 154]
for i in range(0, len(textColor)):
textColor[i] /= 255.0
bgColor[i] /= 255.0
renWin = vtk.vtkRenderWindow()
renWin.SetSize(790, 351)
ren = vtk.vtkRenderer()
ren.SetBackground(bgColor)
renWin.AddRenderer(ren)
families = ["Arial", "Courier", "Times"]
attributes = [[0, 0, 0], [0, 0, 1], [1, 0, 0], [0, 1, 0],
[1, 1, 0]] # bold, italic, shadow
def SetAttributesText(attrib):
""" Expects a list of attributes of size 3, returns a string """
s = ""
if attrib[0] != 0:
s += "b"
if attrib[1] != 0:
s += "i"
if attrib[2] != 0:
s += "s"
return ','.join(list(s))
mapper = dict()
actor = dict()
pos = 0
for i, family in enumerate(families):
for j, attrib in enumerate(attributes):
pos += 1
txt = ""
txtAttrib = SetAttributesText(attrib)
if len(txtAttrib) != 0:
txt = family + " (" + SetAttributesText(
attrib) + "): " + defaultText
else:
txt = family + ": " + defaultText
idx = ''.join(map(str, [i, j]))
mapper.update({idx: vtk.vtkOpenGLFreeTypeTextMapper()})
mapper[idx].SetInput(txt)
tprop = mapper[idx].GetTextProperty()
eval('tprop.SetFontFamilyTo' + family + '()')
tprop.SetColor(textColor)
tprop.SetBold(attrib[0])
tprop.SetItalic(attrib[1])
tprop.SetShadow(attrib[2])
tprop.SetFontSize(currentFontSize)
actor.update({idx: vtk.vtkActor2D()})
actor[idx].SetMapper(mapper[idx])
actor[idx].SetDisplayPosition(10, pos * (currentFontSize + 5))
ren.AddActor(actor[idx])
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
renWin.Render()
img_file = "TestFreetypeTextMapper.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
def __init__(self, vtkWidget=None):
self.ren = vtk.vtkRenderer()
self.window = vtkWidget.GetRenderWindow()
self.window.AddRenderer(self.ren)
self.iren = self.window.GetInteractor()
self.iren.Initialize()#SetRenderWindow(self.window)
# # this is the time for delay the action
# self.fps = 10.0
#
# # Create plane
# planeSource = vtk.vtkPlaneSource();
# planeSource.SetCenter(0.0, 0.0, 0.0)
# planeSource.SetNormal(0.0, 0.0, 1.0)
# planeSource.SetResolution(10,10)
# planeSource.Update()
#
# planeMapper = vtk.vtkPolyDataMapper();
# if(vtk.vtkVersion.GetVTKMajorVersion()<= 5):
# planeMapper.SetInput(planeSource.GetOutput())
# else:
# planeMapper.SetInputData(planeSource.GetOutput())
#
#
# planeActor = vtk.vtkActor()
# planeActor.SetMapper(planeMapper)
#
# self.ren.AddActor(planeActor)
# # Create cone
# coneSource = vtk.vtkConeSource()
# coneSource.SetCenter(0.2,0.0,0.15)
# coneSource.SetHeight(0.3)
# coneSource.SetDirection(0.0,0.0,1.0)
# coneSource.SetAngle(30.0)
# coneSource.SetResolution(36)
# coneSource.Update()
#
# coneMapper = vtk.vtkPolyDataMapper()
# if(vtk.vtkVersion.GetVTKMajorVersion()<= 5):
# coneMapper.SetInput(coneSource.GetOutput())
# else:
# coneMapper.SetInputData(coneSource.GetOutput())
#
# coneActor = vtk.vtkActor()
# coneActor.SetMapper(coneMapper)
# coneActor.GetProperty().SetColor(1.0,1.0,0.0)
# self.ren.AddActor(coneActor)
#
# # Create sphere
# sphereSource = vtk.vtkSphereSource()
# sphereSource.SetCenter(0.3,0.3,0.3)
# sphereSource.SetPhiResolution(10)
# sphereSource.SetThetaResolution(36)
# sphereSource.SetRadius(0.15)
# sphereSource.Update()
#
# sphereMapper = vtk.vtkPolyDataMapper()
# if(vtk.vtkVersion.GetVTKMajorVersion()<= 5):
# sphereMapper.SetInput(sphereSource.GetOutput())
# else:
# sphereMapper.SetInputData(sphereSource.GetOutput())
#
# sphereActor = vtk.vtkActor()
# sphereActor.SetMapper(sphereMapper)
# sphereActor.GetProperty().SetColor(0.0,0.5,1.0)
# self.ren.AddActor(sphereActor)
# Create orientation axes
axes = vtk.vtkAxesActor()
axes.SetShaftTypeToCylinder()
self.orient = vtk.vtkOrientationMarkerWidget()
self.orient.SetOrientationMarker( axes )
#self.orient.SetInteractor( self.iren )
# self.orient.SetViewport( 0.0, 0.0, 0.2, 0.2 )#self.orient.SetViewport( 0.0, 0.0, 0.2, 0.2 )
# self.orient.SetEnabled(1) # Needed to set InteractiveOff
# self.orient.InteractiveOff()
# self.orient.SetEnabled(0)
self.ren.ResetCamera()
def main():
colors = vtk.vtkNamedColors()
# We are going to handle two different sources.
# The first source is a superquadric source.
torus = vtk.vtkSuperquadricSource()
torus.SetCenter(0.0, 0.0, 0.0)
torus.SetScale(1.0, 1.0, 1.0)
torus.SetPhiResolution(64)
torus.SetThetaResolution(64)
torus.SetThetaRoundness(1)
torus.SetThickness(0.5)
torus.SetSize(0.5)
torus.SetToroidal(1)
# Rotate the torus towards the observer (around the x-axis)
torusT = vtk.vtkTransform()
torusT.RotateX(55)
torusTF = vtk.vtkTransformFilter()
torusTF.SetInputConnection(torus.GetOutputPort())
torusTF.SetTransform(torusT)
# The quadric is made of strips, so pass it through a triangle filter as
# the curvature filter only operates on polys
tri = vtk.vtkTriangleFilter()
tri.SetInputConnection(torusTF.GetOutputPort())
# The quadric has nasty discontinuities from the way the edges are generated
# so let's pass it though a CleanPolyDataFilter and merge any points which
# are coincident, or very close
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(tri.GetOutputPort())
cleaner.SetTolerance(0.005)
# The next source will be a parametric function
rh = vtk.vtkParametricRandomHills()
rhFnSrc = vtk.vtkParametricFunctionSource()
rhFnSrc.SetParametricFunction(rh)
# Now we have the sources, lets put them into a list.
sources = list()
sources.append(cleaner)
sources.append(cleaner)
sources.append(rhFnSrc)
sources.append(rhFnSrc)
# Colour transfer function.
ctf = vtk.vtkColorTransferFunction()
ctf.SetColorSpaceToDiverging()
p1 = [0.0] + list(colors.GetColor3d('MidnightBlue'))
p2 = [1.0] + list(colors.GetColor3d('DarkOrange'))
ctf.AddRGBPoint(*p1)
ctf.AddRGBPoint(*p2)
cc = list()
for i in range(256):
cc.append(ctf.GetColor(float(i) / 255.0))
# Lookup table.
lut = list()
for idx in range(len(sources)):
lut.append(vtk.vtkLookupTable())
lut[idx].SetNumberOfColors(256)
for i, item in enumerate(cc):
lut[idx].SetTableValue(i, item[0], item[1], item[2], 1.0)
if idx == 0:
lut[idx].SetRange(-10, 10)
if idx == 1:
lut[idx].SetRange(0, 4)
if idx == 2:
lut[idx].SetRange(-1, 1)
if idx == 3:
lut[idx].SetRange(-1, 1)
lut[idx].Build()
curvatures = list()
for idx in range(len(sources)):
curvatures.append(vtk.vtkCurvatures())
if idx % 2 == 0:
curvatures[idx].SetCurvatureTypeToGaussian()
else:
curvatures[idx].SetCurvatureTypeToMean()
renderers = list()
mappers = list()
actors = list()
textmappers = list()
textactors = list()
# Create a common text property.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(24)
textProperty.SetJustificationToCentered()
names = [
'Torus - Gaussian Curvature', 'Torus - Mean Curvature',
'Random Hills - Gaussian Curvature', 'Random Hills - Mean Curvature'
]
# Link the pipeline together.
for idx, item in enumerate(sources):
sources[idx].Update()
curvatures[idx].SetInputConnection(sources[idx].GetOutputPort())
mappers.append(vtk.vtkPolyDataMapper())
mappers[idx].SetInputConnection(curvatures[idx].GetOutputPort())
mappers[idx].SetLookupTable(lut[idx])
mappers[idx].SetUseLookupTableScalarRange(1)
actors.append(vtk.vtkActor())
actors[idx].SetMapper(mappers[idx])
textmappers.append(vtk.vtkTextMapper())
textmappers[idx].SetInput(names[idx])
textmappers[idx].SetTextProperty(textProperty)
textactors.append(vtk.vtkActor2D())
textactors[idx].SetMapper(textmappers[idx])
textactors[idx].SetPosition(250, 16)
renderers.append(vtk.vtkRenderer())
gridDimensions = 2
rendererSize = 512
for idx in range(len(sources)):
if idx < gridDimensions * gridDimensions:
renderers.append(vtk.vtkRenderer)
# Create the RenderWindow
#
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(rendererSize * gridDimensions,
rendererSize * gridDimensions)
renderWindow.SetWindowName('CurvaturesDemo')
# Add and position the renders to the render window.
viewport = list()
for row in range(gridDimensions):
for col in range(gridDimensions):
idx = row * gridDimensions + col
viewport[:] = []
viewport.append(float(col) / gridDimensions)
viewport.append(float(gridDimensions - (row + 1)) / gridDimensions)
viewport.append(float(col + 1) / gridDimensions)
viewport.append(float(gridDimensions - row) / gridDimensions)
if idx > (len(sources) - 1):
continue
renderers[idx].SetViewport(viewport)
renderWindow.AddRenderer(renderers[idx])
renderers[idx].AddActor(actors[idx])
renderers[idx].AddActor(textactors[idx])
renderers[idx].SetBackground(colors.GetColor3d('CornflowerBlue'))
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
def contour_movie_vti(name):
#gridreader = vtk.vtkXMLStructuredGridReader()
gridreader = vtk.vtkXMLImageDataReader()
gridreader.SetFileName(name)
gridreader.Update()
grid = gridreader.GetOutput()
data = grid.GetPointData()
#dims =grid.GetDimensions()
#print "Dims=",dims
velocity = data.GetArray("v")
phase = data.GetArray("phi")
data.SetScalars(phase)
data.SetVectors(velocity)
print "Phase=", phase
print "Data=", data
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(gridreader.GetOutputPort())
#outline.SetInput(grid)
outlineMapper = vtk.vtkDataSetMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
contour = vtk.vtkContourFilter()
#contour.SetInputConnection(phase_image.GetOutputPort())
#contour.SetInput(phase_image)
contour.SetInputConnection(gridreader.GetOutputPort())
contour.SetValue(0, 0.0)
contour.Update()
contourMapper = vtk.vtkPolyDataMapper()
#contourMapper.SetScalarRange(phase.GetRange())
contourMapper.SetInputConnection(contour.GetOutputPort())
contourActor = vtk.vtkActor()
contourActor.SetMapper(contourMapper)
ren = vtk.vtkRenderer()
ren.AddActor(contourActor)
ren.AddActor(outlineActor)
ren.SetBackground(0.1, 0.2, 0.4)
#ren.SetColor(0.1,0.5,0.2)
#ren.SetViewport(0, 0, .3, 1)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(500, 500)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.Initialize()
renWin.Render()
numbers = 720
delta = 2.0 * math.pi / numbers
cam = ren.GetActiveCamera()
print "Camera=", cam.GetViewUp()
xinit, yinit, zinit = cam.GetPosition()
radius = math.sqrt(xinit**2 + yinit**2 + zinit**2)
print xinit, yinit, zinit
#cam.Azimuth(delta*50)
#contourActor.RotateWXYZ(25,1,0,0)
#renWin.Render()
#cam.Zoom(3)
cam.SetViewUp(1, 0, 0)
for counter, alpha in enumerate(numpy.arange(0, 2.0 * math.pi, delta)):
cam.Azimuth(delta * 180.0 / math.pi)
#contourActor.RotateWXYZ(delta*180/math.pi,0,1,0)
#outlineActor.RotateWXYZ(delta*180/math.pi,0,1,0)
renWin.Render()
im_filter = vtk.vtkWindowToImageFilter()
im_filter.SetInput(renWin)
writer = vtk.vtkJPEGWriter()
file_name = "tmp/contour" + str(0) * (3 - len(str(counter))) + str(
counter) + ".jpg"
writer.SetFileName(file_name)
writer.SetInput(im_filter.GetOutput())
writer.Write()
iren.Start()
def main():
SHOW_AXES = True
SHOW_SCENE_AXES = True
SHOW_COIL_AXES = True
SHOW_SKIN = True
SHOW_BRAIN = True
SHOW_COIL = True
SHOW_MARKERS = True
TRANSF_COIL = True
SHOW_PLANE = False
SELECT_LANDMARKS = 'scalp' # 'all', 'mri' 'scalp'
SAVE_ID = False
AFFINE_IMG = True
NO_SCALE = True
SCREENSHOT = False
reorder = [0, 2, 1]
flipx = [True, False, False]
# reorder = [0, 1, 2]
# flipx = [False, False, False]
# default folder and subject
subj = 'S5' # 1 - 9
id_extra = False # 8, 9, 10, 12, False
data_dir = r'P:\tms_eeg\mTMS\projects\2016 Lateral ppTMS M1\E-fields'
simnibs_dir = os.path.join(data_dir, 'simnibs',
'm2m_ppM1_{}_nc'.format(subj))
if id_extra and subj == 'S1':
subj_id = '{}_{}'.format(subj, id_extra)
else:
subj_id = '{}'.format(subj)
nav_dir = os.path.join(data_dir, 'nav_coordinates',
'ppM1_{}'.format(subj_id))
# filenames
coil_file = os.path.join(os.environ['OneDrive'], 'data', 'nexstim_coord',
'magstim_fig8_coil.stl')
coord_file = os.path.join(nav_dir, 'ppM1_eximia_{}.txt'.format(subj_id))
img_file = os.path.join(data_dir,
r'mri\ppM1_{}\ppM1_{}.nii'.format(subj, subj))
brain_file = os.path.join(simnibs_dir, 'wm.stl')
skin_file = os.path.join(simnibs_dir, 'skin.stl')
output_file = os.path.join(nav_dir, 'transf_mat_{}'.format(subj_id))
coords = lc.load_nexstim(coord_file)
# red, green, blue, maroon (dark red),
# olive (shitty green), teal (petrol blue), yellow, orange
col = [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.], [1., .0, 1.],
[.5, .5, 0.], [0., .5, .5], [1., 1., 0.], [1., .4, .0]]
# extract image header shape and affine transformation from original nifti file
imagedata = nb.squeeze_image(nb.load(img_file))
imagedata = nb.as_closest_canonical(imagedata)
imagedata.update_header()
pix_dim = imagedata.header.get_zooms()
img_shape = imagedata.header.get_data_shape()
print("Pixel size: \n")
print(pix_dim)
print("\nImage shape: \n")
print(img_shape)
affine_aux = imagedata.affine.copy()
if NO_SCALE:
scale, shear, angs, trans, persp = tf.decompose_matrix(
imagedata.affine)
affine_aux = tf.compose_matrix(scale=None,
shear=shear,
angles=angs,
translate=trans,
perspective=persp)
if AFFINE_IMG:
affine = affine_aux
# if NO_SCALE:
# scale, shear, angs, trans, persp = tf.decompose_matrix(imagedata.affine)
# affine = tf.compose_matrix(scale=None, shear=shear, angles=angs, translate=trans, perspective=persp)
else:
affine = np.identity(4)
# affine_I = np.identity(4)
# create a camera, render window and renderer
camera = vtk.vtkCamera()
camera.SetPosition(0, 1000, 0)
camera.SetFocalPoint(0, 0, 0)
camera.SetViewUp(0, 0, 1)
camera.ComputeViewPlaneNormal()
camera.Azimuth(90.0)
camera.Elevation(10.0)
ren = vtk.vtkRenderer()
ren.SetActiveCamera(camera)
ren.ResetCamera()
camera.Dolly(1.5)
ren_win = vtk.vtkRenderWindow()
ren_win.AddRenderer(ren)
ren_win.SetSize(800, 800)
# create a renderwindowinteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(ren_win)
if SELECT_LANDMARKS == 'mri':
# MRI landmarks
coord_mri = [['Nose/Nasion'], ['Left ear'], ['Right ear'],
['Coil Loc'], ['EF max']]
pts_ref = [1, 2, 3, 7, 10]
elif SELECT_LANDMARKS == 'all':
# all coords
coord_mri = [['Nose/Nasion'], ['Left ear'], ['Right ear'],
['Nose/Nasion'], ['Left ear'], ['Right ear'],
['Coil Loc'], ['EF max']]
pts_ref = [1, 2, 3, 5, 4, 6, 7, 10]
elif SELECT_LANDMARKS == 'scalp':
# scalp landmarks
coord_mri = [['Nose/Nasion'], ['Left ear'], ['Right ear'],
['Coil Loc'], ['EF max']]
hdr_mri = [
'Nose/Nasion', 'Left ear', 'Right ear', 'Coil Loc', 'EF max'
]
pts_ref = [5, 4, 6, 7, 10]
coords_np = np.zeros([len(pts_ref), 3])
for n, pts_id in enumerate(pts_ref):
# to keep in the MRI space use the identity as the affine
# coord_aux = n2m.coord_change(coords[pts_id][1:], img_shape, affine_I, flipx, reorder)
# affine_trans = affine_I.copy()
# affine_trans = affine.copy()
# affine_trans[:3, -1] = affine[:3, -1]
coord_aux = n2m.coord_change(coords[pts_id][1:], img_shape, affine,
flipx, reorder)
coords_np[n, :] = coord_aux
[coord_mri[n].append(s) for s in coord_aux]
if SHOW_MARKERS:
marker_actor = add_marker(coord_aux, ren, col[n])
if id_extra:
# compare coil locations in experiments with 8, 9, 10 and 12 mm shifts
# MRI Nexstim space: 8, 9, 10, 12 mm coil locations
# coord_others = [[122.2, 198.8, 99.7],
# [121.1, 200.4, 100.1],
# [120.5, 200.7, 98.2],
# [117.7, 202.9, 96.6]]
if AFFINE_IMG:
# World space: 8, 9, 10, 12 mm coil locations
coord_others = [
[-42.60270233154297, 28.266497802734378, 81.02450256347657],
[-41.50270233154296, 28.66649780273437, 82.62450256347657],
[-40.90270233154297, 26.766497802734378, 82.92450256347655],
[-38.10270233154297, 25.16649780273437, 85.12450256347657]
]
else:
# MRI space reordered and flipped: 8, 9, 10, 12 mm coil locations
coord_others = [[27.8, 99.7, 198.8], [28.9, 100.1, 200.4],
[29.5, 98.2, 200.7], [32.3, 96.6, 202.9]]
col_others = [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.], [0., 0., 0.]]
for n, c in enumerate(coord_others):
marker_actor = add_marker(c, ren, col_others[n])
print('\nOriginal coordinates from Nexstim: \n')
[print(s) for s in coords]
print('\nMRI coordinates flipped and reordered: \n')
[print(s) for s in coords_np]
print('\nTransformed coordinates to MRI space: \n')
[print(s) for s in coord_mri]
# coil location, normal vector and direction vector
coil_loc = coord_mri[-2][1:]
coil_norm = coords[8][1:]
coil_dir = coords[9][1:]
# creating the coil coordinate system by adding a point in the direction of each given coil vector
# the additional vector is just the cross product from coil direction and coil normal vectors
# origin of the coordinate system is the coil location given by Nexstim
# the vec_length is to allow line creation with visible length in VTK scene
vec_length = 75
p1 = coords[7][1:]
p2 = [x + vec_length * y for x, y in zip(p1, coil_norm)]
p2_norm = n2m.coord_change(p2, img_shape, affine, flipx, reorder)
p2 = [x + vec_length * y for x, y in zip(p1, coil_dir)]
p2_dir = n2m.coord_change(p2, img_shape, affine, flipx, reorder)
coil_face = np.cross(coil_norm, coil_dir)
p2 = [x - vec_length * y for x, y in zip(p1, coil_face.tolist())]
p2_face = n2m.coord_change(p2, img_shape, affine, flipx, reorder)
# Coil face unit vector (X)
u1 = np.asarray(p2_face) - np.asarray(coil_loc)
u1_n = u1 / np.linalg.norm(u1)
# Coil direction unit vector (Y)
u2 = np.asarray(p2_dir) - np.asarray(coil_loc)
u2_n = u2 / np.linalg.norm(u2)
# Coil normal unit vector (Z)
u3 = np.asarray(p2_norm) - np.asarray(coil_loc)
u3_n = u3 / np.linalg.norm(u3)
transf_matrix = np.identity(4)
if TRANSF_COIL:
transf_matrix[:3, 0] = u1_n
transf_matrix[:3, 1] = u2_n
transf_matrix[:3, 2] = u3_n
transf_matrix[:3, 3] = coil_loc[:]
# the absolute value of the determinant indicates the scaling factor
# the sign of the determinant indicates how it affects the orientation: if positive maintain the
# original orientation and if negative inverts all the orientations (flip the object inside-out)'
# the negative determinant is what makes objects in VTK scene to become black
print('Transformation matrix: \n', transf_matrix, '\n')
print('Determinant: ', np.linalg.det(transf_matrix))
if SAVE_ID:
coord_dict = {
'm_affine': transf_matrix,
'coords_labels': hdr_mri,
'coords': coords_np
}
io.savemat(output_file + '.mat', coord_dict)
hdr_names = ';'.join(
['m' + str(i) + str(j) for i in range(1, 5) for j in range(1, 5)])
np.savetxt(output_file + '.txt',
transf_matrix.reshape([1, 16]),
delimiter=';',
header=hdr_names)
if SHOW_BRAIN:
if AFFINE_IMG:
brain_actor = load_stl(brain_file,
ren,
colour=[0., 1., 1.],
opacity=1.)
else:
# to visualize brain in MRI space
brain_actor = load_stl(brain_file,
ren,
colour=[0., 1., 1.],
opacity=1.,
user_matrix=np.linalg.inv(affine_aux))
if SHOW_SKIN:
if AFFINE_IMG:
skin_actor = load_stl(skin_file,
ren,
colour="SkinColor",
opacity=.4)
else:
# to visualize skin in MRI space
skin_actor = load_stl(skin_file,
ren,
colour="SkinColor",
opacity=.4,
user_matrix=np.linalg.inv(affine_aux))
if SHOW_COIL:
# reposition STL object prior to transformation matrix
# [translation_x, translation_y, translation_z, rotation_x, rotation_y, rotation_z]
# old translation when using Y as normal vector
# repos = [0., -6., 0., 0., -90., 90.]
# Translate coil loc coordinate to coil bottom
# repos = [0., 0., 5.5, 0., 0., 180.]
repos = [0., 0., 0., 0., 0., 180.]
# SimNIBS coil orientation requires 180deg around Y
# Ry = tf.rotation_matrix(np.pi, [0, 1, 0], [0, 0, 0])
# transf_matrix = transf_matrix @ Ry
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()
sampleActor = vtk.vtkActor() sampleActor.SetMapper(sampleMapper) # Create an outline outline = vtk.vtkOutlineFilter() outline.SetInputConnection(sample.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) # Create the RenderWindow, Renderer and both Actors # ren0 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren0) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add the actors to the renderer, set the background and size # ren0.AddActor(sampleActor) ren0.AddActor(outlineActor) ren0.SetBackground(0.1, 0.2, 0.4) renWin.SetSize(250, 250) cam = ren0.GetActiveCamera() cam.SetFocalPoint(0, 0, 0)
def main():
colors = vtk.vtkNamedColors()
# Set the background color.
colors.SetColor('BkgColor', [26, 51, 77, 255])
# Create a cylinder.
# Cylinder height vector is (0,1,0).
# Cylinder center is in the middle of the cylinder
cylinderSource = vtk.vtkCylinderSource()
cylinderSource.SetResolution(15)
# Generate a random start and end point
startPoint = [0] * 3
endPoint = [0] * 3
rng = vtk.vtkMinimalStandardRandomSequence()
rng.SetSeed(8775070) # For testing.
for i in range(0, 3):
rng.Next()
startPoint[i] = rng.GetRangeValue(-10, 10)
rng.Next()
endPoint[i] = rng.GetRangeValue(-10, 10)
# Compute a basis
normalizedX = [0] * 3
normalizedY = [0] * 3
normalizedZ = [0] * 3
# The X axis is a vector from start to end
vtk.vtkMath.Subtract(endPoint, startPoint, normalizedX)
length = vtk.vtkMath.Norm(normalizedX)
vtk.vtkMath.Normalize(normalizedX)
# The Z axis is an arbitrary vector cross X
arbitrary = [0] * 3
for i in range(0, 3):
rng.Next()
arbitrary[i] = rng.GetRangeValue(-10, 10)
vtk.vtkMath.Cross(normalizedX, arbitrary, normalizedZ)
vtk.vtkMath.Normalize(normalizedZ)
# The Y axis is Z cross X
vtk.vtkMath.Cross(normalizedZ, normalizedX, normalizedY)
matrix = vtk.vtkMatrix4x4()
# Create the direction cosine matrix
matrix.Identity()
for i in range(0, 3):
matrix.SetElement(i, 0, normalizedX[i])
matrix.SetElement(i, 1, normalizedY[i])
matrix.SetElement(i, 2, normalizedZ[i])
# Apply the transforms
transform = vtk.vtkTransform()
transform.Translate(startPoint) # translate to starting point
transform.Concatenate(matrix) # apply direction cosines
transform.RotateZ(-90.0) # align cylinder to x axis
transform.Scale(1.0, length, 1.0) # scale along the height vector
transform.Translate(0, .5, 0) # translate to start of cylinder
# Transform the polydata
transformPD = vtk.vtkTransformPolyDataFilter()
transformPD.SetTransform(transform)
transformPD.SetInputConnection(cylinderSource.GetOutputPort())
# Create a mapper and actor for the arrow
mapper = vtk.vtkPolyDataMapper()
actor = vtk.vtkActor()
if USER_MATRIX:
mapper.SetInputConnection(cylinderSource.GetOutputPort())
actor.SetUserMatrix(transform.GetMatrix())
else:
mapper.SetInputConnection(transformPD.GetOutputPort())
actor.SetMapper(mapper)
actor.GetProperty().SetColor(colors.GetColor3d('Cyan'))
# Create spheres for start and end point
sphereStartSource = vtk.vtkSphereSource()
sphereStartSource.SetCenter(startPoint)
sphereStartSource.SetRadius(0.8)
sphereStartMapper = vtk.vtkPolyDataMapper()
sphereStartMapper.SetInputConnection(sphereStartSource.GetOutputPort())
sphereStart = vtk.vtkActor()
sphereStart.SetMapper(sphereStartMapper)
sphereStart.GetProperty().SetColor(colors.GetColor3d('Yellow'))
sphereEndSource = vtk.vtkSphereSource()
sphereEndSource.SetCenter(endPoint)
sphereEndSource.SetRadius(0.8)
sphereEndMapper = vtk.vtkPolyDataMapper()
sphereEndMapper.SetInputConnection(sphereEndSource.GetOutputPort())
sphereEnd = vtk.vtkActor()
sphereEnd.SetMapper(sphereEndMapper)
sphereEnd.GetProperty().SetColor(colors.GetColor3d('Magenta'))
# Create a renderer, render window, and interactor
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetWindowName('Oriented Cylinder')
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
# Add the actor to the scene
renderer.AddActor(actor)
renderer.AddActor(sphereStart)
renderer.AddActor(sphereEnd)
renderer.SetBackground(colors.GetColor3d('BkgColor'))
# Render and interact
renderWindow.Render()
renderWindowInteractor.Start()
def main():
colors = vtk.vtkNamedColors()
#
# Next we create an instance of vtkConeSource and set some of its
# properties. The instance of vtkConeSource 'cone' is part of a visualization
# pipeline (it is a source process object); it produces data (output type is
# vtkPolyData) which other filters may process.
#
cone = vtk.vtkConeSource()
cone.SetHeight(3.0)
cone.SetRadius(1.0)
cone.SetResolution(10)
#
# In this example we terminate the pipeline with a mapper process object.
# (Intermediate filters such as vtkShrinkPolyData could be inserted in
# between the source and the mapper.) We create an instance of
# vtkPolyDataMapper to map the polygonal data into graphics primitives. We
# connect the output of the cone source to the input of this mapper.
#
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
#
# Create an actor to represent the first cone. The actor's properties are
# modified to give it different surface properties. By default, an actor
# is create with a property so the GetProperty() method can be used.
#
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
coneActor.GetProperty().SetColor(colors.GetColor3d('Peacock'))
coneActor.GetProperty().SetDiffuse(0.7)
coneActor.GetProperty().SetSpecular(0.4)
coneActor.GetProperty().SetSpecularPower(20)
#
# Create a property and directly manipulate it. Assign it to the
# second actor.
#
property = vtk.vtkProperty()
property.SetColor(colors.GetColor3d('Tomato'))
property.SetDiffuse(0.7)
property.SetSpecular(0.4)
property.SetSpecularPower(20)
#
# Create a second actor and a property. The property is directly
# manipulated and then assigned to the actor. In this way, a single
# property can be shared among many actors. Note also that we use the
# same mapper as the first actor did. This way we avoid duplicating
# geometry, which may save lots of memory if the geometry is large.
coneActor2 = vtk.vtkActor()
coneActor2.SetMapper(coneMapper)
# coneActor2.GetProperty().SetColor(colors.GetColor3d('Peacock'))
coneActor2.SetProperty(property)
coneActor2.SetPosition(0, 2, 0)
#
# Create the Renderer and assign actors to it. A renderer is like a
# viewport. It is part or all of a window on the screen and it is responsible
# for drawing the actors it has. We also set the background color here.
#
ren1 = vtk.vtkRenderer()
ren1.AddActor(coneActor)
ren1.AddActor(coneActor2)
ren1.SetBackground(colors.GetColor3d('LightSlateGray'))
#
# Finally we create the render window which will show up on the screen
# We put our renderer into the render window using AddRenderer. We also
# set the size to be 300 pixels by 300.
#
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
renWin.SetSize(640, 480)
renWin.SetWindowName('Cone4')
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
#
# Now we loop over 60 degrees and render the cone each time.
#
ren1.GetActiveCamera().Elevation(30)
ren1.ResetCamera()
for i in range(0, 60):
time.sleep(0.03)
renWin.Render()
ren1.GetActiveCamera().Azimuth(1)
iren.Start()
def main():
fn1, fn2 = get_program_parameters()
polyData1 = ReadPolyData(fn1)
if fn2:
polyData2 = ReadPolyData(fn1)
else:
# If only one polydata is present, generate a second polydata by
# rotating the original about its center.
print('Generating modified polyData1')
center = polyData1.GetCenter()
transform = vtk.vtkTransform()
transform.Translate(center[0], center[1], center[2])
transform.RotateY(90.0)
transform.Translate(-center[0], -center[1], -center[2])
transformPD = vtk.vtkTransformPolyDataFilter()
transformPD.SetTransform(transform)
transformPD.SetInputData(polyData1)
transformPD.Update()
polyData2 = transformPD.GetOutput()
# Mark points inside with 1 and outside with a 0
select = vtk.vtkSelectEnclosedPoints()
select.SetInputData(polyData1)
select.SetSurfaceData(polyData2)
# Extract three meshes, one completely inside, one completely
# outside and on the border between the inside and outside.
threshold = vtk.vtkMultiThreshold()
# Outside points have a 0 value in ALL points of a cell
outsideId = threshold.AddBandpassIntervalSet(
0, 0, vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, "SelectedPoints", 0,
1)
# Inside points have a 1 value in ALL points of a cell
insideId = threshold.AddBandpassIntervalSet(
1, 1, vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, "SelectedPoints", 0,
1)
# Border points have a 0 or a 1 in at least one point of a cell
borderId = threshold.AddIntervalSet(
0, 1, vtk.vtkMultiThreshold.OPEN, vtk.vtkMultiThreshold.OPEN,
vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, "SelectedPoints", 0, 0)
threshold.SetInputConnection(select.GetOutputPort())
# Select the intervals to be output
threshold.OutputSet(outsideId)
threshold.OutputSet(insideId)
threshold.OutputSet(borderId)
threshold.Update()
# Visualize
colors = vtk.vtkNamedColors()
outsideColor = colors.GetColor3d("Crimson")
insideColor = colors.GetColor3d("Banana")
borderColor = colors.GetColor3d("Mint")
surfaceColor = colors.GetColor3d("Peacock")
backgroundColor = colors.GetColor3d("Silver")
# Outside
outsideMapper = vtk.vtkDataSetMapper()
outsideMapper.SetInputData(
threshold.GetOutput().GetBlock(outsideId).GetBlock(0))
outsideMapper.ScalarVisibilityOff()
outsideActor = vtk.vtkActor()
outsideActor.SetMapper(outsideMapper)
outsideActor.GetProperty().SetDiffuseColor(outsideColor)
outsideActor.GetProperty().SetSpecular(.6)
outsideActor.GetProperty().SetSpecularPower(30)
# Inside
insideMapper = vtk.vtkDataSetMapper()
insideMapper.SetInputData(
threshold.GetOutput().GetBlock(insideId).GetBlock(0))
insideMapper.ScalarVisibilityOff()
insideActor = vtk.vtkActor()
insideActor.SetMapper(insideMapper)
insideActor.GetProperty().SetDiffuseColor(insideColor)
insideActor.GetProperty().SetSpecular(.6)
insideActor.GetProperty().SetSpecularPower(30)
insideActor.GetProperty().EdgeVisibilityOn()
# Border
borderMapper = vtk.vtkDataSetMapper()
borderMapper.SetInputData(
threshold.GetOutput().GetBlock(borderId).GetBlock(0))
borderMapper.ScalarVisibilityOff()
borderActor = vtk.vtkActor()
borderActor.SetMapper(borderMapper)
borderActor.GetProperty().SetDiffuseColor(borderColor)
borderActor.GetProperty().SetSpecular(.6)
borderActor.GetProperty().SetSpecularPower(30)
borderActor.GetProperty().EdgeVisibilityOn()
surfaceMapper = vtk.vtkDataSetMapper()
surfaceMapper.SetInputData(polyData2)
surfaceMapper.ScalarVisibilityOff()
# Surface of object containing cell
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(surfaceMapper)
surfaceActor.GetProperty().SetDiffuseColor(surfaceColor)
surfaceActor.GetProperty().SetOpacity(.1)
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(640, 480)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.SetBackground(backgroundColor)
renderer.UseHiddenLineRemovalOn()
renderer.AddActor(surfaceActor)
renderer.AddActor(outsideActor)
renderer.AddActor(insideActor)
renderer.AddActor(borderActor)
renderWindow.SetWindowName('CellsInsideObject')
renderWindow.Render()
renderer.GetActiveCamera().Azimuth(30)
renderer.GetActiveCamera().Elevation(30)
renderer.GetActiveCamera().Dolly(1.25)
renderWindow.Render()
renderWindowInteractor.Start()
def render(self,
color=None,
opacity=1.,
view='+x',
axes_scale=0.,
filename=None,
window=None,
renderer=None,
interact=True):
"""
Plots the mesh on the provided vtkRenderWindow
:param color: (N, 3) or (N, ) array defining the color across the mesh
:param opacity: float setting the opacity of the surface
:param view: where the object is viewed from; one of '+x', '-x', '+y', '-y', '+z', or '-z' or tuple with
- vector pointing from the mesh center to the camera
- vector defining the hemisphere that is up from the camera
:param filename: if set saves the image to the given filename
:param window: If provded the window on which the mesh will be plotted (otherwise a new window is created)
:type window: vtk.vtkRenderWindow
:param renderer: the VTK rendered to which the actor plotting the mesh will be added (default: a new one is created)
:type renderer: vtk.vtkRenderer
:param interact: if True allows interaction of the window (this will pause the evaulation)
:return: the window the mesh is plotted on and the rendered doing the plotting
:rtype: (vtk.vtkRenderWindow, vtk.vtkRenderer)
"""
import vtk
if renderer is None:
renderer = vtk.vtkRenderer()
renderer.SetBackground(1, 1, 1)
if window is None:
window = vtk.vtkRenderWindow()
window.SetSize(1000, 1000)
renderer.AddActor(self.to_vtk_actor(color=color, opacity=opacity))
window.AddRenderer(renderer)
if axes_scale > 0:
vtk_axes = vtk.vtkAxesActor()
transform = vtk.vtkTransform()
transform.Scale(axes_scale, axes_scale, axes_scale)
vtk_axes.SetUserTransform(transform)
vtk_axes.SetAxisLabels(0)
renderer.AddActor(vtk_axes)
if isinstance(view, str):
assert len(view) == 2
view = {
'+x': ((1, 0, 0), (0, 0, 1)),
'-x': ((-1, 0, 0), (0, 0, 1)),
'+y': ((0, 1, 0), (0, 0, 1)),
'-y': ((0, -1, 0), (0, 0, 1)),
'+z': ((0, 0, 1), (0, 1, 0)),
'-z': ((0, 0, -1), (0, 1, 0))
}[view]
camera = renderer.GetActiveCamera()
renderer.ResetCamera()
camera.SetPosition(
np.array(camera.GetFocalPoint()) + np.array(view[0]))
camera.SetViewUp(view[1])
renderer.ResetCamera()
window.Render()
if filename is not None:
imfilt = vtk.vtkWindowToImageFilter()
imfilt.SetInput(window)
imfilt.Update()
pngwriter = vtk.vtkPNGWriter()
pngwriter.SetInputData(imfilt.GetOutput())
pngwriter.SetFileName(filename)
pngwriter.Write()
if interact:
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(window)
interactor.Start()
return window, renderer
def render(self):
try:
pred_mask
except NameError:
pass
else:
pred_mask[pred_mask > 0.5] = 50
data_matrix = pred_mask.astype(np.uint8)
m, n, z = data_matrix.shape
# data_matrix[data_matrix>0.5]=50
vtk.vtkObject.GlobalWarningDisplayOff()
dataImporter = vtk.vtkImageImport()
data_string = data_matrix.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, z - 1, 0, n - 1, 0, m - 1)
dataImporter.SetWholeExtent(0, z - 1, 0, n - 1, 0, m - 1)
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.0)
alphaChannelFunc.AddPoint(50, 2)
colorFunc = vtk.vtkColorTransferFunction()
colorFunc.AddRGBPoint(50, 1.0, 0.0, 0.0)
colorFunc.AddRGBPoint(0, 0.0, 0.0, 0.0)
# colorFunc.AddRGBPoint(150, 0.0, 0.0, 1.0)
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
renderer.AddVolume(volume)
renderer.SetBackground(1, 1, 1)
renderWin.SetSize(400, 400)
def exitCheck(obj, event):
if obj.GetEventPending() != 0:
obj.SetAbortRender(1)
renderWin.AddObserver("AbortCheckEvent", exitCheck)
renderInteractor.Initialize()
renderWin.Render()
renderWin.SetWindowName('3D Vessal')
renderInteractor.Start()
def marching_cubes(mcCases, rotation=0, label=True):
color = vtk.vtkNamedColors()
# Rotate the final figure 0, 90, 180, 270 degrees.
rotation = abs(int(rotation))
if rotation > 3:
rotation = 0
if len(mcCases) > 1:
print('Cases', ', '.join(map(str, mcCases)))
else:
print('Cases', ','.join(map(str, mcCases)))
print('Rotated', rotation * 90, 'degrees.')
renWin = vtk.vtkRenderWindow()
renWin.SetSize(640, 480)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Always use a grid of four columns unless number of cases < 4.
renderers = list()
gridSize = ((len(mcCases) + 3) // 4) * 4
if len(mcCases) < 4:
gridSize = len(mcCases)
for i in range(0, gridSize):
# Create the Renderer
renderer = vtk.vtkRenderer()
renderers.append(renderer)
# Set the background color.
renderers[i].SetBackground(color.GetColor3d('slate_grey'))
renWin.AddRenderer(renderer)
for i in range(0, len(mcCases)):
# Define a Single Cube
Scalars = vtk.vtkFloatArray()
Scalars.InsertNextValue(1.0)
Scalars.InsertNextValue(0.0)
Scalars.InsertNextValue(0.0)
Scalars.InsertNextValue(1.0)
Scalars.InsertNextValue(0.0)
Scalars.InsertNextValue(0.0)
Scalars.InsertNextValue(0.0)
Scalars.InsertNextValue(0.0)
Points = vtk.vtkPoints()
Points.InsertNextPoint(0, 0, 0)
Points.InsertNextPoint(1, 0, 0)
Points.InsertNextPoint(1, 1, 0)
Points.InsertNextPoint(0, 1, 0)
Points.InsertNextPoint(0, 0, 1)
Points.InsertNextPoint(1, 0, 1)
Points.InsertNextPoint(1, 1, 1)
Points.InsertNextPoint(0, 1, 1)
Ids = vtk.vtkIdList()
Ids.InsertNextId(0)
Ids.InsertNextId(1)
Ids.InsertNextId(2)
Ids.InsertNextId(3)
Ids.InsertNextId(4)
Ids.InsertNextId(5)
Ids.InsertNextId(6)
Ids.InsertNextId(7)
Grid = vtk.vtkUnstructuredGrid()
Grid.Allocate(10, 10)
Grid.InsertNextCell(12, Ids)
Grid.SetPoints(Points)
Grid.GetPointData().SetScalars(Scalars)
# Find the triangles that lie along the 0.5 contour in this cube.
Marching = vtk.vtkContourFilter()
Marching.SetInputData(Grid)
Marching.SetValue(0, 0.5)
Marching.Update()
# Extract the edges of the triangles just found.
triangleEdges = vtk.vtkExtractEdges()
triangleEdges.SetInputConnection(Marching.GetOutputPort())
# Draw the edges as tubes instead of lines. Also create the associated
# mapper and actor to display the tubes.
triangleEdgeTubes = vtk.vtkTubeFilter()
triangleEdgeTubes.SetInputConnection(triangleEdges.GetOutputPort())
triangleEdgeTubes.SetRadius(.005)
triangleEdgeTubes.SetNumberOfSides(6)
triangleEdgeTubes.UseDefaultNormalOn()
triangleEdgeTubes.SetDefaultNormal(.577, .577, .577)
triangleEdgeMapper = vtk.vtkPolyDataMapper()
triangleEdgeMapper.SetInputConnection(triangleEdgeTubes.GetOutputPort())
triangleEdgeMapper.ScalarVisibilityOff()
triangleEdgeActor = vtk.vtkActor()
triangleEdgeActor.SetMapper(triangleEdgeMapper)
triangleEdgeActor.GetProperty().SetDiffuseColor(
color.GetColor3d('lamp_black'))
triangleEdgeActor.GetProperty().SetSpecular(.4)
triangleEdgeActor.GetProperty().SetSpecularPower(10)
# Shrink the triangles we found earlier. Create the associated mapper
# and actor. Set the opacity of the shrunken triangles.
aShrinker = vtk.vtkShrinkPolyData()
aShrinker.SetShrinkFactor(1)
aShrinker.SetInputConnection(Marching.GetOutputPort())
aMapper = vtk.vtkPolyDataMapper()
aMapper.ScalarVisibilityOff()
aMapper.SetInputConnection(aShrinker.GetOutputPort())
Triangles = vtk.vtkActor()
Triangles.SetMapper(aMapper)
Triangles.GetProperty().SetDiffuseColor(
color.GetColor3d('banana'))
Triangles.GetProperty().SetOpacity(.6)
# Draw a cube the same size and at the same position as the one
# created previously. Extract the edges because we only want to see
# the outline of the cube. Pass the edges through a vtkTubeFilter so
# they are displayed as tubes rather than lines.
CubeModel = vtk.vtkCubeSource()
CubeModel.SetCenter(.5, .5, .5)
Edges = vtk.vtkExtractEdges()
Edges.SetInputConnection(CubeModel.GetOutputPort())
Tubes = vtk.vtkTubeFilter()
Tubes.SetInputConnection(Edges.GetOutputPort())
Tubes.SetRadius(.01)
Tubes.SetNumberOfSides(6)
Tubes.UseDefaultNormalOn()
Tubes.SetDefaultNormal(.577, .577, .577)
# Create the mapper and actor to display the cube edges.
TubeMapper = vtk.vtkPolyDataMapper()
TubeMapper.SetInputConnection(Tubes.GetOutputPort())
CubeEdges = vtk.vtkActor()
CubeEdges.SetMapper(TubeMapper)
CubeEdges.GetProperty().SetDiffuseColor(
color.GetColor3d('khaki'))
CubeEdges.GetProperty().SetSpecular(.4)
CubeEdges.GetProperty().SetSpecularPower(10)
# Create a sphere to use as a glyph source for vtkGlyph3D.
Sphere = vtk.vtkSphereSource()
Sphere.SetRadius(0.04)
Sphere.SetPhiResolution(20)
Sphere.SetThetaResolution(20)
# Remove the part of the cube with data values below 0.5.
ThresholdIn = vtk.vtkThresholdPoints()
ThresholdIn.SetInputData(Grid)
ThresholdIn.ThresholdByUpper(.5)
# Display spheres at the vertices remaining in the cube data set after
# it was passed through vtkThresholdPoints.
Vertices = vtk.vtkGlyph3D()
Vertices.SetInputConnection(ThresholdIn.GetOutputPort())
Vertices.SetSourceConnection(Sphere.GetOutputPort())
# Create a mapper and actor to display the glyphs.
SphereMapper = vtk.vtkPolyDataMapper()
SphereMapper.SetInputConnection(Vertices.GetOutputPort())
SphereMapper.ScalarVisibilityOff()
CubeVertices = vtk.vtkActor()
CubeVertices.SetMapper(SphereMapper)
CubeVertices.GetProperty().SetDiffuseColor(
color.GetColor3d('tomato'))
# Define the text for the label
caseLabel = vtk.vtkVectorText()
caseLabel.SetText('Case 1')
if label:
# Set up a transform to move the label to a new position.
aLabelTransform = vtk.vtkTransform()
aLabelTransform.Identity()
# Position the label according to the rotation of the figure.
if rotation == 0:
aLabelTransform.Translate(-0.2, 0, 1.25)
aLabelTransform.Scale(.05, .05, .05)
elif rotation == 1:
aLabelTransform.RotateY(90)
aLabelTransform.Translate(-1.25, 0, 1.25)
aLabelTransform.Scale(.05, .05, .05)
elif rotation == 2:
aLabelTransform.RotateY(180)
aLabelTransform.Translate(-1.25, 0, 0.2)
aLabelTransform.Scale(.05, .05, .05)
else:
aLabelTransform.RotateY(270)
aLabelTransform.Translate(-0.2, 0, 0.2)
aLabelTransform.Scale(.05, .05, .05)
# Move the label to a new position.
labelTransform = vtk.vtkTransformPolyDataFilter()
labelTransform.SetTransform(aLabelTransform)
labelTransform.SetInputConnection(caseLabel.GetOutputPort())
# Create a mapper and actor to display the text.
labelMapper = vtk.vtkPolyDataMapper()
labelMapper.SetInputConnection(labelTransform.GetOutputPort())
labelActor = vtk.vtkActor()
labelActor.SetMapper(labelMapper)
# Define the base that the cube sits on. Create its associated mapper
# and actor. Set the position of the actor.
baseModel = vtk.vtkCubeSource()
baseModel.SetXLength(1.5)
baseModel.SetYLength(.01)
baseModel.SetZLength(1.5)
baseMapper = vtk.vtkPolyDataMapper()
baseMapper.SetInputConnection(baseModel.GetOutputPort())
base = vtk.vtkActor()
base.SetMapper(baseMapper)
base.SetPosition(.5, -0.09, .5)
# Set the scalar values for this case of marching cubes.
# A negative case number will generate a complementary case
mcCase = mcCases[i]
if mcCase < 0:
cases[-mcCase](Scalars, caseLabel, 0, 1)
else:
cases[mcCase](Scalars, caseLabel, 1, 0)
# Force the grid to update.
Grid.Modified()
# Add the actors to the renderer
renderers[i].AddActor(triangleEdgeActor)
renderers[i].AddActor(base)
if label:
renderers[i].AddActor(labelActor)
renderers[i].AddActor(CubeEdges)
renderers[i].AddActor(CubeVertices)
renderers[i].AddActor(Triangles)
# Position the camera.
renderers[i].GetActiveCamera().Dolly(1.2)
# Rotate the camera an extra 30 degrees so the cube is not face on.
if rotation == 0:
renderers[i].GetActiveCamera().Azimuth(30)
elif rotation == 1:
renderers[i].GetActiveCamera().Azimuth(30 + 90)
elif rotation == 2:
renderers[i].GetActiveCamera().Azimuth(30 + 180)
else:
renderers[i].GetActiveCamera().Azimuth(30 + 270)
renderers[i].GetActiveCamera().Elevation(20)
renderers[i].ResetCamera()
renderers[i].ResetCameraClippingRange()
if i > 0:
renderers[i].SetActiveCamera(renderers[0].GetActiveCamera())
# Setup viewports for the renderers
rendererSize = 300
xGridDimensions = 4
if len(mcCases) < 4:
xGridDimensions = len(mcCases)
yGridDimensions = (len(mcCases) - 1) // 4 + 1
print('Grid dimensions, (x, y): ({:d}, {:d})'.format(xGridDimensions, yGridDimensions))
renWin.SetSize(
rendererSize * xGridDimensions, rendererSize * yGridDimensions)
renWin.SetWindowName('MarchingCases')
for row in range(0, yGridDimensions):
for col in range(0, xGridDimensions):
index = row * xGridDimensions + col
# (xmin, ymin, xmax, ymax)
viewport = [
float(col) / xGridDimensions,
float(yGridDimensions - (row + 1)) / yGridDimensions,
float(col + 1) / xGridDimensions,
float(yGridDimensions - row) / yGridDimensions]
renderers[index].SetViewport(viewport)
iren.Initialize()
renWin.Render()
iren.Start()
