def CreateCircle(radius): circleSource = vtkRegularPolygonSource() circleSource.SetNumberOfSides(32) circleSource.SetRadius(radius) circleSource.SetGeneratePolygon(False) circleMapper = vtkPolyDataMapper() circleMapper.SetInputConnection(circleSource.GetOutputPort()) circle = vtkActor() circle.PickableOff() circle.SetMapper(circleMapper) circle.GetProperty().SetColor(1.0, 0.5, 0.5) return circle
def __init__(self): self.poly_list = [] self.actor_list = [] # Create shapes and actors boxUp = vtk.vtkRegularPolygonSource() boxUp.GeneratePolygonOn() boxUp.GeneratePolylineOff() boxUp.SetNumberOfSides(3) boxUp.SetCenter(0,14,0) boxUp.SetRadius(11) self.poly_list.append(boxUp) boxL = vtk.vtkRegularPolygonSource() boxL.GeneratePolygonOn() boxL.GeneratePolylineOff() boxL.SetNumberOfSides(4) boxL.SetCenter(-15,-2,0) boxL.SetRadius(9) self.poly_list.append(boxL) boxR = vtk.vtkRegularPolygonSource() boxR.GeneratePolygonOn() boxR.GeneratePolylineOff() boxR.SetNumberOfSides(4) boxR.SetCenter(15,-2,0) boxR.SetRadius(9) self.poly_list.append(boxR) boxLDown = vtk.vtkRegularPolygonSource() boxLDown.GeneratePolygonOn() boxLDown.GeneratePolylineOff() boxLDown.SetNumberOfSides(6) boxLDown.SetCenter(-12,-22,0) boxLDown.SetRadius(9) self.poly_list.append(boxLDown) boxRDown = vtk.vtkRegularPolygonSource() boxRDown.GeneratePolygonOn() boxRDown.GeneratePolylineOff() boxRDown.SetNumberOfSides(6) boxRDown.SetCenter(12,-22,0) boxRDown.SetRadius(9) self.poly_list.append(boxRDown) for ii, poly in enumerate(self.poly_list): map = vtk.vtkPolyDataMapper2D() map.SetInputConnection(poly.GetOutputPort(0)) act = vtk.vtkActor2D() act.SetMapper(map) act.SetPickable(True) # act.GetProperty().SetColor(0.5, 0.45, 0.35) act.GetProperty().SetColor(0.4, 0.4, 0.4) act.GetProperty().SetLineWidth(0.0) act.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay() act.GetPositionCoordinate().SetValue(0.075 ,0.15) act.GetPosition2Coordinate().SetCoordinateSystemToNormalizedDisplay() act.GetPosition2Coordinate().SetValue(0.5, 0.5) self.actor_list.append(act)
def main():
colors = vtk.vtkNamedColors()
# Create a circle
polygonSource = vtk.vtkRegularPolygonSource()
# Comment this line to generate a disk instead of a circle.
polygonSource.GeneratePolygonOff()
polygonSource.SetNumberOfSides(50)
polygonSource.SetRadius(5.0)
polygonSource.SetCenter(0.0, 0.0, 0.0)
# Visualize
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(polygonSource.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(colors.GetColor3d('Cornsilk'))
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetWindowName("Circle")
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d('DarkGreen'))
renderWindow.Render()
renderWindowInteractor.Start()
def draw_circle(self):
""" Draw a circle at random coordinates in the window. """
#pylint:disable=attribute-defined-outside-init
# Generate random position and size
self.circle_radius = random.random() * 500 + 25
self.target_x = -400 + self.circle_radius \
+ (800 - 2*self.circle_radius) * random.random()
self.target_y = -260 + self.circle_radius\
+ (520 - 2*self.circle_radius) * random.random()
# Create a circle
polygon_source = vtk.vtkRegularPolygonSource()
# Comment this line to generate a disk instead of a circle.
polygon_source.GeneratePolygonOff()
polygon_source.SetNumberOfSides(50)
polygon_source.SetRadius(self.circle_radius)
polygon_source.SetCenter(self.target_x, self.target_y, 0.0)
# mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(polygon_source.GetOutputPort())
# actor
self.target_actor = vtk.vtkActor()
self.target_actor.SetMapper(mapper)
def createActorTubes(self, elements):
source = vtk.vtkAppendPolyData()
mapper = vtk.vtkPolyDataMapper()
actor = vtk.vtkActor()
for element in elements:
cross_section = element.cross_section
if cross_section and self.plotRadius:
polygon = self.createSectionPolygon(element)
else:
if self.defaultRadius is None:
base_length = self.project.preprocessor.structure_principal_diagonal
if element.length / 10 > base_length / 1000:
self.defaultRadius = element.length / 10
else:
self.defaultRadius = base_length / 1000
polygon = vtk.vtkRegularPolygonSource()
polygon.SetRadius(self.defaultRadius)
polygon.SetNumberOfSides(20)
tube = self.generalSectionTube(element, polygon.GetOutputPort())
source.AddInputData(tube.GetOutput())
mapper.SetInputConnection(source.GetOutputPort())
actor.SetMapper(mapper)
return actor
def Polygon(center=(0., 0., 0.), radius=1, normal=(0, 0, 1), n_sides=6):
"""Create a polygonal disk with a hole in the center.
The disk has zero height. The user can specify the inner and outer radius
of the disk, and the radial and circumferential resolution of the polygonal
representation.
Parameters
----------
center : np.ndarray or list
Center in [x, y, z]. middle of the axis of the polygon.
radius : float
The radius of the polygon
normal : np.ndarray or list
direction vector in [x, y, z]. orientation vector of the cone.
n_sides : int
Number of sides of the polygon
"""
src = vtk.vtkRegularPolygonSource()
src.SetCenter(center)
src.SetNumberOfSides(n_sides)
src.SetRadius(radius)
src.SetNormal(normal)
src.Update()
return pyvista.wrap(src.GetOutput())
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkRegularPolygonSource(), 'Processing.',
(), ('vtkPolyData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def main():
colors = vtk.vtkNamedColors()
# 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)
sphereActor.GetProperty().SetColor(colors.GetColor3d('MistyRose'))
# 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)
regularPolygonActor.GetProperty().SetColor(colors.GetColor3d('Cornsilk'))
# A renderer and render window
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetWindowName('BalloonWidget')
# An interactor
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
# Create the widget
balloonRep = vtk.vtkBalloonRepresentation()
balloonRep.SetBalloonLayoutToImageRight()
balloonWidget = vtk.vtkBalloonWidget()
balloonWidget.SetInteractor(renderWindowInteractor)
balloonWidget.SetRepresentation(balloonRep)
balloonWidget.AddBalloon(sphereActor, 'This is a sphere')
balloonWidget.AddBalloon(regularPolygonActor, 'This is a regular polygon')
# Add the actors to the scene
renderer.AddActor(sphereActor)
renderer.AddActor(regularPolygonActor)
renderer.SetBackground(colors.GetColor3d('SlateGray'))
# Render an image (lights and cameras are created automatically)
renderWindow.Render()
balloonWidget.EnabledOn()
# Begin mouse interaction
renderWindowInteractor.Start()
renderWindowInteractor.Initialize()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkRegularPolygonSource(),
'Processing.', (), ('vtkPolyData', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def polygon(pos=[0, 0, 0],
normal=[0, 0, 1],
nsides=6,
r=1,
c='coral',
bc='darkgreen',
lw=1,
alpha=1,
legend=None,
texture=None,
followcam=False,
camera=None):
'''
Build a 2D polygon of `nsides` of radius `r` oriented as `normal`.
If ``followcam=True`` the polygon will always reorient itself to current camera.
'''
ps = vtk.vtkRegularPolygonSource()
ps.SetNumberOfSides(nsides)
ps.SetRadius(r)
ps.SetNormal(-np.array(normal))
ps.Update()
tf = vtk.vtkTriangleFilter()
tf.SetInputConnection(ps.GetOutputPort())
tf.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(tf.GetOutputPort())
if followcam: # follow cam
actor = vtk.vtkFollower()
actor.SetCamera(camera)
if not camera:
colors.printc('Warning: vtkCamera does not yet exist for polygon',
c=5)
else:
actor = Actor() # vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(colors.getColor(c))
# check if color string contains a float, in this case ignore alpha
al = colors._getAlpha(c)
if al:
alpha = al
actor.GetProperty().SetOpacity(alpha)
actor.GetProperty().SetLineWidth(lw)
actor.GetProperty().SetInterpolationToFlat()
if bc: # defines a specific color for the backface
backProp = vtk.vtkProperty()
backProp.SetDiffuseColor(colors.getColor(bc))
backProp.SetOpacity(alpha)
actor.SetBackfaceProperty(backProp)
if texture:
actor.texture(texture)
actor.SetPosition(pos)
return actor
def __create_vtk_loop_rep(self, p): n = (0, -1/math.sqrt(2), 1/math.sqrt(2)) r = Settings.loop_radius vtk_circle_src = vtk.vtkRegularPolygonSource() vtk_circle_src.SetCenter(p[0] + r*n[0], p[1] - r*n[1], p[2] + r*n[2]) vtk_circle_src.SetNormal(n) vtk_circle_src.SetRadius(r) vtk_circle_src.GeneratePolygonOff() vtk_circle_src.SetNumberOfSides(40) vtk_circle_src.Update() return vtk_circle_src.GetOutput()
def showGrid(self):
self.grid = []
# latitude
tmp = self.addPart(ObjectBase(vtk.vtkRegularPolygonSource()))
tmp._source.SetGeneratePolyline(True)
tmp._source.SetGeneratePolygon(False)
tmp._source.SetNumberOfSides(self.res)
tmp._source.SetRadius(0.5 + self.height)
tmp._actor.GetProperty().SetColor(0.3, 0.3, 0.3)
self.grid.append(tmp)
for i in range(10, 90, 10):
u = i * math.pi / 180.0
h = (0.5 + self.height) * math.cos(u)
r = (0.5 + self.height) * math.cos(0.5*math.pi-u)
a = self.addPart(ObjectBase(vtk.vtkRegularPolygonSource()))
a._source.SetGeneratePolyline(True)
a._source.SetGeneratePolygon(False)
a._source.SetNumberOfSides(self.res)
a._source.SetRadius(r)
a._source.SetCenter(0.0, 0.0, h)
a._actor.GetProperty().SetColor(0.3, 0.3, 0.3)
self.grid.append(a)
b = self.addPart(ObjectBase(vtk.vtkRegularPolygonSource()))
b._source.SetGeneratePolyline(True)
b._source.SetGeneratePolygon(False)
b._source.SetNumberOfSides(self.res)
b._source.SetRadius(r)
b._source.SetCenter(0.0, 0.0, -h)
b._actor.GetProperty().SetColor(0.3, 0.3, 0.3)
self.grid.append(b)
# longitude
for i in range(0, 180, 10):
u = i * math.pi / 180.0
a = self.addPart(ObjectBase(vtk.vtkRegularPolygonSource()))
a._source.SetGeneratePolyline(True)
a._source.SetGeneratePolygon(False)
a._source.SetNumberOfSides(2*self.res)
a._source.SetNormal(math.sin(u), math.cos(u), 0.0)
a._source.SetRadius(0.5 + self.height)
a._actor.GetProperty().SetColor(0.3, 0.3, 0.3)
self.grid.append(a)
def Polygon(pos=(0, 0, 0),
normal=(0, 0, 1),
nsides=6,
r=1,
c="coral",
bc="darkgreen",
lw=1,
alpha=1,
followcam=False):
"""
Build a 2D polygon of `nsides` of radius `r` oriented as `normal`.
:param followcam: if `True` the text will auto-orient itself to the active camera.
A ``vtkCamera`` object can also be passed.
:type followcam: bool, vtkCamera
|Polygon|
"""
ps = vtk.vtkRegularPolygonSource()
ps.SetNumberOfSides(nsides)
ps.SetRadius(r)
ps.SetNormal(-np.array(normal))
ps.Update()
tf = vtk.vtkTriangleFilter()
tf.SetInputConnection(ps.GetOutputPort())
tf.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(tf.GetOutputPort())
if followcam:
import vtkplotter.plotter as plt
actor = vtk.vtkFollower()
if isinstance(followcam, vtk.vtkCamera):
actor.SetCamera(followcam)
else:
actor.SetCamera(plt._plotter_instance.camera)
else:
actor = Actor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(colors.getColor(c))
actor.GetProperty().SetOpacity(alpha)
actor.GetProperty().SetLineWidth(lw)
actor.GetProperty().SetInterpolationToFlat()
if bc: # defines a specific color for the backface
backProp = vtk.vtkProperty()
backProp.SetDiffuseColor(colors.getColor(bc))
backProp.SetOpacity(alpha)
actor.SetBackfaceProperty(backProp)
actor.SetPosition(pos)
return actor
def draw_circles(self):
circles = []
for center, normal in zip(self.all_centers_disc, self.all_normals):
for radii in self.all_radii:
for radius in radii:
circle = vtk.vtkRegularPolygonSource()
circle.SetNormal(normal)
circle.SetNumberOfSides(500)
circle.SetRadius(radius)
circle.SetCenter(center)
circle.Update()
circles.append(circle.GetOutput())
return circles
def Polygon(pos=(0, 0, 0), nsides=6, r=1, c="coral", alpha=1):
"""
Build a 2D polygon of `nsides` of radius `r` oriented as `normal`.
|Polygon|
"""
ps = vtk.vtkRegularPolygonSource()
ps.SetNumberOfSides(nsides)
ps.SetRadius(r)
ps.Update()
actor = Actor(ps.GetOutput(), c, alpha)
actor.SetPosition(pos)
settings.collectable_actors.append(actor)
return actor
def CreateCircle(radius):
circleSource = vtkRegularPolygonSource()
circleSource.SetNumberOfSides(32)
circleSource.SetRadius(radius)
circleSource.SetGeneratePolygon(False)
circleMapper = vtkPolyDataMapper()
circleMapper.SetInputConnection(circleSource.GetOutputPort())
circle = vtkActor()
circle.PickableOff()
circle.SetMapper(circleMapper)
circle.GetProperty().SetColor(1.0, 0.5, 0.5)
return circle
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.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create source
polygonSource = vtk.vtkRegularPolygonSource()
polygonSource.Update()
triangleFilter = vtk.vtkTriangleFilter()
triangleFilter.SetInputConnection(polygonSource.GetOutputPort())
triangleFilter.Update()
inputMapper = vtk.vtkPolyDataMapper()
inputMapper.SetInputConnection(polygonSource.GetOutputPort())
inputActor = vtk.vtkActor()
inputActor.SetMapper(inputMapper)
inputActor.GetProperty().SetRepresentationToWireframe()
triangleMapper = vtk.vtkPolyDataMapper()
triangleMapper.SetInputConnection(triangleFilter.GetOutputPort())
triangleActor = vtk.vtkActor()
triangleActor.SetMapper(triangleMapper)
triangleActor.GetProperty().SetRepresentationToWireframe()
# Setup renderers
leftRenderer = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(leftRenderer)
leftRenderer.SetViewport(0, 0, 0.5, 1)
leftRenderer.SetBackground(0.6, 0.5, 0.4)
leftRenderer.AddActor(inputActor)
rightRenderer = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(rightRenderer)
rightRenderer.SetViewport(0.5, 0, 1, 1)
rightRenderer.SetBackground(0.4, 0.5, 0.6)
rightRenderer.AddActor(triangleActor)
leftRenderer.ResetCamera()
rightRenderer.ResetCamera()
self._initialized = False
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.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create source
polygonSource = vtk.vtkRegularPolygonSource()
polygonSource.Update()
triangleFilter = vtk.vtkTriangleFilter()
triangleFilter.SetInputConnection(polygonSource.GetOutputPort())
triangleFilter.Update()
inputMapper = vtk.vtkPolyDataMapper()
inputMapper.SetInputConnection(polygonSource.GetOutputPort())
inputActor = vtk.vtkActor()
inputActor.SetMapper(inputMapper)
inputActor.GetProperty().SetRepresentationToWireframe()
triangleMapper = vtk.vtkPolyDataMapper()
triangleMapper.SetInputConnection(triangleFilter.GetOutputPort())
triangleActor = vtk.vtkActor()
triangleActor.SetMapper(triangleMapper)
triangleActor.GetProperty().SetRepresentationToWireframe()
# Setup renderers
leftRenderer = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(leftRenderer)
leftRenderer.SetViewport(0, 0, 0.5, 1)
leftRenderer.SetBackground(0.6, 0.5, 0.4)
leftRenderer.AddActor(inputActor)
rightRenderer = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(rightRenderer)
rightRenderer.SetViewport(0.5, 0, 1, 1)
rightRenderer.SetBackground(0.4, 0.5, 0.6)
rightRenderer.AddActor(triangleActor)
leftRenderer.ResetCamera()
rightRenderer.ResetCamera()
self._initialized = False
def make_polydata_actor(centers, normals, return_pdm=False, type='circle'):
""" Create the actor and set colors
:param return_pdm: if True give back the polydatamapper
:param centers: list of centers as tuples
:param normals: list of list of normals as tuples
"""
# In order to build the bounding box it is convenient to combine
# All sources using a vtkAppenPolyData
apd = vtk.vtkAppendPolyData()
mappers = []
# create source
for i in range(len(centers)):
normal = normals[i]
if normal is None:
source = vtk.vtkSphereSource()
source.SetRadius(80)
else:
if type == 'torus':
source = vtk.vtkSuperquadricSource()
source.SetScale(1.0, 1.0, 1.0)
source.SetPhiResolution(16)
source.SetThetaResolution(16)
source.SetThetaRoundness(1)
source.SetThickness(0.1)
source.SetSize(100.5)
source.SetToroidal(1)
source.SetNormal(normal)
elif type == 'circle':
source = vtk.vtkRegularPolygonSource()
source.SetNumberOfSides(16)
source.SetRadius(100)
source.SetNormal(normal)
source.SetCenter(*centers[i])
apd.AddInput(source.GetOutput())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(apd.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
if return_pdm:
return actor, apd
else:
return actor
def __init__(self, position=None, color=None, size=None, filled=None):
""" Size is the radius of the disk
"""
Shape.__init__(self, position, color, size, filled)
source = vtkRegularPolygonSource()
source.SetNumberOfSides(30)
source.SetCenter(0, 0, 0)
mapper = vtkPolyDataMapper()
mapper.SetInput(source.GetOutput())
self._actor.SetMapper(mapper)
# Use flat lightning
self._actor.GetProperty().SetAmbient(1)
if size is not None:
self._set_size(size)
def make_polydata_actor(centers, normals, return_pdm=False, type='circle'):
""" Create the actor and set colors
:param return_pdm: if True give back the polydatamapper
:param centers: list of centers as tuples
:param normals: list of list of normals as tuples
"""
# In order to build the bounding box it is convenient to combine
# All sources using a vtkAppenPolyData
apd = vtk.vtkAppendPolyData()
mappers = []
# create source
for i in range(len(centers)):
normal = normals[i]
if normal is None:
source = vtk.vtkSphereSource()
source.SetRadius(80)
else:
if type=='torus':
source = vtk.vtkSuperquadricSource();
source.SetScale(1.0, 1.0, 1.0)
source.SetPhiResolution (16)
source.SetThetaResolution(16)
source.SetThetaRoundness (1)
source.SetThickness (0.1)
source.SetSize(100.5)
source.SetToroidal(1)
source.SetNormal(normal)
elif type=='circle':
source = vtk.vtkRegularPolygonSource()
source.SetNumberOfSides(16)
source.SetRadius(100)
source.SetNormal(normal)
source.SetCenter(*centers[i])
apd.AddInput(source.GetOutput())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(apd.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
if return_pdm:
return actor, apd
else:
return actor
def get_actor(self, zplane = 0.0):
polygonSource = vtk.vtkRegularPolygonSource()
polygonSource.SetNumberOfSides(50)
polygonSource.SetRadius(self.radius)
polygonSource.SetCenter(self.cx, self.cy, zplane)
polygonSource.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(polygonSource.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(1.0, 0.0, 0.0)
return actor
def main():
colors = vtk.vtkNamedColors()
points = vtk.vtkPoints()
points.InsertNextPoint(0, 0, 0)
points.InsertNextPoint(1, 1, 0)
points.InsertNextPoint(2, 2, 0)
polydata = vtk.vtkPolyData()
polydata.SetPoints(points)
# Create anything you want here, we will use a polygon for the demo.
polygonSource = vtk.vtkRegularPolygonSource() # default is 6 sides
glyph2D = vtk.vtkGlyph2D()
glyph2D.SetSourceConnection(polygonSource.GetOutputPort())
glyph2D.SetInputData(polydata)
glyph2D.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(glyph2D.GetOutputPort())
mapper.Update()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(colors.GetColor3d('Salmon'))
# Visualize
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d('SlateGray'))
style = vtk.vtkInteractorStyleImage()
renderWindowInteractor.SetInteractorStyle(style)
renderWindow.SetWindowName('Glyph2D')
renderWindow.Render()
renderWindowInteractor.Start()
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.ren.SetBackground(0.1, 0.2, 0.4)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
points = vtk.vtkPoints()
points.InsertNextPoint(0, 0, 0)
points.InsertNextPoint(1, 1, 0)
points.InsertNextPoint(2, 2, 0)
polyData = vtk.vtkPolyData()
polyData.SetPoints(points)
# Create anything you want here, we will use a polygon for the demo.
polygonSource = vtk.vtkRegularPolygonSource() #default is 6 sides
glyph2D = vtk.vtkGlyph2D()
glyph2D.SetSourceConnection(polygonSource.GetOutputPort())
glyph2D.SetInput(polyData)
glyph2D.Update()
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(glyph2D.GetOutputPort())
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self._initialized = False
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.ren.SetBackground(0.1, 0.2, 0.4)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
points = vtk.vtkPoints()
points.InsertNextPoint(0, 0, 0)
points.InsertNextPoint(1, 1, 0)
points.InsertNextPoint(2, 2, 0)
polyData = vtk.vtkPolyData()
polyData.SetPoints(points)
# Create anything you want here, we will use a polygon for the demo.
polygonSource = vtk.vtkRegularPolygonSource() #default is 6 sides
glyph2D = vtk.vtkGlyph2D()
glyph2D.SetSourceConnection(polygonSource.GetOutputPort())
glyph2D.SetInput(polyData)
glyph2D.Update()
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(glyph2D.GetOutputPort())
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self._initialized = False
def __init__(self,
raio,
centro,
material,
grupo="disco",
cor=(255, 255, 255)):
"""
Construtor da classe Disco.
Args:
raio (float): raio do disco.
centro (float[2]): tupla da posição (x,y) do centro do disco.
material (Material): Material do disco.
grupo (string): Grupo desse elemento. Padrão "disco".
cor (int[3]): tupla as 3 componentes RBG 0-255 para cor do elemento.
"""
Elemento.__init__(self, grupo)
self._tipo = "Disco"
self.raio = raio
self.centro = np.array(centro)
self.mat = material
self.area = math.pi * raio**2
self.massa = self.mat.den * self.area
# lista de todas as variaveis do elemento ao decorrer da simulação, pos, vel...
# vel inicial duplicada para calcular corretamente a velocidade média no 1o passo
self.movimento = {
'pos': [centro],
'vel': [self.v0, self.v0],
'F': [self.F0]
}
# config para VTK
self.disk = vtk.vtkRegularPolygonSource()
self.disk.SetNumberOfSides(50)
self.disk.SetRadius(raio)
#self.disk.SetCenter(centro[0], centro[1], 0)
self._set_vtk(self.disk, cor)
self.actor.SetPosition(centro[0], centro[1], 0)
def main():
colors = vtk.vtkNamedColors()
# Create a pentagon
polygonSource = vtk.vtkRegularPolygonSource()
polygonSource.SetNumberOfSides(5)
polygonSource.SetRadius(5)
polygonSource.SetCenter(0, 0, 0)
shrink = vtk.vtkShrinkPolyData()
shrink.SetInputConnection(polygonSource.GetOutputPort())
shrink.SetShrinkFactor(.9)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(shrink.GetOutputPort())
back = vtk.vtkProperty()
back.SetColor(colors.GetColor3d("Tomato"))
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().EdgeVisibilityOn()
actor.GetProperty().SetLineWidth(5)
actor.GetProperty().SetColor(colors.GetColor3d("Banana"))
actor.SetBackfaceProperty(back)
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetWindowName("Regular Polygon Source")
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d("Silver"))
renderWindow.Render()
renderWindowInteractor.Start()
def make_polydata_actor(centers, normals, colors, return_pdm=False):
""" Create the actor and set colors
:param return_pdm: if True give back the polydatamapper
:param centers: list of centers as tuples
:param normals: list of normals as tuples
:param colors: list of rgb tuples
"""
# In order to build the bounding box it is convenient to combine
# All sources using a vtkAppenPolyData
apd = vtk.vtkAppendPolyData()
mappers = []
# create source
for i in range(len(centers)):
normal = normals[i]
if normal is None:
continue
source = vtk.vtkRegularPolygonSource()
source.SetNormal(normal)
source.SetCenter(*centers[i])
source.SetNumberOfSides(16)
source.SetRadius(100)
apd.AddInput(source.GetOutput())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(apd.GetOutputPort())
# actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# set colors:
actor.GetProperty().SetColor(*colors[i])
if return_pdm:
return actor, apd
else:
return actor
def createActorTubes(self, elements):
source = vtk.vtkAppendPolyData()
mapper = vtk.vtkPolyDataMapper()
actor = vtk.vtkActor()
# _first = True
for element in elements:
cross_section = element.cross_section
if cross_section:
polygon = self.createSectionPolygon(element)
else: # not cross section
if self.defaultRadius is None:
self.defaultRadius = element.length / 20
polygon = vtk.vtkRegularPolygonSource()
polygon.SetRadius(self.defaultRadius)
polygon.SetNumberOfSides(20)
tube = self.generalSectionTube(element, polygon.GetOutputPort())
source.AddInputData(tube.GetOutput())
mapper.SetInputConnection(source.GetOutputPort())
actor.SetMapper(mapper)
return actor
def add_case_actors(self, data, actors, color, opacity):
for i in range(len(data)):
x = (self.sat_x / 360.0) * (180 + float(data[i][1]))
y = (self.sat_y / 180.0) * (90 + float(data[i][0]))
cases = int(data[i][self.date+2])
if(cases > 0 and (float(data[i][1]) != 0 or float(data[i][0]) != 0)):
radius = (math.log2(cases)/math.log2(self.max_cases)) * self.max_radius
polygon_source = vtk.vtkRegularPolygonSource()
polygon_source.SetNumberOfSides(50)
polygon_source.SetRadius(radius)
polygon_source.SetCenter(x, y, 0)
cases_mapper = vtk.vtkPolyDataMapper()
cases_mapper.SetInputConnection(polygon_source.GetOutputPort())
cases_actor = vtk.vtkActor()
cases_actor.SetMapper(cases_mapper)
cases_actor.GetProperty().SetColor(color[0], color[1], color[2])
cases_actor.GetProperty().SetOpacity(opacity)
self.ren.AddActor(cases_actor)
actors.append(cases_actor)
def main():
colors = vtk.vtkNamedColors()
# Set the background color.
colors.SetColor("BkgColor", [51, 77, 102, 255])
# Create container to hold the 3D object generators (sources)
geometricObjectSources = list()
# Populate the container with the various object sources to be demonstrated
geometricObjectSources.append(vtk.vtkArrowSource())
geometricObjectSources.append(vtk.vtkConeSource())
geometricObjectSources.append(vtk.vtkCubeSource())
geometricObjectSources.append(vtk.vtkCylinderSource())
geometricObjectSources.append(vtk.vtkDiskSource())
geometricObjectSources.append(vtk.vtkLineSource())
geometricObjectSources.append(vtk.vtkRegularPolygonSource())
geometricObjectSources.append(vtk.vtkSphereSource())
# Create containers for the remaining nodes of each pipeline
mappers = list()
actors = list()
textmappers = list()
textactors = list()
# Create a common text property.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(16)
textProperty.SetJustificationToCentered()
# Create a mapper and actor for each object and the corresponding text label
for i in range(0, len(geometricObjectSources)):
geometricObjectSources[i].Update()
mappers.append(vtk.vtkPolyDataMapper())
mappers[i].SetInputConnection(geometricObjectSources[i].GetOutputPort())
actors.append(vtk.vtkActor())
actors[i].SetMapper(mappers[i])
actors[i].GetProperty().SetColor(
colors.GetColor3d("Seashell"))
textmappers.append(vtk.vtkTextMapper())
textmappers[i].SetInput(
geometricObjectSources[i].GetClassName()) # set text label to the name of the object source
textmappers[i].SetTextProperty(textProperty)
textactors.append(vtk.vtkActor2D())
textactors[i].SetMapper(textmappers[i])
textactors[i].SetPosition(120, 16) # Note: the position of an Actor2D is specified in display coordinates
# Define size of the grid that will hold the objects
gridCols = 3
gridRows = 3
# Define side length (in pixels) of each renderer square
rendererSize = 300
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetWindowName("Geometric Objects Demo")
renderWindow.SetSize(rendererSize * gridCols, rendererSize * gridRows)
# Set up a grid of viewports for each renderer
for row in range(0, gridRows):
for col in range(0, gridCols):
index = row * gridCols + col
# Create a renderer for this grid cell
renderer = vtk.vtkRenderer()
renderer.SetBackground(colors.GetColor3d("BkgColor"))
# Set the renderer's viewport dimensions (xmin, ymin, xmax, ymax) within the render window.
# Note that for the Y values, we need to subtract the row index from gridRows
# because the viewport Y axis points upwards, but we want to draw the grid from top to down
viewport = [
float(col) / gridCols,
float(gridRows - row - 1) / gridRows,
float(col + 1) / gridCols,
float(gridRows - row) / gridRows
]
renderer.SetViewport(viewport)
# Add the corresponding actor and label for this grid cell, if they exist
if index < len(geometricObjectSources):
renderer.AddActor(actors[index])
renderer.AddActor(textactors[index])
renderer.ResetCameraClippingRange()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
def __init__(self, parent = None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
# Create source
geometricObjects = list()
geometricObjects.append(vtk.vtkArrowSource())
geometricObjects.append(vtk.vtkConeSource())
geometricObjects.append(vtk.vtkCubeSource())
geometricObjects.append(vtk.vtkCylinderSource())
geometricObjects.append(vtk.vtkDiskSource())
geometricObjects.append(vtk.vtkLineSource())
geometricObjects.append(vtk.vtkRegularPolygonSource())
geometricObjects.append(vtk.vtkSphereSource())
renderers = list()
mappers = list()
actors = list()
textmappers = list()
textactors = list()
# Create a common text property.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(10)
textProperty.SetJustificationToCentered()
# Create a parametric function source, renderer, mapper
# and actor for each object.
for idx, item in enumerate(geometricObjects):
geometricObjects[idx].Update()
mappers.append(vtk.vtkPolyDataMapper())
mappers[idx].SetInputConnection(geometricObjects[idx].GetOutputPort())
actors.append(vtk.vtkActor())
actors[idx].SetMapper(mappers[idx])
textmappers.append(vtk.vtkTextMapper())
textmappers[idx].SetInput(item.GetClassName())
textmappers[idx].SetTextProperty(textProperty)
textactors.append(vtk.vtkActor2D())
textactors[idx].SetMapper(textmappers[idx])
textactors[idx].SetPosition(150, 16)
renderers.append(vtk.vtkRenderer())
gridDimensions = 3
for idx in range(len(geometricObjects)):
if idx < gridDimensions * gridDimensions:
renderers.append(vtk.vtkRenderer())
rendererSize = 300
# Setup the RenderWindow
self.vtkWidget.GetRenderWindow().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(geometricObjects) - 1):
continue
renderers[idx].SetViewport(viewport)
self.vtkWidget.GetRenderWindow().AddRenderer(renderers[idx])
renderers[idx].AddActor(actors[idx])
renderers[idx].AddActor(textactors[idx])
renderers[idx].SetBackground(0.4,0.3,0.2)
self._initialized = False
#!/usr/bin/env python import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Create two polygon sources, one a closed polyline, one a polygon # polyline = vtk.vtkRegularPolygonSource() polyline.SetCenter(1,1,1) polyline.SetRadius(1) polyline.SetNumberOfSides(12) polyline.SetNormal(1,2,3) polyline.GeneratePolylineOn() polyline.GeneratePolygonOff() polylineMapper = vtk.vtkPolyDataMapper() polylineMapper.SetInputConnection(polyline.GetOutputPort()) polylineActor = vtk.vtkActor() polylineActor.SetMapper(polylineMapper) polylineActor.GetProperty().SetColor(0,1,0) polylineActor.GetProperty().SetAmbient(1) polygon = vtk.vtkRegularPolygonSource() polygon.SetCenter(3,1,1) polygon.SetRadius(1) polygon.SetNumberOfSides(12) polygon.SetNormal(1,2,3) polygon.GeneratePolylineOff() polygon.GeneratePolygonOn() polygonMapper = vtk.vtkPolyDataMapper() polygonMapper.SetInputConnection(polygon.GetOutputPort()) polygonActor = vtk.vtkActor()
#!/usr/bin/env python import vtk # Create a pentagon polygonSource = vtk.vtkRegularPolygonSource() #polygonSource.GeneratePolygonOff() polygonSource.SetNumberOfSides(5) polygonSource.SetRadius(5) polygonSource.SetCenter(0,0,0) polygonSource.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(polygonSource.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(actor) renderer.SetBackground(.3,.3,.5) # Background color purple renderWindow.Render() renderWindowInteractor.Start()
def GeometricObjects(self):
GeometricObjects = list()
GeometricObjects.append(vtk.vtkArrowSource())
GeometricObjects.append(vtk.vtkConeSource())
GeometricObjects.append(vtk.vtkCubeSource())
GeometricObjects.append(vtk.vtkCylinderSource())
GeometricObjects.append(vtk.vtkDiskSource())
GeometricObjects.append(vtk.vtkLineSource())
GeometricObjects.append(vtk.vtkRegularPolygonSource())
GeometricObjects.append(vtk.vtkSphereSource())
renderers = list()
mappers = list()
actors = list()
textmappers = list()
textactors = list()
# Create a common text property.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(10)
textProperty.SetJustificationToCentered()
# Create a parametric function source, renderer, mapper
# and actor for each object.
for idx, item in enumerate(GeometricObjects):
GeometricObjects[idx].Update()
mappers.append(vtk.vtkPolyDataMapper())
mappers[idx].SetInputConnection(GeometricObjects[idx].GetOutputPort())
actors.append(vtk.vtkActor())
actors[idx].SetMapper(mappers[idx])
textmappers.append(vtk.vtkTextMapper())
textmappers[idx].SetInput(item.GetClassName())
textmappers[idx].SetTextProperty(textProperty)
textactors.append(vtk.vtkActor2D())
textactors[idx].SetMapper(textmappers[idx])
textactors[idx].SetPosition(150, 16)
renderers.append(vtk.vtkRenderer())
gridDimensions = 3
for idx in range(len(GeometricObjects)):
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(GeometricObjects) - 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()
#!/usr/bin/env python import vtk # Create a pentagon polygonSource = vtk.vtkRegularPolygonSource() #polygonSource.GeneratePolygonOff() polygonSource.SetNumberOfSides(5) polygonSource.SetRadius(5) polygonSource.SetCenter(0, 0, 0) polygonSource.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(polygonSource.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(actor) renderer.SetBackground(.3, .3, .5) # Background color purple renderWindow.Render() renderWindowInteractor.Start()
def __init__(self,
parent=None,
width=400,
height=400,
showWidget=False,
scale=False):
super(ROIManager, self).__init__()
self.width = width
self.height = height
self.showWidget = showWidget
self.scale = scale
self.renderer = None
self.ROIRadius = 20.0
self.minValueBG = 0
self.maxValueBG = 0
self.minValueFG = 0
self.maxValueFG = 0
self.probeWidget = None
self.drawOverlay = 0
# utility Qt instances for use in methods
self.gray = qt.QColor()
self.gray.setRedF(0.5)
self.gray.setGreenF(0.5)
self.gray.setBlueF(0.5)
# a painter to use for various jobs
self.painter = qt.QPainter()
# make a qwidget display
if self.showWidget:
self.frame = qt.QFrame(parent)
mw = slicer.util.mainWindow()
self.frame.setGeometry(mw.x, mw.y, self.width, self.height)
self.frameLayout = qt.QVBoxLayout(self.frame)
self.label = qt.QLabel()
self.frameLayout.addWidget(self.label)
self.frame.show()
# make an image actor in the slice view
self.vtkImage = vtk.vtkImageData()
self.mrmlUtils = slicer.qMRMLUtils()
self.imageMapper = vtk.vtkImageMapper()
self.imageMapper.SetColorLevel(128)
self.imageMapper.SetColorWindow(255)
if vtk.VTK_MAJOR_VERSION <= 5:
self.imageMapper.SetInput(self.vtkImage)
else:
self.imageMapper.SetInputData(self.vtkImage)
self.actor2D = vtk.vtkActor2D()
self.actor2D.SetMapper(self.imageMapper)
# make a circle actor
self.circle = vtk.vtkRegularPolygonSource()
self.circle.SetNumberOfSides(50)
self.circle.SetRadius(5)
self.circle.SetCenter(0, 0, 0)
self.circle.GeneratePolylineOn()
self.circle.GeneratePolygonOff()
self.circle.Update()
self.mapper = vtk.vtkPolyDataMapper2D()
self.actor = vtk.vtkActor2D()
if vtk.VTK_MAJOR_VERSION <= 5:
self.mapper.SetInput(self.circle.GetOutput())
else:
self.mapper.SetInputConnection(self.circle.GetOutputPort())
self.actor.SetMapper(self.mapper)
property_ = self.actor.GetProperty()
property_.SetColor(1, 1, 0)
property_.SetLineWidth(1)
def test_custom_interactor_style_events(recording=False):
print("Using VTK {}".format(vtk.vtkVersion.GetVTKVersion()))
filename = "test_custom_interactor_style_events.log.gz"
recording_filename = pjoin(DATA_DIR, filename)
scene = window.Scene()
# the show manager allows to break the rendering process
# in steps so that the widgets can be added properly
interactor_style = interactor.CustomInteractorStyle()
show_manager = window.ShowManager(scene,
size=(800, 800),
reset_camera=False,
interactor_style=interactor_style)
# Create a cursor, a circle that will follow the mouse.
polygon_source = vtk.vtkRegularPolygonSource()
polygon_source.GeneratePolygonOff() # Only the outline of the circle.
polygon_source.SetNumberOfSides(50)
polygon_source.SetRadius(10)
# polygon_source.SetRadius
polygon_source.SetCenter(0, 0, 0)
mapper = vtk.vtkPolyDataMapper2D()
vtk_utils.set_input(mapper, polygon_source.GetOutputPort())
cursor = vtk.vtkActor2D()
cursor.SetMapper(mapper)
cursor.GetProperty().SetColor(1, 0.5, 0)
scene.add(cursor)
def follow_mouse(iren, obj):
obj.SetPosition(*iren.event.position)
iren.force_render()
interactor_style.add_active_prop(cursor)
interactor_style.add_callback(cursor, "MouseMoveEvent", follow_mouse)
# create some minimalistic streamlines
lines = [
np.array([[-1, 0, 0.], [1, 0, 0.]]),
np.array([[-1, 1, 0.], [1, 1, 0.]])
]
colors = np.array([[1., 0., 0.], [0.3, 0.7, 0.]])
tube1 = actor.streamtube([lines[0]], colors[0])
tube2 = actor.streamtube([lines[1]], colors[1])
scene.add(tube1)
scene.add(tube2)
# Define some counter callback.
states = defaultdict(lambda: 0)
def counter(iren, _obj):
states[iren.event.name] += 1
# Assign the counter callback to every possible event.
for event in [
"CharEvent", "MouseMoveEvent", "KeyPressEvent", "KeyReleaseEvent",
"LeftButtonPressEvent", "LeftButtonReleaseEvent",
"RightButtonPressEvent", "RightButtonReleaseEvent",
"MiddleButtonPressEvent", "MiddleButtonReleaseEvent"
]:
interactor_style.add_callback(tube1, event, counter)
# Add callback to scale up/down tube1.
def scale_up_obj(iren, obj):
counter(iren, obj)
scale = np.asarray(obj.GetScale()) + 0.1
obj.SetScale(*scale)
iren.force_render()
iren.event.abort() # Stop propagating the event.
def scale_down_obj(iren, obj):
counter(iren, obj)
scale = np.array(obj.GetScale()) - 0.1
obj.SetScale(*scale)
iren.force_render()
iren.event.abort() # Stop propagating the event.
interactor_style.add_callback(tube2, "MouseWheelForwardEvent",
scale_up_obj)
interactor_style.add_callback(tube2, "MouseWheelBackwardEvent",
scale_down_obj)
# Add callback to hide/show tube1.
def toggle_visibility(iren, obj):
key = iren.event.key
if key.lower() == "v":
obj.SetVisibility(not obj.GetVisibility())
iren.force_render()
interactor_style.add_active_prop(tube1)
interactor_style.add_active_prop(tube2)
interactor_style.remove_active_prop(tube2)
interactor_style.add_callback(tube1, "CharEvent", toggle_visibility)
if recording:
show_manager.record_events_to_file(recording_filename)
print(list(states.items()))
else:
show_manager.play_events_from_file(recording_filename)
msg = ("Wrong count for '{}'.")
expected = [('CharEvent', 6), ('KeyPressEvent', 6),
('KeyReleaseEvent', 6), ('MouseMoveEvent', 1652),
('LeftButtonPressEvent', 1), ('RightButtonPressEvent', 1),
('MiddleButtonPressEvent', 2),
('LeftButtonReleaseEvent', 1),
('MouseWheelForwardEvent', 3),
('MouseWheelBackwardEvent', 1),
('MiddleButtonReleaseEvent', 2),
('RightButtonReleaseEvent', 1)]
# Useful loop for debugging.
for event, count in expected:
if states[event] != count:
print("{}: {} vs. {} (expected)".format(
event, states[event], count))
for event, count in expected:
npt.assert_equal(states[event], count, err_msg=msg.format(event))
def createSectionPolygon(self, element):
if None in [element.cross_section, element.cross_section_points]:
poly = vtk.vtkRegularPolygonSource()
poly.SetNumberOfSides(3)
poly.SetNormal(1, 0, 0)
poly.SetRadius(1e-6)
return poly
if self.pressure_plot:
if element.element_type in ['beam_1']:
poly = vtk.vtkRegularPolygonSource()
poly.SetNumberOfSides(3)
poly.SetNormal(1, 0, 0)
poly.SetRadius(1e-6)
return poly
elif element.valve_parameters:
r = (element.valve_diameters[element.index][1] / 2) * self.bff
elif element.perforated_plate:
r = (element.perforated_plate.hole_diameter / 2) * self.bff
else:
r = (element.cross_section.inner_diameter / 2) * self.bff
poly = vtk.vtkRegularPolygonSource()
poly.SetNumberOfSides(36)
poly.SetNormal(1, 0, 0)
poly.SetRadius(r)
return poly
outer_points, inner_points, _ = element.cross_section_points
number_inner_points = len(inner_points)
number_outer_points = len(outer_points)
# definitions
points = vtk.vtkPoints()
outerData = vtk.vtkPolyData()
innerPolygon = vtk.vtkPolygon()
innerCell = vtk.vtkCellArray()
innerData = vtk.vtkPolyData()
delaunay = vtk.vtkDelaunay2D()
outerPolygon = vtk.vtkPolygon()
edges = vtk.vtkCellArray()
source = vtk.vtkTriangleFilter()
# create points
for y, z in inner_points:
y *= self.bff
z *= self.bff
points.InsertNextPoint(0, y, z)
for y, z in outer_points:
y *= self.bff
z *= self.bff
points.InsertNextPoint(0, y, z)
# create external polygon
outerData.SetPoints(points)
#TODO: clean-up the structure below
if number_inner_points >= 3:
delaunay.SetProjectionPlaneMode(2)
delaunay.SetInputData(outerData)
# remove inner area for holed sections
for i in range(number_inner_points):
innerPolygon.GetPointIds().InsertNextId(i)
innerCell.InsertNextCell(innerPolygon)
innerData.SetPoints(points)
innerData.SetPolys(innerCell)
delaunay.SetSourceData(innerData)
delaunay.Update()
return delaunay
else:
# prevents bugs on the outer section
for i in range(number_outer_points):
outerPolygon.GetPointIds().InsertNextId(i)
edges.InsertNextCell(outerPolygon)
outerData.SetPolys(edges)
source.AddInputData(outerData)
return source
def GeometricObjects(self):
GeometricObjects = list()
GeometricObjects.append(vtk.vtkArrowSource())
GeometricObjects.append(vtk.vtkConeSource())
GeometricObjects.append(vtk.vtkCubeSource())
GeometricObjects.append(vtk.vtkCylinderSource())
GeometricObjects.append(vtk.vtkDiskSource())
GeometricObjects.append(vtk.vtkLineSource())
GeometricObjects.append(vtk.vtkRegularPolygonSource())
GeometricObjects.append(vtk.vtkSphereSource())
renderers = list()
mappers = list()
actors = list()
textmappers = list()
textactors = list()
# Create a common text property.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(10)
textProperty.SetJustificationToCentered()
# Create a parametric function source, renderer, mapper
# and actor for each object.
for idx, item in enumerate(GeometricObjects):
GeometricObjects[idx].Update()
mappers.append(vtk.vtkPolyDataMapper())
mappers[idx].SetInputConnection(
GeometricObjects[idx].GetOutputPort())
actors.append(vtk.vtkActor())
actors[idx].SetMapper(mappers[idx])
textmappers.append(vtk.vtkTextMapper())
textmappers[idx].SetInput(item.GetClassName())
textmappers[idx].SetTextProperty(textProperty)
textactors.append(vtk.vtkActor2D())
textactors[idx].SetMapper(textmappers[idx])
textactors[idx].SetPosition(150, 16)
renderers.append(vtk.vtkRenderer())
gridDimensions = 3
for idx in range(len(GeometricObjects)):
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(GeometricObjects) - 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()
def __init__(self, parent=None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
# Create source
geometricObjects = list()
geometricObjects.append(vtk.vtkArrowSource())
geometricObjects.append(vtk.vtkConeSource())
geometricObjects.append(vtk.vtkCubeSource())
geometricObjects.append(vtk.vtkCylinderSource())
geometricObjects.append(vtk.vtkDiskSource())
geometricObjects.append(vtk.vtkLineSource())
geometricObjects.append(vtk.vtkRegularPolygonSource())
geometricObjects.append(vtk.vtkSphereSource())
renderers = list()
mappers = list()
actors = list()
textmappers = list()
textactors = list()
# Create a common text property.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(10)
textProperty.SetJustificationToCentered()
# Create a parametric function source, renderer, mapper
# and actor for each object.
for idx, item in enumerate(geometricObjects):
geometricObjects[idx].Update()
mappers.append(vtk.vtkPolyDataMapper())
mappers[idx].SetInputConnection(
geometricObjects[idx].GetOutputPort())
actors.append(vtk.vtkActor())
actors[idx].SetMapper(mappers[idx])
textmappers.append(vtk.vtkTextMapper())
textmappers[idx].SetInput(item.GetClassName())
textmappers[idx].SetTextProperty(textProperty)
textactors.append(vtk.vtkActor2D())
textactors[idx].SetMapper(textmappers[idx])
textactors[idx].SetPosition(150, 16)
renderers.append(vtk.vtkRenderer())
gridDimensions = 3
for idx in range(len(geometricObjects)):
if idx < gridDimensions * gridDimensions:
renderers.append(vtk.vtkRenderer())
rendererSize = 300
# Setup the RenderWindow
self.vtkWidget.GetRenderWindow().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(geometricObjects) - 1):
continue
renderers[idx].SetViewport(viewport)
self.vtkWidget.GetRenderWindow().AddRenderer(renderers[idx])
renderers[idx].AddActor(actors[idx])
renderers[idx].AddActor(textactors[idx])
renderers[idx].SetBackground(0.4, 0.3, 0.2)
self._initialized = False