def __init__(self, parent, visualizer, **kws):
"""
Initialization
"""
VisualizationModule.__init__(self, parent, visualizer, **kws)
self.descs = {"TrackFile": "Tracks file", #"AllTracks": "Show all tracks", \
"MinLength": "Min. length of track (# of timepoints)",
"SphereRadius": "Sphere radius",
"TubeRadius": "Tube radius",
"SameStartingPoint": "Visualize tracks starting from same point"}
self.showTracks = []
self.lineMapper = vtk.vtkPolyDataMapper()
self.sphereMapper = vtk.vtkPolyDataMapper()
self.firstMapper = vtk.vtkPolyDataMapper()
self.lastMapper = vtk.vtkPolyDataMapper()
self.currentMapper = vtk.vtkPolyDataMapper()
self.actors = []
self.renderer = self.parent.getRenderer()
#iactor = self.wxrenwin.GetRenderWindow().GetInteractor()
lib.messenger.connect(None, "visualize_tracks", self.onVisualizeTracks)
self.filterDesc = "Visualize created motion tracks"
def _MakeActors(self):
actors = []
# lines
for i in range(3):
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(self._Cutters[i].GetOutputPort())
actor = self._NewActor()
actor.SetProperty(self._Properties[i])
actor.SetMapper(mapper)
actor.PickableOff()
actors.append(actor)
# use index to track actors in different renderers
self._LineActorsIndex = (0, 1, 2)
# cones
for i in range(6):
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(self._Cones[i].GetOutputPort())
actor = self._NewActor()
actor.SetProperty(self._ConeProperties[i / 2])
actor.SetMapper(mapper)
actor.PickableOff()
actors.append(actor)
self._ConeActorsIndex = (3, 4, 5, 6, 7, 8)
return actors
def addPoints(self, points, color, thick=False, thickness=_DEFAULT_POINT_THICKNESS):
vtkPoints = vtk.vtkPoints()
for point in points:
vtkPoints.InsertNextPoint(point[0], point[1], point[2])
pointsPolyData = vtk.vtkPolyData()
pointsPolyData.SetPoints(vtkPoints)
if thick:
sphereSource = vtk.vtkSphereSource()
sphereSource.SetRadius(thickness)
glyph3D = vtk.vtkGlyph3D()
glyph3D.SetSourceConnection(sphereSource.GetOutputPort())
glyph3D.SetInputData(pointsPolyData)
glyph3D.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(glyph3D.GetOutputPort())
else:
vertexFilter = vtk.vtkVertexGlyphFilter()
vertexFilter.SetInputData(pointsPolyData)
vertexFilter.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(vertexFilter.GetOutput())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(color)
self._rendererScene.AddActor(actor)
def _MakeActors(self):
actors = []
# 4 corners
for i in range(4):
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(self._Corners[i].GetOutput())
actor = self._NewActor()
actor.SetProperty(self._CornerProperty)
actor.SetMapper(mapper)
actors.append(actor)
# center
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(self._Center.GetOutput())
actor = self._NewActor()
actor.SetProperty(self._CenterProperty)
actor.SetMapper(mapper)
actors.append(actor)
# rectangle roi
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(self._ROI.GetOutput())
actor = self._NewActor()
actor.SetProperty(self._ROIProperty)
actor.SetMapper(mapper)
actor.PickableOff()
actors.append(actor)
return actors
def __init__(self):
# Central dot
self.dot = vtk.vtkSphereSource()
self.dot.SetThetaResolution(20)
self.dot.SetRadius(.5)
self.dotMapper = vtk.vtkPolyDataMapper()
self.dotMapper.SetInputConnection(self.dot.GetOutputPort())
self.dotActor = vtk.vtkActor()
self.dotActor.SetMapper(self.dotMapper)
# Circular halo around dot
self.halo = vtk.vtkSphereSource()
self.halo.SetThetaResolution(20)
self.halo.SetRadius(2)
self.haloMapper = vtk.vtkPolyDataMapper()
self.haloMapper.SetInputConnection(self.halo.GetOutputPort())
self.haloActor = vtk.vtkActor()
self.haloActor.SetMapper(self.haloMapper)
self.dotActor.GetProperty().SetColor(red)
self.haloActor.GetProperty().SetColor(white)
self.haloActor.GetProperty().SetOpacity(0.1)
self.haloActor.GetProperty().SetSpecular(0.6)
self.actor = vtk.vtkAssembly()
self.actor.AddPart(self.dotActor)
self.actor.AddPart(self.haloActor)
def plotContinents(self,x1,x2,y1,y2,projection,wrap,tmpl):
contData = vcs2vtk.prepContinents(self.canvas._continents)
contMapper = vtk.vtkPolyDataMapper()
contMapper.SetInputData(contData)
contActor = vtk.vtkActor()
contActor.SetMapper(contMapper)
contActor.GetProperty().SetColor(0.,0.,0.)
contActor = vcs2vtk.doWrap(contActor,[x1,x2,y1,y2],wrap)
if projection.type!="linear":
contData=contActor.GetMapper().GetInput()
cpts = contData.GetPoints()
geo, gcpts = vcs2vtk.project(cpts,projection,[x1,x2,y1,y2])
contData.SetPoints(gcpts)
contMapper = vtk.vtkPolyDataMapper()
contMapper.SetInputData(contData)
contActor = vtk.vtkActor()
contActor.SetMapper(contMapper)
contActor.GetProperty().SetColor(0.,0.,0.)
else:
geo=None
ren = vtk.vtkRenderer()
self.renWin.AddRenderer(ren)
self.setLayer(ren,tmpl.data.priority)
vcs2vtk.fitToViewport(contActor,ren,[tmpl.data.x1,tmpl.data.x2,tmpl.data.y1,tmpl.data.y2],wc=[x1,x2,y1,y2],geo=geo)
if tmpl.data.priority!=0:
ren.AddActor(contActor)
def test(points, springs1, springs2):
app = QApplication(sys.argv)
window = Viewer3D.SimpleView()
polydata1 = GeneratePolydata.generateLinePolydata(points, springs1)
polydata2 = GeneratePolydata.generateLinePolydata(points, springs2)
mapper1 = vtk.vtkPolyDataMapper()
mapper1.SetInputData(polydata1)
actor1 = vtk.vtkActor()
actor1.SetMapper(mapper1)
mapper2 = vtk.vtkPolyDataMapper()
mapper2.SetInputData(polydata2)
actor2 = vtk.vtkActor()
actor2.SetMapper(mapper2)
actor1.GetProperty().SetColor(1,0,0)
actor2.GetProperty().SetColor(0,1,0.5)
window.ren.AddActor(actor1)
window.ren.AddActor(actor2)
window.start(app)
return
def __init__(self, renderer):
Visualizer.__init__(self)
assert isinstance(renderer, vtk.vtkRenderer)
self.ren = renderer
# -------- add the beam ----
# geometry
self.beam = vtk.vtkCubeSource()
self.beam.SetXLength(st.visBeamLength)
self.beam.SetYLength(st.visBeamWidth)
self.beam.SetZLength(st.visBeamDepth)
# mapper
self.beamMapper = vtk.vtkPolyDataMapper()
self.beamMapper.SetInputConnection(self.beam.GetOutputPort())
# actor
self.beamActor = vtk.vtkLODActor()
self.beamActor.SetMapper(self.beamMapper)
# make it look nice
self.beamProp = self.beamActor.GetProperty()
self.beamProp.SetColor(101 / 255, 123 / 255, 131 / 255)
self.ren.AddActor(self.beamActor)
# -------- add the ball ----
# geometry
self.ball = vtk.vtkSphereSource()
self.ball.SetRadius(st.visR)
self.ball.SetThetaResolution(20)
self.ball.SetPhiResolution(20)
# mapper
self.ballMapper = vtk.vtkPolyDataMapper()
self.ballMapper.SetInputConnection(self.ball.GetOutputPort())
# actor
self.ballActor = vtk.vtkLODActor()
self.ballActor.SetMapper(self.ballMapper)
# make it look nice
self.ballProp = self.ballActor.GetProperty()
self.ballProp.SetColor(255 / 255, 255 / 255, 0)
self.ballProp.SetAmbient(0.2)
self.ballProp.SetDiffuse(0.8)
self.ballProp.SetSpecular(0.5)
self.ballProp.SetSpecularPower(0.5)
self.ren.AddActor(self.ballActor)
# add background
self.ren.GradientBackgroundOn()
self.ren.SetBackground(228 / 255, 232 / 255, 213 / 255)
self.ren.SetBackground2(38 / 255, 139 / 255, 210 / 255)
# get everybody into the frame
self.ren.ResetCamera()
self.ren.GetActiveCamera().Zoom(1.7)
def make_sphere():
global renderer
# ---------------------------------------------------------------
# The following code is identical to render_demo.py...
# ---------------------------------------------------------------
# create a sphere
sphere_src = vtk.vtkSphereSource()
sphere_src.SetRadius(1.0)
sphere_src.SetCenter(0.0, 0.0, 0.0)
sphere_src.SetThetaResolution(20)
sphere_src.SetPhiResolution(20)
# extract the edges
edge_extractor = vtk.vtkExtractEdges()
edge_extractor.SetInputConnection(sphere_src.GetOutputPort())
# map sphere and edges separately
sphere_mapper = vtk.vtkPolyDataMapper()
sphere_mapper.SetInputConnection(sphere_src.GetOutputPort())
edge_mapper = vtk.vtkPolyDataMapper()
edge_mapper.SetInputConnection(edge_extractor.GetOutputPort())
# define different rendering styles for sphere and edges
sphere_actor = vtk.vtkActor()
sphere_actor.SetMapper(sphere_mapper)
sphere_actor.GetProperty().SetColor(1, 0.5, 0)
edge_actor = vtk.vtkActor()
edge_actor.SetMapper(edge_mapper)
edge_actor.GetProperty().SetColor(0, 0.5, 0)
edge_actor.GetProperty().SetLineWidth(3)
# add resulting primitives to renderer
renderer.AddActor(sphere_actor)
renderer.AddActor(edge_actor)
def render_image(pointset):
delaunay = vtk.vtkDelaunay2D()
delaunay.SetTolerance(0.001)
delaunay.SetAlpha(18)
delaunay.SetInput(pointset);
delaunay.Update();
meshMapper = vtk.vtkPolyDataMapper()
meshMapper.SetInput(delaunay.GetOutput())
meshMapper.SetScalarRange(0,255)
meshActor = vtk.vtkActor()
meshActor.SetMapper(meshMapper)
boundaryMapper = vtk.vtkPolyDataMapper()
boundaryMapper.SetInput(delaunay.GetOutput())
boundaryActor = vtk.vtkActor()
boundaryActor.SetMapper(boundaryMapper);
boundaryActor.GetProperty().SetColor(0,0.55,0);
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(meshActor)
renderer.AddActor(boundaryActor)
renderer.SetBackground(.5, .5, .5)
renderWindow.SetSize(600, 600)
renderWindow.Render()
renderWindowInteractor.Start()
def __init__(self, reader):
self.reader = reader
sg = self.src_glyph = vtk.vtkSphereSource()
sg.SetRadius(0.5)
sg.SetCenter(0.5, 0.0, 0.0)
g = self.glyph = vtk.vtkTensorGlyph()
g.SetInputConnection(self.reader.GetOutputPort())
g.SetSource(self.src_glyph.GetOutput())
g.SetScaleFactor(0.25)
# The normals are needed to generate the right colors and if
# not used some of the glyphs are black.
self.normals = vtk.vtkPolyDataNormals()
self.normals.SetInputConnection(g.GetOutputPort())
self.map = vtk.vtkPolyDataMapper()
self.map.SetInputConnection(self.normals.GetOutputPort())
self.act = vtk.vtkActor()
self.act.SetMapper(self.map)
# An outline.
self.of = vtk.vtkOutlineFilter()
self.of.SetInputConnection(self.reader.GetOutputPort())
self.out_map = vtk.vtkPolyDataMapper()
self.out_map.SetInputConnection(self.of.GetOutputPort())
self.out_act = vtk.vtkActor()
self.out_act.SetMapper(self.out_map)
def update_viewer(self, event, *args):
MarkerWindowInteractor.update_viewer(self, event, *args)
if event=='color marker':
marker, color = args
marker.set_color(color)
elif event=='label marker':
marker, label = args
marker.set_label(label)
if shared.debug: print "Create VTK-Text", marker.get_label()
text = vtk.vtkVectorText()
text.SetText(marker.get_label())
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInput(text.GetOutput())
textActor = self.textActors[marker]
textActor.SetMapper(textMapper)
elif event=='move marker':
marker, center = args
marker.set_center(center)
#update the select boxes and text actor
textActor = self.textActors[marker]
size = marker.get_size()
textActor.SetScale(size, size, size)
x,y,z = marker.get_center()
textActor.SetPosition(x+size, y+size, z+size)
if self.boxes.has_key(marker):
selectActor = self.boxes[marker]
boxSource = vtk.vtkCubeSource()
boxSource.SetBounds(marker.GetBounds())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(boxSource.GetOutput())
selectActor.SetMapper(mapper)
elif event=='labels on':
actors = self.textActors.values()
for actor in actors:
actor.VisibilityOn()
elif event=='labels off':
actors = self.textActors.values()
for actor in actors:
actor.VisibilityOff()
#elif event=='select marker':
# marker = args[0]
# actor = create_box_actor_around_marker(marker)
# if shared.debug: print "PlaneWidgetsXYZ.update_viewer(): self.renderer.AddActor(actor)"
# self.renderer.AddActor(actor)
# self.boxes[marker] = actor
#elif event=='unselect marker':
# marker = args[0]
# actor = self.boxes[marker]
# print "pwxyz: u m", repr(marker), repr(actor)
# self.renderer.RemoveActor(actor)
# del self.boxes[marker]
elif event=="set axes directions":
self.add_axes_labels()
EventHandler().notify('observers update plane')
self.Render()
def add_edge(self, start, end, colour=Colours.BASE0):
"""Appends an edge to the edges list."""
# Line
line = vtkLineSource()
line.SetPoint1(start)
line.SetPoint2(end)
# Line Mapper
line_mapper = vtkPolyDataMapper()
line_mapper.SetInputConnection(line.GetOutputPort())
self.edge_colours.append(colour)
self.line_mappers.append(line_mapper)
# Bar
bar = vtkTubeFilter()
bar.SetInputConnection(line.GetOutputPort())
bar.SetRadius(2.5)
self.bar_data.append(bar)
# Bar Mapper
# Tried this, but mapping the ribbon caused beaucoup errors,
# debugging would take a week.There must be some kind of way
# out of here.
# Said the joker to the thief
# There's too much confusion
# I can't get no relief
# No reason to get excited, the thief he kindly spoke
# But you and I have been through that
# And this is not our fate
# So let us not talk falsely now, the hour is getting late.
# (2011-08-12)
bar_mapper = vtkPolyDataMapper()
bar_mapper.SetInputConnection(bar.GetOutputPort())
self.bar_mappers.append(bar_mapper)
def addCube(self,pos,tam,img=False):
jpegfile = "struct.jpg"
# Read the image data from a file
reader = vtk.vtkJPEGReader()
reader.SetFileName(jpegfile)
(x,y,z) = pos
(i,j,k) = tam
cubito = vtk.vtkCubeSource()
cubito.SetXLength(0.2*i)
cubito.SetYLength(0.2*j)
cubito.SetZLength(0.2*k)
cubito.SetCenter((x,y,z))
if img == True:
# Create texture object
texture = vtk.vtkTexture()
if vtk.VTK_MAJOR_VERSION <= 5:
texture.SetInput(reader.GetOutput())
else:
texture.SetInputConnection(reader.GetOutputPort())
# Map texture coordinates
map_to_sphere = vtk.vtkTextureMapToPlane()
if vtk.VTK_MAJOR_VERSION <= 5:
map_to_sphere.SetInput(cubito.GetOutput())
else:
map_to_sphere.SetInputConnection(cubito.GetOutputPort())
#map_to_sphere.PreventSeamOn()
# Create mapper and set the mapped texture as input
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(map_to_sphere.GetOutput())
else:
mapper.SetInputConnection(map_to_sphere.GetOutputPort())
planeMapper = vtk.vtkPolyDataMapper()
planeMapper.SetInputConnection(cubito.GetOutputPort())
planeActor = (vtk.vtkActor())
if (img == True):
planeActor.SetMapper(mapper)
else:
planeActor.SetMapper(planeMapper)# mapper planeMapper
planeActor.DragableOn()
planeActor.SetDragable(1)
if (img== True):
planeActor.SetTexture(texture)
else:
planeActor.GetProperty().SetColor(.0,.3,.6)
planeActor.GetProperty().SetOpacity(0.95)
#planeActor.GetProperty().SetAmbient(0)
#planeActor.GetProperty().SetDiffuse(0.9)
#planeActor.GetProperty().SetSpecular(0.1)
self.render.AddActor(planeActor)
return planeActor
def main(self):
print("main builder")
window = self.widget.GetRenderWindow()
window.AddRenderer(self.rend)
self.addGeometry()
self.addAltGeometry()
self.buildLookupTable()
#self.startWireframeLight()
self.createTriAxes()
textSize = 14 * self.magnify
self.createText([5, 50], 'Max ', textSize) # text actor 0
self.createText([5, 35], 'Min ', textSize) # text actor 1
self.createText([5, 20], 'Word1', textSize) # text actor 2
self.createText([5, 5], 'Word2', textSize) # text actor 3
#self.createText([5,35],'Yet Again', textSize)
# Create the usual rendering stuff.
self.get_edges()
if self.is_edges:
prop = self.edgeActor.GetProperty()
prop.EdgeVisibilityOn()
else:
prop = self.edgeActor.GetProperty()
prop.EdgeVisibilityOff()
self.rend.GetActiveCamera().ParallelProjectionOn()
self.rend.SetBackground(.1, .2, .4)
vtk.vtkPolyDataMapper().SetResolveCoincidentTopologyToPolygonOffset()
self.rend.ResetCamera()
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 Execute(self):
if (self._Surface == None):
self.PrintError('vmtkPickPointSeedSelector Error: Surface not set.')
return
self._SourceSeedIds.Initialize()
self._TargetSeedIds.Initialize()
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
glyphs = vtk.vtkGlyph3D()
glyphSource = vtk.vtkSphereSource()
glyphs.SetInput(self.PickedSeeds)
glyphs.SetSource(glyphSource.GetOutput())
glyphs.SetScaleModeToDataScalingOff()
glyphs.SetScaleFactor(self._Surface.GetLength()*0.01)
glyphMapper = vtk.vtkPolyDataMapper()
glyphMapper.SetInput(glyphs.GetOutput())
self.SeedActor = vtk.vtkActor()
self.SeedActor.SetMapper(glyphMapper)
self.SeedActor.GetProperty().SetColor(1.0,0.0,0.0)
self.SeedActor.PickableOff()
self.vmtkRenderer.Renderer.AddActor(self.SeedActor)
self.vmtkRenderer.RenderWindowInteractor.AddObserver("KeyPressEvent", self.KeyPressed)
surfaceMapper = vtk.vtkPolyDataMapper()
surfaceMapper.SetInput(self._Surface)
surfaceMapper.ScalarVisibilityOff()
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(surfaceMapper)
surfaceActor.GetProperty().SetOpacity(1.0)
self.vmtkRenderer.Renderer.AddActor(surfaceActor)
self.OutputText('Please position the mouse and press space to add source points, \'u\' to undo\n')
any = 0
while any == 0:
self.InitializeSeeds()
self.vmtkRenderer.Render()
any = self.PickedSeedIds.GetNumberOfIds()
self._SourceSeedIds.DeepCopy(self.PickedSeedIds)
self.OutputText('Please position the mouse and press space to add target points, \'u\' to undo\n')
any = 0
while any == 0:
self.InitializeSeeds()
self.vmtkRenderer.Render()
any = self.PickedSeedIds.GetNumberOfIds()
self._TargetSeedIds.DeepCopy(self.PickedSeedIds)
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
def __init__(self, parent, visualizer, **kws):
"""
Initialization
"""
self.x, self.y, self.z = -1, -1, -1
VisualizationModule.__init__(self, parent, visualizer, **kws)
self.on = 0
self.renew = 1
self.mapper = vtk.vtkPolyDataMapper()
self.eventDesc = "Rendering orthogonal slices"
self.outline = vtk.vtkOutlineFilter()
self.outlineMapper = vtk.vtkPolyDataMapper()
self.outlineActor = vtk.vtkActor()
self.outlineActor.SetMapper(self.outlineMapper)
self.picker = vtk.vtkCellPicker()
self.picker.SetTolerance(0.005)
self.planeWidgetX = vtk.vtkImagePlaneWidget()
self.planeWidgetX.DisplayTextOn()
self.planeWidgetX.SetPicker(self.picker)
self.planeWidgetX.SetKeyPressActivationValue("x")
#self.planeWidgetX.UserControlledLookupTableOn()
self.prop1 = self.planeWidgetX.GetPlaneProperty()
#self.prop1.SetColor(1, 0, 0)
self.planeWidgetX.SetResliceInterpolateToCubic()
self.planeWidgetY = vtk.vtkImagePlaneWidget()
self.planeWidgetY.DisplayTextOn()
self.planeWidgetY.SetPicker(self.picker)
self.planeWidgetY.SetKeyPressActivationValue("y")
self.prop2 = self.planeWidgetY.GetPlaneProperty()
self.planeWidgetY.SetResliceInterpolateToCubic()
#self.planeWidgetY.UserControlledLookupTableOn()
#self.prop2.SetColor(1, 1, 0)
# for the z-slice, turn off texture interpolation:
# interpolation is now nearest neighbour, to demonstrate
# cross-hair cursor snapping to pixel centers
self.planeWidgetZ = vtk.vtkImagePlaneWidget()
self.planeWidgetZ.DisplayTextOn()
self.planeWidgetZ.SetPicker(self.picker)
self.planeWidgetZ.SetKeyPressActivationValue("z")
self.prop3 = self.planeWidgetZ.GetPlaneProperty()
#self.prop3.SetColor(1, 0, 1)
#self.planeWidgetZ.UserControlledLookupTableOn()
self.planeWidgetZ.SetResliceInterpolateToCubic()
self.renderer = self.parent.getRenderer()
self.renderer.AddActor(self.outlineActor)
self.useOutline = 1
iactor = self.wxrenwin.GetRenderWindow().GetInteractor()
self.planeWidgetX.SetInteractor(iactor)
self.planeWidgetY.SetInteractor(iactor)
self.planeWidgetZ.SetInteractor(iactor)
lib.messenger.connect(None, "zslice_changed", self.setZ)
self.filterDesc = "View orthogonal slices"
def visQuadFunc():
""" vtk sample scene with iso contours """
# VTK supports implicit functions of the form f(x,y,z)=constant. These
# functions can represent things spheres, cones, etc. Here we use a
# general form for a quadric to create an elliptical data field.
quadric = vtk.vtkQuadric()
quadric.SetCoefficients(.5, 1, .2, 0, .1, 0, 0, .2, 0, 0)
# vtkSampleFunction samples an implicit function over the x-y-z range
# specified (here it defaults to -1,1 in the x,y,z directions).
sample = vtk.vtkSampleFunction()
sample.SetSampleDimensions(30, 30, 30)
sample.SetImplicitFunction(quadric)
# Create five surfaces F(x,y,z) = constant between range specified. The
# GenerateValues() method creates n isocontour values between the range
# specified.
contours = vtk.vtkContourFilter()
contours.SetInputConnection(sample.GetOutputPort())
contours.GenerateValues(8, 0.0, 1.2)
contMapper = vtk.vtkPolyDataMapper()
contMapper.SetInputConnection(contours.GetOutputPort())
contMapper.SetScalarRange(0.0, 1.2)
contActor = vtk.vtkActor()
contActor.SetMapper(contMapper)
# We'll put a simple outline around the data.
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(sample.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(1, 0.5, 0)
# extract data from the volume
extract = vtk.vtkExtractVOI()
extract.SetInputConnection(sample.GetOutputPort())
extract.SetVOI(0, 29, 0, 29, 15, 15)
extract.SetSampleRate(1, 2, 3)
contours2 = vtk.vtkContourFilter()
contours2.SetInputConnection(extract.GetOutputPort())
contours2.GenerateValues(8, 0.0, 1.2)
contMapper2 = vtk.vtkPolyDataMapper()
contMapper2.SetInputConnection(contours2.GetOutputPort())
contMapper2.SetScalarRange(0.0, 1.2)
contActor2 = vtk.vtkActor()
contActor2.SetMapper(contMapper2)
return contActor, contActor2, outlineActor, contours, contours2
def CreateAxes():
global xAxis, yAxis, zAxis, popSplatter
# 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)
return axesActor, XActor, YActor, ZActor
def BuildBackdrop (minX, maxX, minY, maxY, minZ, maxZ, thickness):
global basePlane
global baseMapper
global base
global backPlane
global backMapper
global back
global left
global leftPlane
global leftMapper
if not basePlane:
basePlane = vtk.vtkCubeSource()
basePlane.SetCenter( (maxX + minX)/2.0, minY, (maxZ + minZ)/2.0)
basePlane.SetXLength(maxX-minX)
basePlane.SetYLength(thickness)
basePlane.SetZLength(maxZ - minZ)
if not baseMapper:
baseMapper = vtk.vtkPolyDataMapper()
baseMapper.SetInput(basePlane.GetOutput())
if not base:
base = vtk.vtkActor()
base.SetMapper(baseMapper)
if not backPlane:
backPlane = vtk.vtkCubeSource()
backPlane.SetCenter( (maxX + minX)/2.0, (maxY + minY)/2.0, minZ)
backPlane.SetXLength(maxX-minX)
backPlane.SetYLength(maxY - minY)
backPlane.SetZLength(thickness)
if not backMapper:
backMapper = vtk.vtkPolyDataMapper()
backMapper.SetInput(backPlane.GetOutput())
if not back:
back = vtk.vtkActor()
back.SetMapper(backMapper)
if not leftPlane:
leftPlane = vtk.vtkCubeSource()
leftPlane.SetCenter( minX, (maxY+minY)/2.0, (maxZ+minZ)/2.0)
leftPlane.SetXLength(thickness)
leftPlane.SetYLength(maxY-minY)
leftPlane.SetZLength(maxZ-minZ)
if not leftMapper:
leftMapper = vtk.vtkPolyDataMapper()
leftMapper.SetInput(leftPlane.GetOutput())
if not left:
left = vtk.vtkActor()
left.SetMapper(leftMapper)
return [base, back, left]
def SetInputMapper(self):
self.inputMapper1 = vtk.vtkPolyDataMapper()
self.inputMapper1.SetInputData(self.inputPolyData1)
self.inputMapper2 = vtk.vtkPolyDataMapper()
self.inputMapper2.SetInputData(self.inputPolyData2)
self.inputMapper3 = vtk.vtkPolyDataMapper()
self.inputMapper3.SetInputData(self.inputPolyData3)
self.inputMapper4 = vtk.vtkPolyDataMapper()
self.inputMapper4.SetInputData(self.inputPolyData4)
def Execute(self):
self._SourceSeedIds.Initialize()
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
glyphs = vtk.vtkGlyph3D()
glyphSource = vtk.vtkSphereSource()
glyphs.SetInputData(self.PickedSeeds)
glyphs.SetSourceConnection(glyphSource.GetOutputPort())
glyphs.SetScaleModeToDataScalingOff()
glyphs.SetScaleFactor(self._Surface.GetLength()*0.01)
glyphMapper = vtk.vtkPolyDataMapper()
glyphMapper.SetInputConnection(glyphs.GetOutputPort())
self.SeedActor = vtk.vtkActor()
self.SeedActor.SetMapper(glyphMapper)
self.SeedActor.GetProperty().SetColor(1.0,0.0,0.0)
self.SeedActor.PickableOff()
self.vmtkRenderer.Renderer.AddActor(self.SeedActor)
self.vmtkRenderer.AddKeyBinding('u','Undo.',self.UndoCallback)
self.vmtkRenderer.AddKeyBinding('space','Add points.',self.PickCallback)
surfaceMapper = vtk.vtkPolyDataMapper()
surfaceMapper.SetInputData(self._Surface)
surfaceMapper.ScalarVisibilityOff()
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(surfaceMapper)
surfaceActor.GetProperty().SetOpacity(1)
self.vmtkRenderer.Renderer.AddActor(surfaceActor)
# create a text actor
txt = vtk.vtkTextActor()
info = "Position mouse and press space. "
info += "Select seeds in this order: RSpv, RIpv, LIpv, LSpv. "
info += "Fifth seed requires --use_laa_seed command."
txt.SetInput(info)
txtprop=txt.GetTextProperty()
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(13)
txtprop.SetColor(1, 1, 1)
txt.SetDisplayPosition(0, 10)
self.vmtkRenderer.Renderer.AddActor(txt)
any = 0
while any == 0:
self.InitializeSeeds()
self.vmtkRenderer.Render()
any = self.PickedSeedIds.GetNumberOfIds()
self._SourceSeedIds.DeepCopy(self.PickedSeedIds)
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
def visualise_color(surface,ref,case):
"""Visualise surface in solid color and 'ref' in trasparent."""
# create a text actor
txt = vtk.vtkTextActor()
txt.SetInput(case)
txtprop=txt.GetTextProperty()
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(18)
txtprop.SetColor(0, 0, 0)
txt.SetDisplayPosition(20, 30)
# create a rendering window, renderer, and renderwindowinteractor
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
iren.SetRenderWindow(renWin)
# surface mapper and actor
surfacemapper = vtk.vtkPolyDataMapper()
surfacemapper.SetInputData(surface)
surfacemapper.SetScalarModeToUsePointFieldData()
surfaceactor = vtk.vtkActor()
surfaceactor.GetProperty().SetColor(288/255, 26/255, 28/255)
surfaceactor.SetMapper(surfacemapper)
# refsurface mapper and actor
refmapper = vtk.vtkPolyDataMapper()
refmapper.SetInputData(ref)
refmapper.SetScalarModeToUsePointFieldData()
refactor = vtk.vtkActor()
refactor.GetProperty().SetOpacity(0.5)
refactor.GetProperty().SetColor(1, 1, 1)
refactor.SetMapper(refmapper)
# assign actors to the renderer
ren.AddActor(surfaceactor)
ren.AddActor(refactor)
ren.AddActor(txt)
# set the background and size; zoom in; and render
ren.SetBackground(1, 1, 1)
renWin.SetSize(800 , 800)
ren.ResetCamera()
ren.GetActiveCamera().Zoom(1)
# enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
def addAltGeometry(self):
aQuadMapper = vtk.vtkDataSetMapper()
aQuadMapper.SetInput(self.grid2)
#aQuadMapper.SetInput(Filter.GetOutput())
geometryActor = vtk.vtkActor()
geometryActor.SetMapper(aQuadMapper)
#geometryActor.AddPosition(2, 0, 2)
#geometryActor.GetProperty().SetDiffuseColor(0, 0, 1) # blue
geometryActor.GetProperty().SetDiffuseColor(1, 1, 0) # green
self.rend.AddActor(geometryActor)
vtk.vtkPolyDataMapper().SetResolveCoincidentTopologyToPolygonOffset()
def __init__(self, parent = None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
#Create a cube
cube=vtk.vtkCubeSource()
cube.SetXLength(40)
cube.SetYLength(30)
cube.SetZLength(20)
cubeMapper=vtk.vtkPolyDataMapper()
cubeMapper.SetInputConnection(cube.GetOutputPort())
#create a plane to cut,here it cuts in the XZ direction (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0)
plane=vtk.vtkPlane()
plane.SetOrigin(10,0,0)
plane.SetNormal(1,0,0)
#create cutter
cutter=vtk.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputConnection(cube.GetOutputPort())
cutter.Update()
cutterMapper=vtk.vtkPolyDataMapper()
cutterMapper.SetInputConnection( cutter.GetOutputPort())
#create plane actor
planeActor=vtk.vtkActor()
planeActor.GetProperty().SetColor(1.0,1,0)
planeActor.GetProperty().SetLineWidth(2)
planeActor.SetMapper(cutterMapper)
#create cube actor
cubeActor=vtk.vtkActor()
cubeActor.GetProperty().SetColor(0.5,1,0.5)
cubeActor.GetProperty().SetOpacity(0.5)
cubeActor.SetMapper(cubeMapper)
#create renderers and add actors of plane and cube
self.ren.AddActor(planeActor)
self.ren.AddActor(cubeActor)
self.ren.ResetCamera()
self._initialized = False
def __init__(self):
self.source = None
self.target = None
self.transformed = None
self.iteration =200
self.icp= vtk.vtkIterativeClosestPointTransform()
self.icptf = vtk.vtkTransformPolyDataFilter()
self.mappers =vtk.vtkPolyDataMapper()
self.mappert =vtk.vtkPolyDataMapper()
self.mappertf =vtk.vtkPolyDataMapper()
self.actors = vtk.vtkActor()
self.actort = vtk.vtkActor()
self.actortf = vtk.vtkActor()
self.centroidon= False
def initializeView():
mapOutline = vtk.vtkPolyDataMapper()
mapOutline.SetInputConnection(outlineData.GetOutputPort())
outline = vtk.vtkActor()
outline.SetMapper(mapOutline)
outline.GetProperty().SetColor(0, 0, 0)
skinMapper = vtk.vtkPolyDataMapper()
skinMapper.SetInputConnection(skinNormals.GetOutputPort())
skinMapper.ScalarVisibilityOff()
skin = vtk.vtkActor()
skin.SetMapper(skinMapper)
attachProp(outline, vtkNode)
attachProp(skin, vtkNode)
def vtkpoints(points, color=None, radius=None):
# Create a polydata with the points we just created.
profile = vtk.vtkPolyData()
profile.SetPoints(points)
# Perform a 2D Delaunay triangulation on them.
delny = vtk.vtkDelaunay2D()
delny.SetInput(profile)
delny.SetTolerance(0.001)
mapMesh = vtk.vtkPolyDataMapper()
mapMesh.SetInputConnection(delny.GetOutputPort())
meshActor = vtk.vtkActor()
meshActor.SetMapper(mapMesh)
meshActor.GetProperty().SetColor(0.1, 0.2, 0.1)
# We will now create a nice looking mesh by wrapping the edges in tubes,
# and putting fat spheres at the points.
extract = vtk.vtkExtractEdges()
extract.SetInputConnection(delny.GetOutputPort())
ball = vtk.vtkSphereSource()
if radius == None:
rad = 0.002
else:
rad = radius
print rad
ball.SetRadius(rad)
ball.SetThetaResolution(50)
ball.SetPhiResolution(5)
balls = vtk.vtkGlyph3D()
balls.SetInputConnection(delny.GetOutputPort())
balls.SetSourceConnection(ball.GetOutputPort())
mapBalls = vtk.vtkPolyDataMapper()
mapBalls.SetInputConnection(balls.GetOutputPort())
ballActor = vtk.vtkActor()
ballActor.SetMapper(mapBalls)
if color == None:
ballcolor = red
else:
ballcolor = color
print "setting ball color to...", ballcolor
ballActor.GetProperty().SetColor(ballcolor)
ballActor.GetProperty().SetSpecularColor(0, 0, 0)
ballActor.GetProperty().SetSpecular(0.3)
ballActor.GetProperty().SetSpecularPower(500)
ballActor.GetProperty().SetAmbient(0.2)
ballActor.GetProperty().SetDiffuse(0.8)
return ballActor, profile
def showAxis(self):
if self.axis:
xmin, xmax, ymin, ymax, zmin, zmax = self.bounds[:]
axes=vtk.vtkAxes()
axes.SetOrigin(0.0,0.0,0.0)
axes.SetScaleFactor(0.1*max([xmax-xmin,ymax-ymin,zmax-zmin]))
axesTubes=vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(0.2)
axesTubes.SetNumberOfSides(6)
axesMapper=vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor=vtk.vtkActor()
axesActor.SetMapper(axesMapper)
XText=vtk.vtkVectorText()
XText.SetText("X")
XTextMapper=vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor=vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(2.0, 2.0, 2.0)
XActor.SetPosition(1.11*xmax, ymin, zmin)
XActor.GetProperty().SetColor(0,0,0)
XActor.SetCamera(self.cam)
YText=vtk.vtkVectorText()
YText.SetText("Y")
YTextMapper=vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor=vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(2.0, 2.0, 2.0)
YActor.SetPosition(xmin, 1.11*ymax, zmin)
YActor.GetProperty().SetColor(0,0,0)
YActor.SetCamera(self.cam)
ZText=vtk.vtkVectorText()
ZText.SetText("Z")
ZTextMapper=vtk.vtkPolyDataMapper()
ZTextMapper.SetInputConnection(ZText.GetOutputPort())
ZActor=vtk.vtkFollower()
ZActor.SetMapper(ZTextMapper)
ZActor.SetScale(2.0, 2.0, 2.0)
ZActor.SetPosition(xmin, ymin, 1.11*zmax)
ZActor.GetProperty().SetColor(0,0,0)
ZActor.SetCamera(self.cam)
self.ren.AddActor(axesActor)
self.ren.AddActor(XActor)
self.ren.AddActor(YActor)
self.ren.AddActor(ZActor)
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
# cleaner = vtk.vtkCleanPolyData()
# cleaner.SetInput(self.Surface)
# cleaner.Update()
#
# triangleFilter = vtk.vtkTriangleFilter()
# triangleFilter.SetInput(cleaner.GetOutput())
# triangleFilter.Update()
#
# self.Surface = triangleFilter.GetOutput()
boundaryIds = vtk.vtkIdList()
if self.Interactive:
if not self.vmtkRenderer:
import vmtkrenderer
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self)
boundaryExtractor = vtkvmtk.vtkvmtkPolyDataBoundaryExtractor()
boundaryExtractor.SetInput(self.Surface)
boundaryExtractor.Update()
boundaries = boundaryExtractor.GetOutput()
numberOfBoundaries = boundaries.GetNumberOfCells()
seedPoints = vtk.vtkPoints()
for i in range(numberOfBoundaries):
barycenter = [0.0, 0.0, 0.0]
vtkvmtk.vtkvmtkBoundaryReferenceSystems.ComputeBoundaryBarycenter(
boundaries.GetCell(i).GetPoints(), barycenter)
seedPoints.InsertNextPoint(barycenter)
seedPolyData = vtk.vtkPolyData()
seedPolyData.SetPoints(seedPoints)
seedPolyData.Update()
labelsMapper = vtk.vtkLabeledDataMapper()
labelsMapper.SetInput(seedPolyData)
labelsMapper.SetLabelModeToLabelIds()
labelsActor = vtk.vtkActor2D()
labelsActor.SetMapper(labelsMapper)
self.vmtkRenderer.Renderer.AddActor(labelsActor)
surfaceMapper = vtk.vtkPolyDataMapper()
surfaceMapper.SetInput(self.Surface)
surfaceMapper.ScalarVisibilityOff()
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(surfaceMapper)
surfaceActor.GetProperty().SetOpacity(0.25)
self.vmtkRenderer.Renderer.AddActor(surfaceActor)
#self.vmtkRenderer.Render()
#self.vmtkRenderer.Renderer.RemoveActor(labelsActor)
#self.vmtkRenderer.Renderer.RemoveActor(surfaceActor)
ok = False
while not ok:
labelString = self.InputText("Please input boundary ids: ",
self.LabelValidator)
labels = [int(label) for label in labelString.split()]
ok = True
for label in labels:
if label not in range(numberOfBoundaries):
ok = False
for label in labels:
boundaryIds.InsertNextId(label)
if self.Method == 'simple':
capper = vtkvmtk.vtkvmtkSimpleCapPolyData()
capper.SetInput(self.Surface)
if self.Interactive:
capper.SetBoundaryIds(boundaryIds)
capper.SetCellEntityIdsArrayName(self.CellEntityIdsArrayName)
capper.SetCellEntityIdOffset(self.CellEntityIdOffset)
capper.Update()
self.Surface = capper.GetOutput()
elif self.Method == 'centerpoint':
capper = vtkvmtk.vtkvmtkCapPolyData()
capper.SetInput(self.Surface)
if self.Interactive:
capper.SetBoundaryIds(boundaryIds)
capper.SetDisplacement(0.0)
capper.SetInPlaneDisplacement(0.0)
capper.Update()
self.Surface = capper.GetOutput()
elif self.Method == 'smooth':
triangle = vtk.vtkTriangleFilter()
triangle.SetInput(self.Surface)
triangle.PassLinesOff()
triangle.PassVertsOff()
triangle.Update()
capper = vtkvmtk.vtkvmtkSmoothCapPolyData()
capper.SetInput(triangle.GetOutput())
capper.SetConstraintFactor(self.ConstraintFactor)
capper.SetNumberOfRings(self.NumberOfRings)
if self.Interactive:
capper.SetBoundaryIds(boundaryIds)
capper.Update()
self.Surface = capper.GetOutput()
elif self.Method == 'annular':
capper = vtkvmtk.vtkvmtkAnnularCapPolyData()
capper.SetInput(self.Surface)
capper.SetCellEntityIdsArrayName(self.CellEntityIdsArrayName)
capper.SetCellEntityIdOffset(self.CellEntityIdOffset)
capper.Update()
self.Surface = capper.GetOutput()
if self.TriangleOutput == 1:
triangle = vtk.vtkTriangleFilter()
triangle.SetInput(self.Surface)
triangle.PassLinesOff()
triangle.PassVertsOff()
triangle.Update()
self.Surface = triangle.GetOutput()
normals = vtk.vtkPolyDataNormals()
normals.SetInput(self.Surface)
normals.AutoOrientNormalsOn()
normals.SplittingOff()
normals.ConsistencyOn()
normals.Update()
self.Surface = normals.GetOutput()
if self.Surface.GetSource():
self.Surface.GetSource().UnRegisterAllOutputs()
pl3d.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin") pl3d.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin") pl3d.SetScalarFunctionNumber(100) pl3d.SetVectorFunctionNumber(202) pl3d.Update() pl3d_output = pl3d.GetOutput().GetBlock(0) # We use a rake to generate a series of streamline starting points # scattered along a line. Each point will generate a streamline. These # streamlines are then fed to the vtkRuledSurfaceFilter which stitches # the lines together to form a surface. rake = vtk.vtkLineSource() rake.SetPoint1(15, -5, 32) rake.SetPoint2(15, 5, 32) rake.SetResolution(21) rakeMapper = vtk.vtkPolyDataMapper() rakeMapper.SetInputConnection(rake.GetOutputPort()) rakeActor = vtk.vtkActor() rakeActor.SetMapper(rakeMapper) integ = vtk.vtkRungeKutta4() sl = vtk.vtkStreamLine() sl.SetInputData(pl3d_output) sl.SetSourceConnection(rake.GetOutputPort()) sl.SetIntegrator(integ) sl.SetMaximumPropagationTime(0.1) sl.SetIntegrationStepLength(0.1) sl.SetIntegrationDirectionToBackward() sl.SetStepLength(0.001) # The ruled surface stiches together lines with triangle strips.
def get_screenshot(path, view, center=False):
reader = vtk.vtkPolyDataReader()
reader.SetFileName(path)
reader.Update()
fow = vtk.vtkFileOutputWindow()
fow.SetFileName('ow.txt')
ow = vtk.vtkOutputWindow()
ow.SetInstance(fow)
surf = reader.GetOutput()
# surf.ColorCells(1, 0, 0)
# create a rendering window and renderer
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
WIDTH = 640
HEIGHT = 500
renWin.SetSize(WIDTH, HEIGHT)
# create a renderwindowinteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# mapper
surfMapper = vtk.vtkPolyDataMapper()
surfMapper.SetInputData(surf)
# actor
surfActor = vtk.vtkActor()
surfActor.SetMapper(surfMapper)
# surfActor.GetProperty().SetColor(1, 0, 0)
if not center:
centerOfMassFilter = vtk.vtkCenterOfMass()
centerOfMassFilter.SetInputData(surf)
centerOfMassFilter.SetUseScalarsAsWeights(False)
centerOfMassFilter.Update()
center = centerOfMassFilter.GetCenter()
print(center)
camera = vtk.vtkCamera()
dist_x = 0
dist_z = 300
if view == 'posterior':
pos = (center[0] - dist_x, center[1] + 400, center[2] - dist_z)
elif view == 'anterior':
pos = (center[0] + dist_x, center[1] + 0, center[2] + dist_z)
else:
raise ValueError('view is not supported: {}'.format(view))
camera.SetPosition(pos)
camera.SetFocalPoint(center[0], center[1], center[2])
# assign actor to the renderer
ren.AddActor(surfActor)
ren.SetActiveCamera(camera)
ren.SetBackground(1, 1, 1)
renWin.Render()
# screenshot code:
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renWin)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName("screenshots/screenshot.png")
writer.SetInputData(w2if.GetOutput())
writer.Write()
# iren.Initialize()
# renWin.Render()
# iren.Start()
im = sitk.GetArrayFromImage(sitk.ReadImage('screenshots/screenshot.png'))
return im[100:400, 25:605], center
def main(argv):
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 cone. The actor orchestrates rendering
# of the mapper's graphics primitives. An actor also refers to properties
# via a vtkProperty instance, and includes an internal transformation
# matrix. We set this actor's mapper to be coneMapper which we created
# above.
#
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
coneActor.GetProperty().SetColor(colors.GetColor3d('MistyRose'))
#
# Create two renderers and assign actors to them. A renderer renders into
# a viewport within the vtkRenderWindow. 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. In this example we are adding the same
# actor to two different renderers it is okay to add different actors to
# different renderers as well.
#
ren1 = vtk.vtkRenderer()
ren1.AddActor(coneActor)
ren1.SetBackground(colors.GetColor3d('RoyalBlue'))
ren1.SetViewport(0.0, 0.0, 0.5, 1.0)
ren2 = vtk.vtkRenderer()
ren2.AddActor(coneActor)
ren2.SetBackground(colors.GetColor3d('DodgerBlue'))
ren2.SetViewport(0.5, 0.0, 1.0, 1.0)
#
# 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.AddRenderer(ren2)
renWin.SetSize(600, 300)
renWin.SetWindowName('Tutorial_Step3')
#
# Make one view 90 degrees from other.
#
ren1.ResetCamera()
ren1.GetActiveCamera().Azimuth(90)
#
# Now we loop over 360 degrees and render the cones each time.
#
for i in range(0, 360): # render the image
renWin.Render()
# rotate the active camera by one degree
ren1.GetActiveCamera().Azimuth(1)
ren2.GetActiveCamera().Azimuth(1)
# print( "P-Value" ) # print( P_val ) ######################################## ##### Visualization ###### ######################################## # Visualize a sphere coordinate sphere = vtk.vtkSphereSource() sphere.SetThetaResolution(30) sphere.SetPhiResolution(30) sphere.SetRadius(1.0) sphere.SetCenter(0.0, 0.0, 0.0) sphere.SetLatLongTessellation(True) sphere.Update() conMapper = vtk.vtkPolyDataMapper() conMapper.SetInputData(sphere.GetOutput()) conMapper.ScalarVisibilityOff() conMapper.Update() conActor = vtk.vtkActor() conActor.SetMapper(conMapper) conActor.GetProperty().SetOpacity(1) conActor.GetProperty().SetColor(0.9, 0.9, 0.9) conActor.GetProperty().SetEdgeColor(0.4, 0.4, 0.7) conActor.GetProperty().EdgeVisibilityOn() conActor.GetProperty().SetAmbient(0.3) conActor.GetProperty().SetDiffuse(0.375) conActor.GetProperty().SetSpecular(0.0) # Visualize spherical points - Red
def __init__(self, *args, **kwargs):
super(WorldPlotWindow, self).__init__(*args, **kwargs)
self.keyframe = 0
self.numKeyframes = 1
self.dataSets = []
self.projCenterLongitude = 0.0
self.projCenterLatitude = 0.0
self.colorBarHeight = 60
self.dataSetForColorBar = -1
self.renderer2D = vtk.vtkRenderer()
self.renderer2D.SetBackground(1, 1, 1)
self.renderer3D = vtk.vtkRenderer()
self.renderer3D.SetBackground(0, 0, 0)
self.style2D = vtkInteractorStyleWorldPlot2D()
self.style3D = vtkInteractorStyleWorldPlot3D()
# Globe (only applicable for 3D)
sphere = vtk.vtkSphereSource()
sphere.SetRadius(1)
sphere.SetPhiResolution(30)
sphere.SetThetaResolution(60)
mapper3D = vtk.vtkPolyDataMapper()
actor3D = vtk.vtkActor()
mapper3D.SetInputConnection(sphere.GetOutputPort())
actor3D.SetMapper(mapper3D)
self.renderer3D.AddActor(actor3D)
def onWorldViewChanged(caller, event, calldata=None):
wx.PostEvent(self, WorldViewChangedEvent())
self.style2D.AddObserver("WorldViewChanged", onWorldViewChanged)
self.style3D.AddObserver("WorldViewChanged", onWorldViewChanged)
# Grid lines
self.geoGridData = vtkGeoGridData()
self.renderer2D.AddActor2D(self.geoGridData.GetActor2D())
self.renderer3D.AddActor(self.geoGridData.GetActor3D())
self.style2D.GetTransformCollection().AddItem(
self.geoGridData.GetTransform())
# Coastlines
self.coastLineData = vtkGeographyLineData()
self.coastLineData.SetMaxLevel(2)
self.renderer2D.AddActor2D(self.coastLineData.GetActor2D())
self.renderer3D.AddActor(self.coastLineData.GetActor3D())
self.style2D.GetTransformCollection().AddItem(
self.coastLineData.GetTransform())
# Political Borders
self.politicalBorderData = vtkGeographyLineData()
self.politicalBorderData.SetMaxLevel(1)
self.renderer2D.AddActor2D(self.politicalBorderData.GetActor2D())
self.renderer3D.AddActor(self.politicalBorderData.GetActor3D())
self.style2D.GetTransformCollection().AddItem(
self.politicalBorderData.GetTransform())
# Plot Title
self.titleMapper2D = vtk.vtkTextMapper()
self.titleMapper2D.GetTextProperty().SetFontFamilyToArial()
self.titleMapper2D.GetTextProperty().SetFontSize(14)
self.titleMapper2D.GetTextProperty().SetColor(0, 0, 0)
self.titleMapper2D.GetTextProperty().SetShadow(1)
self.titleMapper2D.GetTextProperty().SetBold(1)
self.titleMapper2D.GetTextProperty().SetItalic(1)
self.titleMapper2D.GetTextProperty().SetJustificationToCentered()
self.titleActor2D = vtk.vtkActor2D()
self.titleActor2D.SetMapper(self.titleMapper2D)
self.titleActor2D.GetPositionCoordinate(
).SetCoordinateSystemToNormalizedViewport()
self.titleActor2D.SetPosition(0.5, 0.95)
self.renderer2D.AddActor2D(self.titleActor2D)
self.titleMapper3D = vtk.vtkTextMapper()
self.titleMapper3D.GetTextProperty().SetFontFamilyToArial()
self.titleMapper3D.GetTextProperty().SetFontSize(14)
self.titleMapper3D.GetTextProperty().SetColor(1, 1, 1)
self.titleMapper3D.GetTextProperty().SetShadow(1)
self.titleMapper3D.GetTextProperty().SetBold(1)
self.titleMapper3D.GetTextProperty().SetItalic(1)
self.titleMapper3D.GetTextProperty().SetJustificationToCentered()
titleActor = vtk.vtkActor2D()
titleActor.SetMapper(self.titleMapper3D)
titleActor.GetPositionCoordinate(
).SetCoordinateSystemToNormalizedViewport()
titleActor.SetPosition(0.5, 0.95)
self.renderer3D.AddActor2D(titleActor)
# Color Bar
self.colorBarRenderer = vtk.vtkRenderer()
self.colorBarActor = vtk.vtkScalarBarActor()
defaultLut = vtk.vtkLookupTable()
defaultLut.SetNumberOfTableValues(1)
defaultLut.SetTableValue(0, 0, 0, 0, 0)
self.colorBarActor.SetLookupTable(defaultLut)
self.colorBarActor.SetOrientationToHorizontal()
self.colorBarActor.SetPosition(0.1, 0.1)
self.colorBarActor.SetPosition2(0.8, 0.9)
self.colorBarActor.SetNumberOfLabels(5)
self.colorBarActor.GetLabelTextProperty().SetColor(1, 1, 1)
self.colorBarActor.GetLabelTextProperty().ShadowOff()
self.colorBarActor.GetLabelTextProperty().SetFontFamilyToArial()
self.colorBarActor.GetLabelTextProperty().ItalicOff()
self.colorBarActor.GetLabelTextProperty().BoldOff()
self.colorBarActor.GetLabelTextProperty().SetJustificationToCentered()
self.colorBarActor.GetTitleTextProperty().SetColor(1, 1, 1)
self.colorBarActor.GetTitleTextProperty().ShadowOff()
self.colorBarActor.GetTitleTextProperty().SetFontFamilyToArial()
self.colorBarActor.GetTitleTextProperty().ItalicOff()
self.colorBarActor.GetTitleTextProperty().BoldOff()
self.colorBarActor.SetLabelFormat("%g")
self.colorBarRenderer.AddActor2D(self.colorBarActor)
self.colorBarRenderer.InteractiveOff()
# Make sure the renderer starts with the default zoom/pan position from style3D.
# We need to do this step before the renderer is attached to the renderwindow otherwise the
# renderwindow will start to draw itself which breaks the wxVTK binding.
self.style3D.SetCurrentRenderer(self.renderer3D)
self.style3D.SetDefaultZoom(2.5)
self.style3D.SetDefaultView()
# start with 3D projection
self.projection = PROJECTION_3D
self.GetRenderWindow().AddRenderer(self.colorBarRenderer)
self.GetRenderWindow().AddRenderer(self.renderer2D)
self.GetRenderWindow().AddRenderer(self.renderer3D)
self.renderer2D.DrawOff()
self.SetInteractorStyle(self.style3D)
# By default the colorbar is hidden
self.showColorBar = False
self.UpdateColorBarSize()
print("Reading volume dataset from " + filename + " ...")
reader.Update() # executes the reader
print("Done!")
# Just for illustration, extract and print the dimensions of the
# volume. The string formatting used here is similar to the sprintf
# style in C.
width, height, depth = reader.GetOutput().GetDimensions()
print("Dimensions: %i %i %i" % (width, height, depth))
# Create an outline of the volume
# create an outline of the dataset
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(reader.GetOutputPort())
outline_mapper = vtk.vtkPolyDataMapper()
outline_mapper.SetInputConnection(outline.GetOutputPort())
outline_actor = vtk.vtkActor()
outline_actor.SetMapper(outline_mapper)
# Define actor properties (color, shading, line width, etc)
outline_actor.GetProperty().SetColor(0.0, 0.0, 1.0)
outline_actor.GetProperty().SetLineWidth(2.0)
outline_actor.GetProperty().SetColor(0.8, 0.8, 0.8)
outline_actor.GetProperty().SetLineWidth(2.0)
# color lookup table (an alternative is vtkLookUpTable)
lut = vtk.vtkColorTransferFunction()
lut.AddRGBPoint(0, 1, 0, 0)
lut.AddRGBPoint(0.5, 1, 1, 0)
aCellArray = vtk.vtkCellArray()
boundary = vtk.vtkPolyData()
boundary.SetPoints(aPolyData.GetPoints())
boundary.SetPolys(aCellArray)
delaunay = vtk.vtkDelaunay2D()
if vtk.VTK_MAJOR_VERSION <= 5:
delaunay.SetInput(aPolyData.GetOutput())
delaunay.SetSource(boundary)
else:
delaunay.SetInputData(aPolyData)
delaunay.SetSourceData(boundary)
delaunay.Update()
meshMapper = vtk.vtkPolyDataMapper()
meshMapper.SetInputConnection(delaunay.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()
0.0, r[1], 0.0, 0.0, 0.0, r[2])) grid = vtk.vtkUnstructuredGrid() grid.SetPoints(atom_points) grid.GetPointData().SetTensors(tensors) sphere = vtk.vtkSphereSource() sphere.SetPhiResolution(16) sphere.SetThetaResolution(16) ellipsoids = vtk.vtkTensorGlyph() ellipsoids.SetInputData(grid) ellipsoids.SetSourceConnection(sphere.GetOutputPort()) ellMapper = vtk.vtkPolyDataMapper() ellMapper.SetInputConnection(ellipsoids.GetOutputPort()) ellActor = vtk.vtkActor() ellActor.SetMapper(ellMapper) ellActor.GetProperty().SetOpacity(0.3) molecule = vtk.vtkMolecule() for i in range(natoms): s = symbols[i] a = averaged[i] molecule.AppendAtom(s, a[0], a[1], a[2]) for i in range(natoms): a = averaged[i]
def CreateSurfaceFromPolydata(self,
polydata,
overwrite=False,
name=None,
colour=None,
transparency=None,
volume=None,
area=None):
normals = vtk.vtkPolyDataNormals()
normals.SetInputData(polydata)
normals.SetFeatureAngle(80)
normals.AutoOrientNormalsOn()
normals.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(normals.GetOutput())
mapper.ScalarVisibilityOff()
mapper.ImmediateModeRenderingOn() # improve performance
actor = vtk.vtkActor()
actor.SetMapper(mapper)
if overwrite:
surface = Surface(index=self.last_surface_index)
else:
surface = Surface()
if not colour:
surface.colour = random.choice(const.SURFACE_COLOUR)
else:
surface.colour = colour
surface.polydata = polydata
if transparency:
surface.transparency = transparency
if name:
surface.name = name
# Append surface into Project.surface_dict
proj = prj.Project()
if overwrite:
proj.ChangeSurface(surface)
else:
index = proj.AddSurface(surface)
surface.index = index
self.last_surface_index = index
# Set actor colour and transparency
actor.GetProperty().SetColor(surface.colour)
actor.GetProperty().SetOpacity(1 - surface.transparency)
self.actors_dict[surface.index] = actor
session = ses.Session()
session.ChangeProject()
# The following lines have to be here, otherwise all volumes disappear
if not volume or not area:
triangle_filter = vtk.vtkTriangleFilter()
triangle_filter.SetInputData(polydata)
triangle_filter.Update()
measured_polydata = vtk.vtkMassProperties()
measured_polydata.SetInputConnection(
triangle_filter.GetOutputPort())
measured_polydata.Update()
volume = measured_polydata.GetVolume()
area = measured_polydata.GetSurfaceArea()
surface.volume = volume
surface.area = area
print ">>>>", surface.volume
else:
surface.volume = volume
surface.area = area
self.last_surface_index = surface.index
Publisher.sendMessage('Load surface actor into viewer', actor)
Publisher.sendMessage(
'Update surface info in GUI',
(surface.index, surface.name, surface.colour, surface.volume,
surface.area, surface.transparency))
return surface.index
Plot3D0.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin") Plot3D0.SetBinaryFile(1) Plot3D0.SetMultiGrid(0) Plot3D0.SetHasByteCount(0) Plot3D0.SetIBlanking(0) Plot3D0.SetTwoDimensionalGeometry(0) Plot3D0.SetForceRead(0) Plot3D0.SetByteOrder(0) Plot3D0.Update() output = Plot3D0.GetOutput().GetBlock(0) Geometry5 = vtk.vtkStructuredGridOutlineFilter() Geometry5.SetInputData(output) Mapper5 = vtk.vtkPolyDataMapper() Mapper5.SetInputConnection(Geometry5.GetOutputPort()) Mapper5.UseLookupTableScalarRangeOn() Mapper5.SetScalarVisibility(0) Mapper5.SetScalarModeToDefault() Actor5 = vtk.vtkActor() Actor5.SetMapper(Mapper5) Actor5.GetProperty().SetRepresentationToSurface() Actor5.GetProperty().SetInterpolationToGouraud() Actor5.GetProperty().SetAmbient(0.15) Actor5.GetProperty().SetDiffuse(0.85) Actor5.GetProperty().SetSpecular(0.1) Actor5.GetProperty().SetSpecularPower(100) Actor5.GetProperty().SetSpecularColor(1, 1, 1) Actor5.GetProperty().SetColor(1, 1, 1)
def load_stl(stl_path,
ren,
opacity=1.,
visibility=1,
position=False,
colour=False,
replace=False,
user_matrix=np.identity(4)):
vtk_colors = vtk.vtkNamedColors()
vtk_colors.SetColor("SkinColor", [233, 200, 188, 255])
vtk_colors.SetColor("BkgColor", [51, 77, 102, 255])
reader = vtk.vtkSTLReader()
reader.SetFileName(stl_path)
reader.Update()
poly_normals = vtk.vtkPolyDataNormals()
poly_normals.SetInputData(reader.GetOutput())
poly_normals.ConsistencyOn()
poly_normals.AutoOrientNormalsOn()
poly_normals.SplittingOff()
poly_normals.Update()
if replace:
transx, transy, transz, rotx, roty, rotz = replace
# create a transform that rotates the stl source
transform = vtk.vtkTransform()
transform.PostMultiply()
transform.RotateX(rotx)
transform.RotateY(roty)
transform.RotateZ(rotz)
transform.Translate(transx, transy, transz)
transform_filt = vtk.vtkTransformPolyDataFilter()
transform_filt.SetTransform(transform)
transform_filt.SetInputConnection(poly_normals.GetOutputPort())
transform_filt.Update()
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
if replace:
mapper.SetInput(transform_filt.GetOutput())
else:
mapper.SetInput(poly_normals.GetOutput())
else:
if replace:
mapper.SetInputConnection(transform_filt.GetOutputPort())
else:
mapper.SetInputConnection(poly_normals.GetOutputPort())
mapper.ScalarVisibilityOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetOpacity(opacity)
actor.SetVisibility(visibility)
if colour:
if type(colour) is str:
actor.GetProperty().SetDiffuseColor(
vtk_colors.GetColor3d("SkinColor"))
actor.GetProperty().SetSpecular(.3)
actor.GetProperty().SetSpecularPower(20)
else:
actor.GetProperty().SetColor(colour)
if position:
actor.SetPosition(position)
matrix_vtk = vtk.vtkMatrix4x4()
for row in range(0, 4):
for col in range(0, 4):
matrix_vtk.SetElement(row, col, user_matrix[row, col])
actor.SetUserMatrix(matrix_vtk)
# Assign actor to the renderer
ren.AddActor(actor)
return actor
def CurvaturesDemo(self):
# 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()
ctf.AddRGBPoint(0.0, 0.230, 0.299, 0.754)
ctf.AddRGBPoint(1.0, 0.706, 0.016, 0.150)
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(10)
textProperty.SetJustificationToCentered()
names = [
'Torus - Gaussian Curvature', 'Torus - Mean Curvature',
'Gaussian Curvature', '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(150, 16)
renderers.append(vtk.vtkRenderer())
gridDimensions = 2
for idx in range(len(sources)):
if idx < gridDimensions * gridDimensions:
renderers.append(vtk.vtkRenderer)
rendererSize = 300
# 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(sources) - 1):
continue
renderers[idx].SetViewport(viewport)
renderWindow.AddRenderer(renderers[idx])
renderers[idx].AddActor(actors[idx])
renderers[idx].AddActor(textactors[idx])
renderers[idx].SetBackground(0.4, 0.3, 0.2)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
reader = vtk.vtkJPEGReader() reader.SetFileName(VTK_DATA_ROOT + "/Data/beach.jpg") #--------------------------------------------------------- # Do the surface rendering sphereSource = vtk.vtkSphereSource() sphereSource.SetRadius(100) textureSphere = vtk.vtkTextureMapToSphere() textureSphere.SetInputConnection(sphereSource.GetOutputPort()) sphereStripper = vtk.vtkStripper() sphereStripper.SetInputConnection(textureSphere.GetOutputPort()) sphereStripper.SetMaximumLength(5) sphereMapper = vtk.vtkPolyDataMapper() sphereMapper.SetInputConnection(sphereStripper.GetOutputPort()) sphereMapper.ScalarVisibilityOff() sphereTexture = vtk.vtkTexture() sphereTexture.SetInputConnection(reader.GetOutputPort()) sphereProperty = vtk.vtkProperty() # sphereProperty.BackfaceCullingOn() sphere = vtk.vtkActor() sphere.SetMapper(sphereMapper) sphere.SetTexture(sphereTexture) sphere.SetProperty(sphereProperty) #--------------------------------------------------------- ren.AddViewProp(sphere)
sigma_test_list.append(Sigma_test[i, i])
test_points = vtk.vtkPoints()
for i in range(len(pt_test_list)):
test_points.InsertNextPoint(pt_test_list[i].pt[0], pt_test_list[i].pt[1],
pt_test_list[i].pt[2])
test_ptsPolyData = vtk.vtkPolyData()
test_ptsPolyData.SetPoints(test_points)
test_vertFilter = vtk.vtkVertexGlyphFilter()
test_vertFilter.SetInputData(test_ptsPolyData)
test_vertFilter.Update()
test_ptsMapper = vtk.vtkPolyDataMapper()
test_ptsMapper.SetInputData(test_vertFilter.GetOutput())
# Magenta - Gaussian Process
test_ptsActor = vtk.vtkActor()
test_ptsActor.SetMapper(test_ptsMapper)
test_ptsActor.GetProperty().SetPointSize(10)
test_ptsActor.GetProperty().SetColor(1, 0, 1)
test_ptsActor.GetProperty().SetOpacity(1.0)
test_ptsActor.GetProperty().SetRenderPointsAsSpheres(1)
#############################################
# There is something wrong with probability
# Maybe change it to the confidence interval with 2 sigma
#############################################
def render(self, pointsData, scalarsArray, radiusArray, nspecies,
colouringOptions, atomScaleFactor, lut, resolution):
"""
Render the given atoms.
"""
self._logger.debug("Rendering atoms: shape is '%s', colour by: '%s'",
self._shape, colouringOptions.colourBy)
# points
atomPoints = vtk.vtkPoints()
atomPoints.SetData(pointsData.getVTK())
# poly data
atomsPolyData = vtk.vtkPolyData()
atomsPolyData.SetPoints(atomPoints)
atomsPolyData.GetPointData().AddArray(scalarsArray.getVTK())
atomsPolyData.GetPointData().SetScalars(radiusArray.getVTK())
# glyph source
atomsGlyphSource = vtk.vtkSphereSource(
) # TODO: depends on self._shape
atomsGlyphSource.SetPhiResolution(resolution)
atomsGlyphSource.SetThetaResolution(resolution)
atomsGlyphSource.SetRadius(1.0)
# glyph
atomsGlyph = vtk.vtkGlyph3D()
if vtk.vtkVersion.GetVTKMajorVersion() <= 5:
atomsGlyph.SetSource(atomsGlyphSource.GetOutput())
atomsGlyph.SetInput(atomsPolyData)
else:
atomsGlyph.SetSourceConnection(atomsGlyphSource.GetOutputPort())
atomsGlyph.SetInputData(atomsPolyData)
atomsGlyph.SetScaleFactor(atomScaleFactor)
atomsGlyph.SetScaleModeToScaleByScalar()
atomsGlyph.ClampingOff()
# mapper
atomsMapper = vtk.vtkPolyDataMapper()
atomsMapper.SetInputConnection(atomsGlyph.GetOutputPort())
atomsMapper.SetLookupTable(lut)
atomsMapper.SetScalarModeToUsePointFieldData()
atomsMapper.SelectColorArray("colours")
utils.setMapperScalarRange(atomsMapper, colouringOptions, nspecies)
# glyph mapper
# glyphMapper = vtk.vtkGlyph3DMapper()
# if vtk.vtkVersion.GetVTKMajorVersion() <= 5:
# glyphMapper.SetInputConnection(atomsPolyData.GetProducerPort())
# else:
# glyphMapper.SetInputData(atomsPolyData)
# glyphMapper.SetSourceConnection(atomsGlyphSource.GetOutputPort())
# glyphMapper.SetScaleFactor(displayOptions.atomScaleFactor)
# glyphMapper.SetScaleModeToScaleByMagnitude()
# glyphMapper.ClampingOff()
# glyphMapper.SetLookupTable(lut)
# glyphMapper.SetScalarModeToUsePointFieldData()
# glyphMapper.SelectColorArray("colours")
# setMapperScalarRange(glyphMapper, colouringOptions, NSpecies)
# atomsMapper = glyphMapper
# actor
atomsActor = vtk.vtkActor()
atomsActor.SetMapper(atomsMapper)
atomsActor.GetProperty().SetSpecular(0.4)
atomsActor.GetProperty().SetSpecularPower(50)
# store attributes
self._actor = utils.ActorObject(atomsActor)
self._data["Points"] = pointsData
self._data["Scalars"] = scalarsArray
self._data["Radius"] = radiusArray
self._data["LUT"] = lut
self._data["Scale factor"] = atomScaleFactor
renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # create cones of varying resolution cone0 = vtk.vtkConeSource() cone0.SetResolution(0) cone1 = vtk.vtkConeSource() cone1.SetResolution(1) cone2 = vtk.vtkConeSource() cone2.SetResolution(2) cone8 = vtk.vtkConeSource() cone8.SetResolution(8) cone8.SetDirection(0, 0, 10) cone8.SetCenter(5, 0, 0) cone0Mapper = vtk.vtkPolyDataMapper() cone0Mapper.SetInputConnection(cone0.GetOutputPort()) cone0Actor = vtk.vtkActor() cone0Actor.SetMapper(cone0Mapper) cone1Mapper = vtk.vtkPolyDataMapper() cone1Mapper.SetInputConnection(cone1.GetOutputPort()) cone1Actor = vtk.vtkActor() cone1Actor.SetMapper(cone1Mapper) cone2Mapper = vtk.vtkPolyDataMapper() cone2Mapper.SetInputConnection(cone2.GetOutputPort()) cone2Actor = vtk.vtkActor() cone2Actor.SetMapper(cone2Mapper) cone8Mapper = vtk.vtkPolyDataMapper() cone8Mapper.SetInputConnection(cone8.GetOutputPort()) cone8Actor = vtk.vtkActor() cone8Actor.SetMapper(cone8Mapper)
print "Range of image: %d--%d" % (a1, b1)
filename2 = "ctscan_ez_bin.vtk"
reader2 = vtk.vtkStructuredPointsReader()
reader2.SetFileName(filename2)
reader2.Update()
a2, b2 = reader2.GetOutput().GetScalarRange()
print "Range of segmented image: %d--%d" % (a2, b2)
#Liver
liverFilter = vtk.vtkContourFilter()
liverFilter.SetInputConnection(reader2.GetOutputPort())
liverFilter.SetValue(0, 255.0)
liverMapper = vtk.vtkPolyDataMapper()
liverMapper.SetInputConnection(liverFilter.GetOutputPort())
liverMapper.SetScalarRange(0.0, 255.0)
lut = vtk.vtkLookupTable()
liverMapper.SetLookupTable(lut)
lut.SetHueRange(0.10, 0.10)
lut.Build()
liverActor = vtk.vtkActor()
liverActor.SetMapper(liverMapper)
#Info Text 1
showInfoText = vtk.vtkTextMapper()
showInfoText.SetInput(
"Press the following keys to move the planes\nNormal to X: G ; B \nNormal to Y: H ; N\nNormal to Z: J ; M"
def main():
points_reader = PointCloudReader("../0000000000.bin")
sphereSource = vtk.vtkSphereSource()
sphereSource.SetPhiResolution(30)
sphereSource.SetThetaResolution(30)
sphereSource.SetCenter(40, 40, 0)
sphereSource.SetRadius(20)
circleCutter = vtk.vtkCutter()
circleCutter.SetInputConnection(points_reader.GetOutputPort())
cutPlane = vtk.vtkPlane()
cutPlane.SetOrigin([0, 0, 0])
# cutPlane.SetOrigin(sphereSource.GetCenter())
cutPlane.SetNormal(0, 0, 1)
circleCutter.SetCutFunction(cutPlane)
stripper = vtk.vtkStripper()
stripper.SetInputConnection(circleCutter.GetOutputPort())
stripper.Update()
circle = stripper.GetOutput()
circle_actor = vtk.vtkActor()
circle_mapper = vtk.vtkPolyDataMapper()
circle_mapper.SetInputConnection(circleCutter.GetOutputPort())
circle_actor.SetMapper(circle_mapper)
polyDataWriter = vtk.vtkXMLPolyDataWriter()
polyDataWriter.SetInputData(circle)
polyDataWriter.SetFileName("circle.vtp")
polyDataWriter.SetCompressorTypeToNone()
polyDataWriter.SetDataModeToAscii()
polyDataWriter.Write()
whiteImage = vtk.vtkImageData()
bounds = circle.GetBounds()
spacing = [0.5, 0.5, 0.5]
whiteImage.SetSpacing(spacing)
dim = [0, 0, 0]
for i in range(3):
dim[i] = math.ceil(
(bounds[i * 2 + 1] - bounds[i * 2]) / spacing[i]) + 1
whiteImage.SetDimensions(dim)
whiteImage.SetExtent(0, dim[0] - 1, 0, dim[1] - 1, 0, dim[2] - 1)
origin = [bounds[0], bounds[1], bounds[2]]
whiteImage.SetOrigin(origin)
whiteImage.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
inval = 255
outval = 0
count = whiteImage.GetNumberOfPoints()
for i in range(count):
scalars = whiteImage.GetPointData().GetScalars()
# f = vtk.vtkFloatArray()
# f.SetV
scalars.SetValue(i, inval)
extruder = vtk.vtkLinearExtrusionFilter()
extruder.SetInputData(circle)
extruder.SetScaleFactor(1.)
extruder.SetVector(0, 0, 1)
extruder.Update()
pol2stenc = vtk.vtkPolyDataToImageStencil()
pol2stenc.SetTolerance(0)
pol2stenc.SetInputConnection(extruder.GetOutputPort())
pol2stenc.SetOutputOrigin(origin)
pol2stenc.SetOutputSpacing(spacing)
pol2stenc.SetOutputWholeExtent(whiteImage.GetExtent())
pol2stenc.Update()
imgstenc = vtk.vtkImageStencil()
imgstenc.SetInputData(whiteImage)
imgstenc.SetStencilConnection(pol2stenc.GetOutputPort())
imgstenc.ReverseStencilOff()
imgstenc.SetBackgroundValue(outval)
imgstenc.Update()
# mapper = vtk.vtkImageMapper()
# mapper.SetInputConnection(imgstenc.GetOutputPort())
imgactor = vtk.vtkImageActor()
imgactor.GetMapper().SetInputConnection(imgstenc.GetOutputPort())
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.1, 0.2, 0.4)
renderer.AddActor(imgactor)
renderer.AddActor(circle_actor)
# renderer.AddActor(actor)
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
style = vtk.vtkInteractorStyleImage()
interactor.SetInteractorStyle(style)
renderer.ResetCamera()
interactor.Start()
imageWriter = vtk.vtkMetaImageWriter()
imageWriter.SetFileName("labelImage.mhd")
imageWriter.SetInputConnection(imgstenc.GetOutputPort())
imageWriter.Write()
# The cut plane
plane = vtk.vtkPlane()
plane.SetOrigin(0, 0, 0)
plane.SetNormal(0, 0, -1)
# Clipper - single sphere with point data
clipper1 = vtk.vtkPolyDataPlaneClipper()
clipper1.SetInputConnection(ele1.GetOutputPort())
clipper1.SetPlane(plane)
clipper1.SetBatchSize(10000)
clipper1.CappingOn()
clipper1.Update()
# Display the clipped cells
mapper1 = vtk.vtkPolyDataMapper()
mapper1.SetInputConnection(clipper1.GetOutputPort())
mapper1.SetScalarRange(
clipper1.GetOutput().GetPointData().GetScalars().GetRange())
actor1 = vtk.vtkActor()
actor1.SetMapper(mapper1)
# Display the cap
capMapper1 = vtk.vtkPolyDataMapper()
capMapper1.SetInputConnection(clipper1.GetOutputPort(1))
capActor1 = vtk.vtkActor()
capActor1.SetMapper(capMapper1)
capActor1.GetProperty().SetColor(1, 0, 0)
for i in range(0, tableSize):
rgb = list(colorTransferFunction.GetColor(float(i) / tableSize)) + [0.5]
lut.SetTableValue(i, rgb)
# A plane for the seeds
plane = vtk.vtkPlaneSource()
plane.SetOrigin(0, 0, 0)
plane.SetPoint1(xma, 0, 0)
plane.SetPoint2(0, 0, zma)
plane.SetXResolution(20)
plane.SetYResolution(20)
# Add the outline of the plane
outline = vtk.vtkOutlineFilter()
outline.SetInputData(plane.GetOutput())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(1, 1, 1)
# Compute streamlines
streamline = vtk.vtkStreamTracer()
streamline.SetSourceConnection(plane.GetOutputPort())
streamline.SetInputConnection(reader.GetOutputPort())
streamline.SetIntegrationDirectionToForward()
#streamline.SetIntegrationDirectionToBackward()
#streamline.SetIntegrationDirectionToBoth()
streamline.SetMaximumPropagation(1)
streamline.SetComputeVorticity(True)
transform1.Scale(1.3, 1.1, 0.8) transform2 = vtk.vtkTransform() transform2.Translate(0.3, 0.7, 0.1) transform2.Scale(1.0, 0.1, 1.8) transformer1 = vtk.vtkTransformPolyDataFilter() transformer1.SetInputConnection(sphere.GetOutputPort()) transformer1.SetTransform(transform1) transformer2 = vtk.vtkTransformPolyDataFilter() transformer2.SetInputConnection(sphere.GetOutputPort()) transformer2.SetTransform(transform2) # map these three shapes into the first renderer map1a = vtk.vtkPolyDataMapper() map1a.SetInputConnection(sphere.GetOutputPort()) Actor1a = vtk.vtkActor() Actor1a.SetMapper(map1a) Actor1a.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784) map1b = vtk.vtkPolyDataMapper() map1b.SetInputConnection(transformer1.GetOutputPort()) Actor1b = vtk.vtkActor() Actor1b.SetMapper(map1b) Actor1b.GetProperty().SetDiffuseColor(0.3882, 1.0000, 0.2784) map1c = vtk.vtkPolyDataMapper() map1c.SetInputConnection(transformer2.GetOutputPort())
def __init__(self, renderer):
pm.VtkVisualizer.__init__(self, renderer)
# -------- add the beam ----
# geometry
self.beam = vtk.vtkCubeSource()
self.beam.SetXLength(st.beam_length)
self.beam.SetYLength(st.beam_height)
self.beam.SetZLength(st.beam_depth)
# mapper
self.beam_Mapper = vtk.vtkPolyDataMapper()
self.beam_Mapper.SetInputConnection(self.beam.GetOutputPort())
# actor
self.beam_Actor = vtk.vtkLODActor()
self.beam_Actor.SetMapper(self.beam_Mapper)
self.beam_Actor.SetPosition(
0, -(st.cart_height / 2 + st.beam_height / 2), 0)
# make it look nice
self.beam_Prop = self.beam_Actor.GetProperty()
# RAL 9007, grey-aluminium
self.beam_Prop.SetColor(142 / 255, 142 / 255, 139 / 255)
self.ren.AddActor(self.beam_Actor)
# -------- add cart ----
# geometry
self.cart = vtk.vtkCubeSource()
self.cart.SetXLength(st.cart_length)
self.cart.SetYLength(st.cart_height)
self.cart.SetZLength(st.cart_depth)
# mapper
self.cart_Mapper = vtk.vtkPolyDataMapper()
self.cart_Mapper.SetInputConnection(self.cart.GetOutputPort())
# actor
self.cart_Actor = vtk.vtkLODActor()
self.cart_Actor.SetPosition(0, 0, 0)
self.cart_Actor.RotateWXYZ(0, 1, 0, 0)
self.cart_Actor.SetMapper(self.cart_Mapper)
# make it look nice
self.cart_Prop = self.cart_Actor.GetProperty()
# RAL 7011, iron-grey
self.cart_Prop.SetColor(64 / 255, 74 / 255, 84 / 255)
self.ren.AddActor(self.cart_Actor)
# save pose
self.cart_pose = [np.array([0, 0, 0]), np.eye(3)]
# -------- add axis ----
# geometry
self.axis = vtk.vtkCylinderSource()
self.axis.SetHeight(st.axis_height)
self.axis.SetRadius(st.axis_radius)
self.axis.SetResolution(100)
# mapper
self.axis_Mapper = vtk.vtkPolyDataMapper()
self.axis_Mapper.SetInputConnection(self.axis.GetOutputPort())
# actor
self.axis_Actor = vtk.vtkLODActor()
self.axis_Actor.SetPosition(0, 0,
st.cart_depth / 2 + st.axis_height / 2)
self.axis_Actor.RotateWXYZ(90, 1, 0, 0)
self.axis_Actor.SetMapper(self.axis_Mapper)
# make it look nice
self.axis_Prop = self.axis_Actor.GetProperty()
# RAL 7011, iron-grey
self.axis_Prop.SetColor(64 / 255, 74 / 255, 84 / 255)
self.ren.AddActor(self.axis_Actor)
# save pose
self.axis_pose = [
np.array([0, 0, st.cart_depth / 2 + st.axis_height / 2]),
pm.rotation_matrix_xyz("x", 90, "deg")
]
# -------- add short pendulum ----
# add short pendulum shaft
# geometry
self.short_pendulum_shaft = vtk.vtkCylinderSource()
self.short_pendulum_shaft.SetHeight(st.pendulum_shaft_height)
self.short_pendulum_shaft.SetRadius(st.pendulum_shaft_radius)
self.short_pendulum_shaft.SetResolution(100)
# mapper
self.short_pendulum_shaft_Mapper = vtk.vtkPolyDataMapper()
self.short_pendulum_shaft_Mapper.SetInputConnection(
self.short_pendulum_shaft.GetOutputPort())
# actor
self.short_pendulum_shaft_Actor = vtk.vtkLODActor()
self.short_pendulum_shaft_Actor.SetPosition(
0, 0, st.cart_depth / 2 + st.axis_height +
st.pendulum_shaft_height / 2)
self.short_pendulum_shaft_Actor.RotateWXYZ(90, 1, 0, 0)
self.short_pendulum_shaft_Actor.SetMapper(
self.short_pendulum_shaft_Mapper)
# make it look nice
self.short_pendulum_shaft_Prop = \
self.short_pendulum_shaft_Actor.GetProperty()
# RAL 9007, grey-aluminium, a little bit darker
self.short_pendulum_shaft_Prop.SetColor(122 / 255, 122 / 255,
119 / 255)
self.ren.AddActor(self.short_pendulum_shaft_Actor)
# save pose
self.short_pendulum_shaft_pose = [
np.array([
0, 0, st.cart_depth / 2 + st.axis_height +
st.pendulum_shaft_height / 2
]),
pm.rotation_matrix_xyz("x", 90, "deg")
]
# add short pendulum
# geometry
self.short_pendulum = vtk.vtkCylinderSource()
self.short_pendulum.SetHeight(st.short_pendulum_height)
self.short_pendulum.SetRadius(st.short_pendulum_radius)
self.short_pendulum.SetResolution(100)
# mapper
self.short_pendulum_Mapper = vtk.vtkPolyDataMapper()
self.short_pendulum_Mapper.SetInputConnection(
self.short_pendulum.GetOutputPort())
# actor
self.short_pendulum_Actor = vtk.vtkLODActor()
self.short_pendulum_Actor.SetPosition(
0, st.short_pendulum_height / 2, st.cart_depth / 2 +
st.axis_height + st.pendulum_shaft_height / 2)
self.short_pendulum_Actor.RotateWXYZ(0, 1, 0, 0)
self.short_pendulum_Actor.SetMapper(self.short_pendulum_Mapper)
# make it look nice
self.short_pendulum_Prop = self.short_pendulum_Actor.GetProperty()
# RAL 9007, grey-aluminium, a little bit darker
self.short_pendulum_Prop.SetColor(122 / 255, 122 / 255, 119 / 255)
self.ren.AddActor(self.short_pendulum_Actor)
self.short_pendulum_pose = [
np.array([
0, st.short_pendulum_height / 2, st.cart_depth / 2 +
st.axis_height + st.pendulum_shaft_height / 2
]),
np.eye(3)
]
# add short pendulum weight
# geometry
self.short_pendulum_weight = vtk.vtkCylinderSource()
self.short_pendulum_weight.SetHeight(st.pendulum_weight_height)
self.short_pendulum_weight.SetRadius(st.pendulum_weight_radius)
self.short_pendulum_weight.SetResolution(100)
# mapper
self.short_pendulum_weight_Mapper = vtk.vtkPolyDataMapper()
self.short_pendulum_weight_Mapper.SetInputConnection(
self.short_pendulum_weight.GetOutputPort())
# actor
self.short_pendulum_weight_Actor = vtk.vtkLODActor()
self.short_pendulum_weight_Actor.SetPosition(
0, (st.short_pendulum_height + st.pendulum_weight_height / 2),
st.cart_depth / 2 + st.axis_height +
st.pendulum_shaft_height / 2)
self.short_pendulum_weight_Actor.RotateWXYZ(0, 1, 0, 0)
self.short_pendulum_weight_Actor.SetMapper(
self.short_pendulum_weight_Mapper)
# make it look nice
self.short_pendulum_weight_Prop \
= self.short_pendulum_weight_Actor.GetProperty()
# RAL 9006, white-aluminium
self.short_pendulum_weight_Prop.SetColor(162 / 255, 166 / 255,
164 / 255)
self.ren.AddActor(self.short_pendulum_weight_Actor)
self.short_pendulum_weight_pose = [
np.array([
0,
(st.short_pendulum_height + st.pendulum_weight_height / 2),
st.cart_depth / 2 + st.axis_height +
st.pendulum_shaft_height / 2
]),
np.eye(3)
]
# -------- add long pendulum ----
# add long pendulum shaft
# geometry
self.long_pendulum_shaft = vtk.vtkCylinderSource()
self.long_pendulum_shaft.SetHeight(st.pendulum_shaft_height)
self.long_pendulum_shaft.SetRadius(st.pendulum_shaft_radius)
self.long_pendulum_shaft.SetResolution(100)
# mapper
self.long_pendulum_shaft_Mapper = vtk.vtkPolyDataMapper()
self.long_pendulum_shaft_Mapper.SetInputConnection(
self.long_pendulum_shaft.GetOutputPort())
# actor
self.long_pendulum_shaft_Actor = vtk.vtkLODActor()
self.long_pendulum_shaft_Actor.SetPosition(
0, 0, st.cart_depth / 2 + st.axis_height +
st.pendulum_shaft_height + st.pendulum_shaft_height / 2)
self.long_pendulum_shaft_Actor.RotateWXYZ(90, 1, 0, 0)
self.long_pendulum_shaft_Actor.SetMapper(
self.long_pendulum_shaft_Mapper)
# make it look nice
self.long_pendulum_shaft_Prop =\
self.long_pendulum_shaft_Actor.GetProperty()
# RAL 9007, grey-aluminium
self.long_pendulum_shaft_Prop.SetColor(142 / 255, 142 / 255,
139 / 255)
self.ren.AddActor(self.long_pendulum_shaft_Actor)
# save pose
self.long_pendulum_shaft_pose = [
np.array([
0, 0, st.cart_depth / 2 + st.axis_height +
st.pendulum_shaft_height + st.pendulum_shaft_height / 2
]),
pm.rotation_matrix_xyz("x", 90, "deg")
]
# add long pendulum
# geometry
self.long_pendulum = vtk.vtkCylinderSource()
self.long_pendulum.SetHeight(st.long_pendulum_height)
self.long_pendulum.SetRadius(st.long_pendulum_radius)
self.long_pendulum.SetResolution(100)
# mapper
self.long_pendulum_Mapper = vtk.vtkPolyDataMapper()
self.long_pendulum_Mapper.SetInputConnection(
self.long_pendulum.GetOutputPort())
# actor
self.long_pendulum_Actor = vtk.vtkLODActor()
self.long_pendulum_Actor.SetPosition(
0, st.long_pendulum_height / 2,
st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height +
st.pendulum_shaft_height / 2)
self.long_pendulum_Actor.RotateWXYZ(0, 1, 0, 0)
self.long_pendulum_Actor.SetMapper(self.long_pendulum_Mapper)
# make it look nice
self.long_pendulum_Prop = self.long_pendulum_Actor.GetProperty()
# RAL 9007, grey-aluminium
self.long_pendulum_Prop.SetColor(142 / 255, 142 / 255, 139 / 255)
self.ren.AddActor(self.long_pendulum_Actor)
self.long_pendulum_pose = [
np.array([
0, st.long_pendulum_height / 2,
st.cart_depth / 2 + st.axis_height +
st.pendulum_shaft_height + st.pendulum_shaft_height / 2
]),
np.eye(3)
]
# add long pendulum weight
# geometry
self.long_pendulum_weight = vtk.vtkCylinderSource()
self.long_pendulum_weight.SetHeight(st.pendulum_weight_height)
self.long_pendulum_weight.SetRadius(st.pendulum_weight_radius)
self.long_pendulum_weight.SetResolution(100)
# mapper
self.long_pendulum_weight_Mapper = vtk.vtkPolyDataMapper()
self.long_pendulum_weight_Mapper.SetInputConnection(
self.long_pendulum_weight.GetOutputPort())
# actor
self.long_pendulum_weight_Actor = vtk.vtkLODActor()
self.long_pendulum_weight_Actor.SetPosition(
0, st.long_pendulum_height + st.pendulum_weight_height / 2,
st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height +
st.pendulum_shaft_height / 2)
self.long_pendulum_weight_Actor.RotateWXYZ(0, 1, 0, 0)
self.long_pendulum_weight_Actor.SetMapper(
self.long_pendulum_weight_Mapper)
# make it look nice
self.long_pendulum_weight_Prop \
= self.long_pendulum_weight_Actor.GetProperty()
# RAL 9006, white-aluminium
self.long_pendulum_weight_Prop.SetColor(162 / 255, 166 / 255,
164 / 255)
self.ren.AddActor(self.long_pendulum_weight_Actor)
self.long_pendulum_weight_pose = [
np.array([
0, st.long_pendulum_height + st.pendulum_weight_height / 2,
st.cart_depth / 2 + st.axis_height +
st.pendulum_shaft_height + st.pendulum_shaft_height / 2
]),
np.eye(3)
]
# add background
self.ren.GradientBackgroundOn()
self.ren.SetBackground(228 / 255, 232 / 255, 213 / 255)
self.ren.SetBackground2(38 / 255, 139 / 255, 210 / 255)
# get everybody into the frame
self.ren.ResetCamera()
self.ren.GetActiveCamera().Zoom(1.45)
self.ren.GetActiveCamera().SetFocalPoint(0, 0, 0)
# save this view
self.save_camera_pose()
elevation16 = vtk.vtkElevationFilter() elevation16.SetInputConnection(warp16.GetOutputPort()) elevation16.SetLowPoint(0, 0, lo) elevation16.SetHighPoint(0, 0, hi) elevation16.SetScalarRange(lo, hi) elevation16.ReleaseDataFlagOn() normals16 = vtk.vtkPolyDataNormals() normals16.SetInputConnection(elevation16.GetOutputPort()) normals16.SetFeatureAngle(60) normals16.ConsistencyOff() normals16.SplittingOff() normals16.ReleaseDataFlagOn() demMapper16 = vtk.vtkPolyDataMapper() demMapper16.SetInputConnection(normals16.GetOutputPort()) demMapper16.SetScalarRange(lo, hi) demMapper16.SetLookupTable(lut) demMapper16.Update() demActor.AddLODMapper(demMapper16) # Create the RenderWindow, Renderer and both Actors # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) t = vtk.vtkInteractorStyleTerrain()
def main():
file_name = get_program_parameters()
colors = vtk.vtkNamedColors()
# Set the background color and plate color. Match those in VTKTextbook.pdf.
bkg = map(lambda x: x / 255.0, [65, 99, 149])
bar = map(lambda x: x / 255.0, [255, 160, 140])
colors.SetColor("BkgColor", *bkg)
colors.SetColor("PlateColor", *bar)
# Read a vtk file
#
plate = vtk.vtkPolyDataReader()
plate.SetFileName(file_name)
plate.Update()
bounds = [0] * 6
plate.GetOutput().GetBounds(bounds)
plate.SetVectorsName("mode2")
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(plate.GetOutputPort())
warp = vtk.vtkWarpVector()
warp.SetInputConnection(normals.GetOutputPort())
warp.SetScaleFactor(0.5)
color = vtk.vtkVectorDot()
color.SetInputConnection(warp.GetOutputPort())
plateMapper = vtk.vtkDataSetMapper()
plateMapper.SetInputConnection(warp.GetOutputPort())
plateActor = vtk.vtkActor()
plateActor.SetMapper(plateMapper)
plateActor.GetProperty().SetColor(colors.GetColor3d("PlateColor"))
plateActor.RotateX(-90)
# Create the outline.
#
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(plate.GetOutputPort())
spikeMapper = vtk.vtkPolyDataMapper()
spikeMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(spikeMapper)
outlineActor.RotateX(-90)
outlineActor.GetProperty().SetColor(colors.GetColor3d("White"))
# Create the RenderWindow, Renderer and both Actors
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
#
ren.AddActor(plateActor)
ren.AddActor(outlineActor)
renWin.SetSize(500, 500)
# Render the image.
renWin.Render()
ren.SetBackground(colors.GetColor3d("BkgColor"))
# This closely matches the original illustration.
ren.GetActiveCamera().SetPosition(-3.7, 13, 15.5)
ren.ResetCameraClippingRange()
renWin.Render()
iren.Start()
transform = vtk.vtkTransform() transform.RotateX(90) # triangulate the data using the specified transform # del1 = vtk.vtkDelaunay2D() del1.SetInputData(profile) del1.SetTransform(transform) del1.BoundingTriangulationOff() del1.SetTolerance(0.001) del1.SetAlpha(0.0) shrink = vtk.vtkShrinkPolyData() shrink.SetInputConnection(del1.GetOutputPort()) map = vtk.vtkPolyDataMapper() map.SetInputConnection(shrink.GetOutputPort()) triangulation = vtk.vtkActor() triangulation.SetMapper(map) triangulation.GetProperty().SetColor(1, 0, 0) triangulation.GetProperty().BackfaceCullingOn() # Add the actors to the renderer, set the background and size # ren1.AddActor(triangulation) ren1.SetBackground(1, 1, 1) renWin.SetSize(300, 300) renWin.Render()
polys.InsertCellPoint(9) polys.InsertCellPoint(10) pd.SetPoints(pts) pd.SetPolys(polys) transform = vtk.vtkTransform() transform.RotateZ(17) transform.Translate(0.1, 0, 0) xform = vtk.vtkTransformPolyDataFilter() xform.SetInputData(pd) xform.SetTransform(transform) # Rasterize through the renderer mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(xform.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(1, 0, 0) renWin.SetSize(50, 50) ren1.AddActor(actor) renWin.Render() renSource = vtk.vtkWindowToImageFilter() renSource.SetInput(renWin) renSource.Update() # This trick decouples the pipeline so that updates
#!/usr/bin/env python import vtk # Sphere sphereSource = vtk.vtkSphereSource() sphereSource.SetCenter(-4.0, 0.0, 0.0) sphereSource.SetRadius(4.0) sphereMapper = vtk.vtkPolyDataMapper() sphereMapper.SetInputConnection(sphereSource.GetOutputPort()) sphereActor = vtk.vtkActor() sphereActor.SetMapper(sphereMapper) # Regular Polygon regularPolygonSource = vtk.vtkRegularPolygonSource() regularPolygonSource.SetCenter(4.0, 0.0, 0.0) regularPolygonSource.SetRadius(4.0) regularPolygonMapper = vtk.vtkPolyDataMapper() regularPolygonMapper.SetInputConnection(regularPolygonSource.GetOutputPort()) regularPolygonActor = vtk.vtkActor() regularPolygonActor.SetMapper(regularPolygonMapper) # A renderer and render window renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) # An interactor
def main():
xyzFn, qFn = get_program_parameters()
colors = vtk.vtkNamedColors()
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(xyzFn)
pl3d.SetQFileName(qFn)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
pl3dOutput = pl3d.GetOutput().GetBlock(0)
plane = vtk.vtkStructuredGridGeometryFilter()
plane.SetInputData(pl3dOutput)
plane.SetExtent(1, 100, 1, 100, 7, 7)
lut = vtk.vtkLookupTable()
planeMapper = vtk.vtkPolyDataMapper()
planeMapper.SetLookupTable(lut)
planeMapper.SetInputConnection(plane.GetOutputPort())
planeMapper.SetScalarRange(pl3dOutput.GetScalarRange())
planeActor = vtk.vtkActor()
planeActor.SetMapper(planeMapper)
# This creates an outline around the data.
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3dOutput)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
# Much of the following is commented out. To try different lookup tables,
# uncomment the appropriate portions.
#
# This creates a black to white lut.
# lut.SetHueRange(0, 0)
# lut.SetSaturationRange(0, 0)
# lut.SetValueRange(0.2, 1.0)
# This creates a red to blue lut.
# lut.SetHueRange(0.0, 0.667)
# This creates a blue to red lut.
# lut.SetHueRange(0.667, 0.0)
# This creates a weird effect. The Build() method causes the lookup table
# to allocate memory and create a table based on the correct hue, saturation,
# value, and alpha (transparency) range. Here we then manually overwrite the
# values generated by the Build() method.
lut.SetNumberOfColors(256)
lut.SetHueRange(0.0, 0.667)
lut.Build()
# Create the RenderWindow, Renderer and both Actors.
#
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)
ren1.AddActor(planeActor)
ren1.SetBackground(colors.GetColor3d("SlateGray"))
ren1.TwoSidedLightingOff()
renWin.SetSize(512, 512)
iren.Initialize()
cam1 = ren1.GetActiveCamera()
cam1.SetClippingRange(3.95297, 50)
cam1.SetFocalPoint(8.88908, 0.595038, 29.3342)
cam1.SetPosition(-12.3332, 31.7479, 41.2387)
cam1.SetViewUp(0.060772, -0.319905, 0.945498)
iren.Start()
def AddNewActor(self, pubsub_evt):
"""
Create surface actor, save into project and send it to viewer.
"""
slice_, mask, surface_parameters = pubsub_evt.data
matrix = slice_.matrix
filename_img = slice_.matrix_filename
spacing = slice_.spacing
algorithm = surface_parameters['method']['algorithm']
options = surface_parameters['method']['options']
surface_name = surface_parameters['options']['name']
quality = surface_parameters['options']['quality']
fill_holes = surface_parameters['options']['fill']
keep_largest = surface_parameters['options']['keep_largest']
mode = 'CONTOUR' # 'GRAYSCALE'
min_value, max_value = mask.threshold_range
colour = mask.colour
try:
overwrite = surface_parameters['options']['overwrite']
except KeyError:
overwrite = False
mask.matrix.flush()
if quality in const.SURFACE_QUALITY.keys():
imagedata_resolution = const.SURFACE_QUALITY[quality][0]
smooth_iterations = const.SURFACE_QUALITY[quality][1]
smooth_relaxation_factor = const.SURFACE_QUALITY[quality][2]
decimate_reduction = const.SURFACE_QUALITY[quality][3]
#if imagedata_resolution:
#imagedata = iu.ResampleImage3D(imagedata, imagedata_resolution)
pipeline_size = 4
if decimate_reduction:
pipeline_size += 1
if (smooth_iterations and smooth_relaxation_factor):
pipeline_size += 1
if fill_holes:
pipeline_size += 1
if keep_largest:
pipeline_size += 1
## Update progress value in GUI
UpdateProgress = vu.ShowProgress(pipeline_size)
UpdateProgress(0, _("Creating 3D surface..."))
language = ses.Session().language
if (prj.Project().original_orientation == const.CORONAL):
flip_image = False
else:
flip_image = True
n_processors = multiprocessing.cpu_count()
pipe_in, pipe_out = multiprocessing.Pipe()
o_piece = 1
piece_size = 2000
n_pieces = int(round(matrix.shape[0] / piece_size + 0.5, 0))
q_in = multiprocessing.Queue()
q_out = multiprocessing.Queue()
p = []
for i in xrange(n_processors):
sp = surface_process.SurfaceProcess(
pipe_in, filename_img, matrix.shape, matrix.dtype,
mask.temp_file, mask.matrix.shape, mask.matrix.dtype, spacing,
mode, min_value, max_value, decimate_reduction,
smooth_relaxation_factor, smooth_iterations, language,
flip_image, q_in, q_out, algorithm != 'Default', algorithm,
imagedata_resolution)
p.append(sp)
sp.start()
for i in xrange(n_pieces):
init = i * piece_size
end = init + piece_size + o_piece
roi = slice(init, end)
q_in.put(roi)
print "new_piece", roi
for i in p:
q_in.put(None)
none_count = 1
while 1:
msg = pipe_out.recv()
if (msg is None):
none_count += 1
else:
UpdateProgress(msg[0] / (n_pieces * pipeline_size), msg[1])
if none_count > n_pieces:
break
polydata_append = vtk.vtkAppendPolyData()
# polydata_append.ReleaseDataFlagOn()
t = n_pieces
while t:
filename_polydata = q_out.get()
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(filename_polydata)
# reader.ReleaseDataFlagOn()
reader.Update()
# reader.GetOutput().ReleaseDataFlagOn()
polydata = reader.GetOutput()
# polydata.SetSource(None)
polydata_append.AddInputData(polydata)
del reader
del polydata
t -= 1
polydata_append.Update()
# polydata_append.GetOutput().ReleaseDataFlagOn()
polydata = polydata_append.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
del polydata_append
if algorithm == 'ca_smoothing':
normals = vtk.vtkPolyDataNormals()
normals_ref = weakref.ref(normals)
normals_ref().AddObserver(
"ProgressEvent", lambda obj, evt: UpdateProgress(
normals_ref(), _("Creating 3D surface...")))
normals.SetInputData(polydata)
# normals.ReleaseDataFlagOn()
#normals.SetFeatureAngle(80)
#normals.AutoOrientNormalsOn()
normals.ComputeCellNormalsOn()
# normals.GetOutput().ReleaseDataFlagOn()
normals.Update()
del polydata
polydata = normals.GetOutput()
# polydata.SetSource(None)
del normals
clean = vtk.vtkCleanPolyData()
# clean.ReleaseDataFlagOn()
# clean.GetOutput().ReleaseDataFlagOn()
clean_ref = weakref.ref(clean)
clean_ref().AddObserver(
"ProgressEvent", lambda obj, evt: UpdateProgress(
clean_ref(), _("Creating 3D surface...")))
clean.SetInputData(polydata)
clean.PointMergingOn()
clean.Update()
del polydata
polydata = clean.GetOutput()
# polydata.SetSource(None)
del clean
try:
polydata.BuildLinks()
except TypeError:
polydata.BuildLinks(0)
polydata = ca_smoothing.ca_smoothing(polydata, options['angle'],
options['max distance'],
options['min weight'],
options['steps'])
# polydata.SetSource(None)
# polydata.DebugOn()
else:
#smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother = vtk.vtkSmoothPolyDataFilter()
smoother_ref = weakref.ref(smoother)
smoother_ref().AddObserver(
"ProgressEvent", lambda obj, evt: UpdateProgress(
smoother_ref(), _("Creating 3D surface...")))
smoother.SetInputData(polydata)
smoother.SetNumberOfIterations(smooth_iterations)
smoother.SetRelaxationFactor(smooth_relaxation_factor)
smoother.SetFeatureAngle(80)
#smoother.SetEdgeAngle(90.0)
#smoother.SetPassBand(0.1)
smoother.BoundarySmoothingOn()
smoother.FeatureEdgeSmoothingOn()
#smoother.NormalizeCoordinatesOn()
#smoother.NonManifoldSmoothingOn()
# smoother.ReleaseDataFlagOn()
# smoother.GetOutput().ReleaseDataFlagOn()
smoother.Update()
del polydata
polydata = smoother.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
del smoother
if decimate_reduction:
print "Decimating", decimate_reduction
decimation = vtk.vtkQuadricDecimation()
# decimation.ReleaseDataFlagOn()
decimation.SetInputData(polydata)
decimation.SetTargetReduction(decimate_reduction)
decimation_ref = weakref.ref(decimation)
decimation_ref().AddObserver(
"ProgressEvent", lambda obj, evt: UpdateProgress(
decimation_ref(), _("Creating 3D surface...")))
#decimation.PreserveTopologyOn()
#decimation.SplittingOff()
#decimation.BoundaryVertexDeletionOff()
# decimation.GetOutput().ReleaseDataFlagOn()
decimation.Update()
del polydata
polydata = decimation.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
del decimation
to_measure = polydata
#to_measure.Register(None)
# to_measure.SetSource(None)
if keep_largest:
conn = vtk.vtkPolyDataConnectivityFilter()
conn.SetInputData(polydata)
conn.SetExtractionModeToLargestRegion()
conn_ref = weakref.ref(conn)
conn_ref().AddObserver(
"ProgressEvent", lambda obj, evt: UpdateProgress(
conn_ref(), _("Creating 3D surface...")))
conn.Update()
# conn.GetOutput().ReleaseDataFlagOn()
del polydata
polydata = conn.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
del conn
#Filter used to detect and fill holes. Only fill boundary edges holes.
#TODO: Hey! This piece of code is the same from
#polydata_utils.FillSurfaceHole, we need to review this.
if fill_holes:
filled_polydata = vtk.vtkFillHolesFilter()
# filled_polydata.ReleaseDataFlagOn()
filled_polydata.SetInputData(polydata)
filled_polydata.SetHoleSize(300)
filled_polydata_ref = weakref.ref(filled_polydata)
filled_polydata_ref().AddObserver(
"ProgressEvent", lambda obj, evt: UpdateProgress(
filled_polydata_ref(), _("Creating 3D surface...")))
filled_polydata.Update()
# filled_polydata.GetOutput().ReleaseDataFlagOn()
del polydata
polydata = filled_polydata.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
# polydata.DebugOn()
del filled_polydata
normals = vtk.vtkPolyDataNormals()
# normals.ReleaseDataFlagOn()
normals_ref = weakref.ref(normals)
normals_ref().AddObserver(
"ProgressEvent", lambda obj, evt: UpdateProgress(
normals_ref(), _("Creating 3D surface...")))
normals.SetInputData(polydata)
normals.SetFeatureAngle(80)
normals.AutoOrientNormalsOn()
# normals.GetOutput().ReleaseDataFlagOn()
normals.Update()
del polydata
polydata = normals.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
del normals
# Improve performance
stripper = vtk.vtkStripper()
# stripper.ReleaseDataFlagOn()
stripper_ref = weakref.ref(stripper)
stripper_ref().AddObserver(
"ProgressEvent", lambda obj, evt: UpdateProgress(
stripper_ref(), _("Creating 3D surface...")))
stripper.SetInputData(polydata)
stripper.PassThroughCellIdsOn()
stripper.PassThroughPointIdsOn()
# stripper.GetOutput().ReleaseDataFlagOn()
stripper.Update()
del polydata
polydata = stripper.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
del stripper
# Map polygonal data (vtkPolyData) to graphics primitives.
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(polydata)
mapper.ScalarVisibilityOff()
# mapper.ReleaseDataFlagOn()
mapper.ImmediateModeRenderingOn() # improve performance
# Represent an object (geometry & properties) in the rendered scene
actor = vtk.vtkActor()
actor.SetMapper(mapper)
del mapper
#Create Surface instance
if overwrite:
surface = Surface(index=self.last_surface_index)
else:
surface = Surface(name=surface_name)
surface.colour = colour
surface.polydata = polydata
del polydata
# Set actor colour and transparency
actor.GetProperty().SetColor(colour)
actor.GetProperty().SetOpacity(1 - surface.transparency)
prop = actor.GetProperty()
interpolation = int(ses.Session().surface_interpolation)
prop.SetInterpolation(interpolation)
proj = prj.Project()
if overwrite:
proj.ChangeSurface(surface)
else:
index = proj.AddSurface(surface)
surface.index = index
self.last_surface_index = index
session = ses.Session()
session.ChangeProject()
# The following lines have to be here, otherwise all volumes disappear
measured_polydata = vtk.vtkMassProperties()
# measured_polydata.ReleaseDataFlagOn()
measured_polydata.SetInputData(to_measure)
volume = float(measured_polydata.GetVolume())
area = float(measured_polydata.GetSurfaceArea())
surface.volume = volume
surface.area = area
self.last_surface_index = surface.index
del measured_polydata
del to_measure
Publisher.sendMessage('Load surface actor into viewer', actor)
# Send actor by pubsub to viewer's render
if overwrite and self.actors_dict.keys():
old_actor = self.actors_dict[self.last_surface_index]
Publisher.sendMessage('Remove surface actor from viewer',
old_actor)
# Save actor for future management tasks
self.actors_dict[surface.index] = actor
Publisher.sendMessage(
'Update surface info in GUI',
(surface.index, surface.name, surface.colour, surface.volume,
surface.area, surface.transparency))
#When you finalize the progress. The bar is cleaned.
UpdateProgress = vu.ShowProgress(1)
UpdateProgress(0, _("Ready"))
Publisher.sendMessage('Update status text in GUI', _("Ready"))
Publisher.sendMessage('End busy cursor')
del actor
