def create(self):
source = vtk.vtkCubeSource()
source.SetXLength(1.5 * FlowChannel.RADIUS)
source.SetYLength(self._length)
source.SetZLength(1.5 * FlowChannel.RADIUS)
self._mapper = vtk.vtkPolyDataMapper()
self._mapper.SetInputConnection(source.GetOutputPort())
self._actor = vtk.vtkActor()
self._actor.SetMapper(self._mapper)
self._actor.SetPosition(self._position)
self._actor.SetOrientation(self._vtk_orientation)
self._silhouette = vtk.vtkPolyDataSilhouette()
self._silhouette.SetInputData(self._mapper.GetInput())
self._silhouette_mapper = vtk.vtkPolyDataMapper()
self._silhouette_mapper.SetInputConnection(
self._silhouette.GetOutputPort())
self._silhouette_actor = vtk.vtkActor()
self._silhouette_actor.SetMapper(self._silhouette_mapper)
self._silhouette_actor.SetPosition(self._position)
self._silhouette_actor.SetOrientation(self._vtk_orientation)
self._caption_actor = self._createCaptionActor()
self._caption_actor.SetAttachmentPoint(self._position)
def _silhouette(self,
mesh,
color=None,
line_width=None,
alpha=None,
decimate=None):
mesh = mesh.decimate(decimate) if decimate is not None else mesh
silhouette_filter = vtk.vtkPolyDataSilhouette()
silhouette_filter.SetInputData(mesh)
silhouette_filter.SetCamera(self.plotter.renderer.GetActiveCamera())
silhouette_filter.SetEnableFeatureAngle(0)
silhouette_mapper = vtk.vtkPolyDataMapper()
silhouette_mapper.SetInputConnection(silhouette_filter.GetOutputPort())
_, prop = self.plotter.add_actor(silhouette_mapper,
reset_camera=False,
name=None,
culling=False,
pickable=False,
render=False)
if color is not None:
prop.SetColor(*color)
if alpha is not None:
prop.SetOpacity(alpha)
if line_width is not None:
prop.SetLineWidth(line_width)
def create(self):
self._center = self.__computeCenter(self.__connections)
bounds = self.__computeBounds(self._center)
source = vtk.vtkCubeSource()
source.SetCenter(self._center)
source.SetBounds(bounds)
self._mapper = vtk.vtkPolyDataMapper()
self._mapper.SetInputConnection(source.GetOutputPort())
self._actor = vtk.vtkActor()
self._actor.SetMapper(self._mapper)
self._silhouette = vtk.vtkPolyDataSilhouette()
self._silhouette.SetInputData(self._mapper.GetInput())
self._silhouette_mapper = vtk.vtkPolyDataMapper()
self._silhouette_mapper.SetInputConnection(
self._silhouette.GetOutputPort())
self._silhouette_actor = vtk.vtkActor()
self._silhouette_actor.SetMapper(self._silhouette_mapper)
self._caption_actor = self._createCaptionActor()
self._caption_actor.SetAttachmentPoint(self._center)
def _setUpSilhouette(self, camera):
self._silhouette = vtk.vtkPolyDataSilhouette()
self._silhouette.SetInputData(self._mapper.GetInput())
self._silhouette.SetCamera(camera)
self._silhouette_mapper = vtk.vtkPolyDataMapper()
self._silhouette_mapper.SetInputConnection(
self._silhouette.GetOutputPort())
self._silhouette_actor = vtk.vtkActor()
self._silhouette_actor.SetMapper(self._silhouette_mapper)
self._silhouette_actor.VisibilityOff()
self._silhouette_property = self._silhouette_actor.GetProperty()
self._silhouette_property.SetColor([0, 0, 0])
self._silhouette_property.SetLineWidth(3)
def create(self):
comp = self._reader.getComponent(self._connection['name'])
pos = comp.getPoint(self._connection['type'])
ori = comp.getOrientation(self._connection['type'])
if self._connection['type'] == 'in':
self._center = [
pos[0] - ori[0] * 0.5 * Boundary.SIZE,
pos[1] - ori[1] * 0.5 * Boundary.SIZE,
pos[2] - ori[2] * 0.5 * Boundary.SIZE
]
elif self._connection['type'] == 'out':
self._center = [
pos[0] + ori[0] * 0.5 * Boundary.SIZE,
pos[1] + ori[1] * 0.5 * Boundary.SIZE,
pos[2] + ori[2] * 0.5 * Boundary.SIZE
]
else:
self._center = pos
source = vtk.vtkCubeSource()
source.SetCenter(self._center)
source.SetXLength(Boundary.SIZE)
source.SetYLength(Boundary.SIZE)
source.SetZLength(Boundary.SIZE)
self._mapper = vtk.vtkPolyDataMapper()
self._mapper.SetInputConnection(source.GetOutputPort())
self._actor = vtk.vtkActor()
self._actor.SetMapper(self._mapper)
self._silhouette = vtk.vtkPolyDataSilhouette()
self._silhouette.SetInputData(self._mapper.GetInput())
self._silhouette_mapper = vtk.vtkPolyDataMapper()
self._silhouette_mapper.SetInputConnection(
self._silhouette.GetOutputPort())
self._silhouette_actor = vtk.vtkActor()
self._silhouette_actor.SetMapper(self._silhouette_mapper)
self._caption_actor = self._createCaptionActor()
self._caption_actor.SetAttachmentPoint(self._center)
def create(self):
"""
Creates the CubeSource object representing a heat structure.
"""
source = vtk.vtkCubeSource()
source.SetBounds(self._bounds)
self._mapper = vtk.vtkPolyDataMapper()
self._mapper.SetInputConnection(source.GetOutputPort())
self._actor = vtk.vtkActor()
self._actor.SetMapper(self._mapper)
self._actor.SetPosition(self._position)
self._actor.SetOrientation(self._orientation)
self._actor.RotateX(self._rotation)
self._actor.RotateY(0)
self._actor.RotateZ(0)
self._silhouette = vtk.vtkPolyDataSilhouette()
self._silhouette.SetInputData(self._mapper.GetInput())
self._silhouette_mapper = vtk.vtkPolyDataMapper()
self._silhouette_mapper.SetInputConnection(
self._silhouette.GetOutputPort())
self._silhouette_actor = vtk.vtkActor()
self._silhouette_actor.SetMapper(self._silhouette_mapper)
self._silhouette_actor.SetPosition(self._position)
self._silhouette_actor.SetOrientation(self._orientation)
self._silhouette_actor.RotateX(self._rotation)
self._silhouette_actor.RotateY(0)
self._silhouette_actor.RotateZ(0)
self._caption_actor = self._createCaptionActor()
center = self._actor.GetCenter()
self._caption_actor.SetAttachmentPoint(center)
"""Make the silhouette of an object
move along with camera position.
"""
from vtkplotter import *
import vtk
plt = Plotter(bg='lightblue', interactive=False)
s = load(datadir + 'shark.ply')
s.alpha(0.1).c('gray').lw(0.1).lc('red')
plt.show(s, Text(__doc__))
sil = vtk.vtkPolyDataSilhouette()
sil.SetInputData(s.polydata())
sil.SetCamera(plt.camera)
silMapper = vtk.vtkPolyDataMapper()
silMapper.SetInputConnection(sil.GetOutputPort())
actor = Actor()
actor.lw(4).c('black').SetMapper(silMapper)
plt.add(actor) # add() also renders the scene
interactive()
def main():
numberOfSpheres = get_program_parameters()
colors = vtk.vtkNamedColors()
# A renderer and render window
renderer = vtk.vtkRenderer()
renderer.SetBackground(colors.GetColor3d('SteelBlue'))
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(640, 480)
renderWindow.AddRenderer(renderer)
# An interactor
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
randomSequence = vtk.vtkMinimalStandardRandomSequence()
# randomSequence.SetSeed(1043618065)
# randomSequence.SetSeed(5170)
randomSequence.SetSeed(8775070)
# Add spheres to play with
for i in range(numberOfSpheres):
source = vtk.vtkSphereSource()
# random position and radius
x = randomSequence.GetRangeValue(-5.0, 5.0)
randomSequence.Next()
y = randomSequence.GetRangeValue(-5.0, 5.0)
randomSequence.Next()
z = randomSequence.GetRangeValue(-5.0, 5.0)
randomSequence.Next()
radius = randomSequence.GetRangeValue(0.5, 1.0)
randomSequence.Next()
source.SetRadius(radius)
source.SetCenter(x, y, z)
source.SetPhiResolution(11)
source.SetThetaResolution(21)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(source.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
r = randomSequence.GetRangeValue(0.4, 1.0)
randomSequence.Next()
g = randomSequence.GetRangeValue(0.4, 1.0)
randomSequence.Next()
b = randomSequence.GetRangeValue(0.4, 1.0)
randomSequence.Next()
actor.GetProperty().SetDiffuseColor(r, g, b)
actor.GetProperty().SetDiffuse(0.8)
actor.GetProperty().SetSpecular(0.5)
actor.GetProperty().SetSpecularColor(colors.GetColor3d('White'))
actor.GetProperty().SetSpecularPower(30.0)
renderer.AddActor(actor)
# Render and interact
renderWindow.Render()
# Create the silhouette pipeline, the input data will be set in the
# interactor
silhouette = vtk.vtkPolyDataSilhouette()
silhouette.SetCamera(renderer.GetActiveCamera())
# Create mapper and actor for silhouette
silhouetteMapper = vtk.vtkPolyDataMapper()
silhouetteMapper.SetInputConnection(silhouette.GetOutputPort())
silhouetteActor = vtk.vtkActor()
silhouetteActor.SetMapper(silhouetteMapper)
silhouetteActor.GetProperty().SetColor(colors.GetColor3d("Tomato"))
silhouetteActor.GetProperty().SetLineWidth(5)
# Set the custom type to use for interaction.
style = MouseInteractorHighLightActor(silhouette, silhouetteActor)
style.SetDefaultRenderer(renderer)
# Start
interactor.Initialize()
interactor.SetInteractorStyle(style)
renderWindow.SetWindowName('HighlightWithSilhouette')
renderWindow.Render()
interactor.Start()
def show_mesh(input_mesh, dists, plotter, spacing, tolerance=None):
#vp2 = Plotter(bg = 'bb', size='fullscreen')
vp2 = plotter
plotter.clear()
if tolerance is not None:
try:
poly_data = input_mesh.polydata()
sil = vtk.vtkPolyDataSilhouette()
sil.SetInputData(poly_data)
sil.SetCamera(vp2.camera)
silMapper = vtk.vtkPolyDataMapper()
silMapper.SetInputConnection(sil.GetOutputPort())
mesh1 = mesh.Mesh(alpha=0.21)
mesh1.lw(3).c('w').SetMapper(silMapper)
vp2 += mesh1
pts = input_mesh.points()
def_pts = []
for i, dist in enumerate(dists):
if dist > tolerance:
def_pts.append(pts[i])
arr = np.array(def_pts)
arr = removeOutliers(arr, spacing)
cl = cluster(arr, radius=spacing)
err_num = 0
sph_arr = []
for pt_cl in cl.GetParts():
err_num += 1
cl_pts = pt_cl.points()
hull_pt1, hull_pt2 = furthest_pts(cl_pts)
cnt_pnt = (hull_pt1 + hull_pt2) / 2
rdi = 1 * pt_dist(cnt_pnt, hull_pt2)
sp = shapes.Sphere(cnt_pnt,
rdi,
c=(1, 0, 0),
alpha=.15,
quads=True).wireframe(.5)
sph_arr.append(sp)
vp2 += sp
txt = Text2D("Detected {} Object Defect".format(err_num),
pos=8,
c='gray',
s=1.31)
vp2 += txt
vp2.show(interactive=1)
except AttributeError as error:
print("Error during automatic error detection:", error)
vp2.clear()
input_mesh.pointColors(dists, cmap='jet')
input_mesh.addScalarBar(title="Divergence",
pos=(0, 0.24),
titleFontSize=16,
titleYOffset=25)
def slider(widget, event):
value = widget.GetRepresentation().GetValue()
cuttoff = round(value * 900)
hidden = np.full((cuttoff), 0.0)
show = np.full((900 - cuttoff), 1)
opacities = np.concatenate((hidden, show), axis=None)
input_mesh.pointColors(dists, cmap='jet', alpha=opacities)
vp2.addSlider2D(slider,
xmin=0.0,
xmax=1,
value=0.0,
showValue=False,
pos=[(0.9, 1), (0.9, 0)],
c='lightgray')
ambient, diffuse, specular = .4, 1., 0.
specularPower, specularColor = 20, 'white'
input_mesh.lighting('default', ambient, diffuse, specular, specularPower,
specularColor)
vp2 += input_mesh
def main():
nargs = len(sys.argv)
if nargs < 2:
sphere_source = vtk.vtkSphereSource()
sphere_source.Update()
polyData = sphere_source.GetOutput()
else:
reader = vtkXMLPolyDataReader()
reader.SetFileName(sys.argv[1])
clean = vtk.vtkCleanPolyData()
clean.SetInputConnection(reader.GetOutputPort())
clean.Update()
poly_data = clean.GetOutput()
colors = vtk.vtkNamedColors()
#create mapper and actor for original model
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(poly_data)
mapper.ScalarVisibilityOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetInterpolationToFlat()
#actor.GetProperty().SetColor(colors.GetColor3d("Banana").GetData())
actor.GetProperty().SetColor(1., 0., 1.)
#create renderer and renderWindow
renderer = vtk.vtkRenderer()
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
renderer.AddActor(actor) #view the original model
#Compute the silhouette
silhouette = vtk.vtkPolyDataSilhouette()
silhouette.SetInputData(poly_data)
silhouette.SetCamera(renderer.GetActiveCamera())
silhouette.SetEnableFeatureAngle(0)
#create mapper and actor for silouette
mapper2 = vtk.vtkPolyDataMapper()
mapper2.SetInputConnection(silhouette.GetOutputPort())
actor2 = vtk.vtkActor()
actor2.SetMapper(mapper2)
#actor2.GetProperty().SetColor(colors.GetColor3d("Tomato").GetData())
actor2.GetProperty().SetColor(1., 1., 0.)
actor2.GetProperty().SetLineWidth(5)
renderer.AddActor(actor2)
#renderer.SetBackground(colors.GetColor3d("Silver").GetData())
renderer.SetBackground(0.1, 0.2, 0.5)
renderer.ResetCamera()
renderer.GetActiveCamera().Azimuth(30)
renderer.GetActiveCamera().Elevation(30)
renderer.GetActiveCamera().Dolly(1.5)
renderer.ResetCameraClippingRange()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(render_window)
#render and interact
render_window.SetSize(640, 480)
render_window.Render()
iren.Start()
