def testImage2DScalar(self):
planes = ['XY', 'XZ', 'YZ']
expectedNCells = [38, 46, 42]
expectedNClippedCells = [104, 104, 106]
for plane, nCells, nClippedCells in zip(planes,expectedNCells,expectedNClippedCells):
r = vtk.vtkRTAnalyticSource()
r.SetXFreq(600);
r.SetYFreq(400);
r.SetZFreq(900);
if plane == 'XY':
r.SetWholeExtent(-5, 5, -5, 5, 0, 0)
elif plane == 'XZ':
r.SetWholeExtent(-5, 5, 0, 0, -5, 5)
else:
r.SetWholeExtent(0, 0, -5, 5, -5, 5)
r.Update()
c = vtk.vtkTableBasedClipDataSet()
c.SetInputConnection(r.GetOutputPort())
c.SetUseValueAsOffset(0)
c.SetValue(150)
c.SetInsideOut(1)
c.SetGenerateClippedOutput(1)
c.Update()
self.assertEqual(c.GetOutput().GetNumberOfCells(), nCells)
self.assertEqual(c.GetClippedOutput().GetNumberOfCells(), nClippedCells)
def testStructured(self):
rt = vtk.vtkRTAnalyticSource()
rt.SetWholeExtent(-5, 5, -5, 5, -5, 5)
rt.Update()
i = rt.GetOutput()
st = vtk.vtkStructuredGrid()
st.SetDimensions(i.GetDimensions())
nps = i.GetNumberOfPoints()
ps = vtk.vtkPoints()
ps.SetNumberOfPoints(nps)
for idx in range(nps):
ps.SetPoint(idx, i.GetPoint(idx))
st.SetPoints(ps)
s = vtk.vtkSphere()
s.SetRadius(2)
s.SetCenter(0,0,0)
c = vtk.vtkTableBasedClipDataSet()
c.SetInputData(st)
c.SetClipFunction(s)
c.SetInsideOut(1)
c.Update()
self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
def testImage2DScalar(self):
planes = ['XY', 'XZ', 'YZ']
expectedNCells = [38, 46, 42]
for plane, nCells in zip(planes,expectedNCells):
r = vtk.vtkRTAnalyticSource()
r.SetXFreq(600);
r.SetYFreq(400);
r.SetZFreq(900);
if plane == 'XY':
r.SetWholeExtent(-5, 5, -5, 5, 0, 0)
elif plane == 'XZ':
r.SetWholeExtent(-5, 5, 0, 0, -5, 5)
else:
r.SetWholeExtent(0, 0, -5, 5, -5, 5)
r.Update()
c = vtk.vtkTableBasedClipDataSet()
c.SetInputConnection(r.GetOutputPort())
c.SetUseValueAsOffset(0)
c.SetValue(150)
c.SetInsideOut(1)
c.Update()
self.assertEqual(c.GetOutput().GetNumberOfCells(), nCells)
def testUnstructured(self):
rt = vtk.vtkRTAnalyticSource()
rt.SetWholeExtent(-5, 5, -5, 5, -5, 5)
t = vtk.vtkThreshold()
t.SetInputConnection(rt.GetOutputPort())
t.ThresholdByUpper(-10)
s = vtk.vtkSphere()
s.SetRadius(2)
s.SetCenter(0,0,0)
c = vtk.vtkTableBasedClipDataSet()
c.SetInputConnection(t.GetOutputPort())
c.SetClipFunction(s)
c.SetInsideOut(1)
c.Update()
self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
eg = vtk.vtkEnSightGoldReader()
eg.SetCaseFileName(VTK_DATA_ROOT + "/Data/EnSight/elements.case")
eg.Update()
pl = vtk.vtkPlane()
pl.SetOrigin(3.5, 3.5, 0.5)
pl.SetNormal(0, 0, 1)
c.SetInputConnection(eg.GetOutputPort())
c.SetClipFunction(pl)
c.SetInsideOut(1)
c.Update()
data = c.GetOutputDataObject(0).GetBlock(0)
self.assertEqual(data.GetNumberOfCells(), 75)
rw = vtk.vtkRenderWindow()
ren = vtk.vtkRenderer()
rw.AddRenderer(ren)
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(data)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
ren.AddActor(actor)
ac = ren.GetActiveCamera()
ac.SetPosition(-7.9, 9.7, 14.6)
ac.SetFocalPoint(3.5, 3.5, 0.5)
ac.SetViewUp(0.08, 0.93, -0.34)
rw.Render()
ren.ResetCameraClippingRange()
rtTester = vtk.vtkTesting()
for arg in sys.argv[1:]:
rtTester.AddArgument(arg)
rtTester.AddArgument("-V")
rtTester.AddArgument("tableBasedClip.png")
rtTester.SetRenderWindow(rw)
rw.Render()
rtResult = rtTester.RegressionTest(10)
def testStructured(self):
rt = vtk.vtkRTAnalyticSource()
rt.SetWholeExtent(-5, 5, -5, 5, -5, 5)
rt.Update()
i = rt.GetOutput()
st = vtk.vtkStructuredGrid()
st.SetDimensions(i.GetDimensions())
nps = i.GetNumberOfPoints()
ps = vtk.vtkPoints()
ps.SetNumberOfPoints(nps)
for idx in xrange(nps):
ps.SetPoint(idx, i.GetPoint(idx))
st.SetPoints(ps)
s = vtk.vtkSphere()
s.SetRadius(2)
s.SetCenter(0,0,0)
c = vtk.vtkTableBasedClipDataSet()
c.SetInputData(st)
c.SetClipFunction(s)
c.SetInsideOut(1)
c.Update()
self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
def testUnstructured(self):
rt = vtk.vtkRTAnalyticSource()
rt.SetWholeExtent(-5, 5, -5, 5, -5, 5)
t = vtk.vtkThreshold()
t.SetInputConnection(rt.GetOutputPort())
t.ThresholdByUpper(-10)
s = vtk.vtkSphere()
s.SetRadius(2)
s.SetCenter(0,0,0)
c = vtk.vtkTableBasedClipDataSet()
c.SetInputConnection(t.GetOutputPort())
c.SetClipFunction(s)
c.SetInsideOut(1)
c.Update()
self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
eg = vtk.vtkEnSightGoldReader()
eg.SetCaseFileName(VTK_DATA_ROOT + "/Data/EnSight/elements.case")
eg.Update()
pl = vtk.vtkPlane()
pl.SetOrigin(3.5, 3.5, 0.5)
pl.SetNormal(0, 0, 1)
c.SetInputConnection(eg.GetOutputPort())
c.SetClipFunction(pl)
c.SetInsideOut(1)
c.Update()
data = c.GetOutputDataObject(0).GetBlock(0)
self.assertEqual(data.GetNumberOfCells(), 75)
rw = vtk.vtkRenderWindow()
ren = vtk.vtkRenderer()
rw.AddRenderer(ren)
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(data)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
ren.AddActor(actor)
ac = ren.GetActiveCamera()
ac.SetPosition(-7.9, 9.7, 14.6)
ac.SetFocalPoint(3.5, 3.5, 0.5)
ac.SetViewUp(0.08, 0.93, -0.34)
rw.Render()
ren.ResetCameraClippingRange()
rtTester = vtk.vtkTesting()
for arg in sys.argv[1:]:
rtTester.AddArgument(arg)
rtTester.AddArgument("-V")
rtTester.AddArgument("tableBasedClip.png")
rtTester.SetRenderWindow(rw)
rw.Render()
rtResult = rtTester.RegressionTest(10)
def __init__(self, original_actor, plane):
PeacockActor.__init__(self, original_actor.renderer)
self.original_actor = original_actor
self.plane = plane
self.clipper = vtk.vtkTableBasedClipDataSet()
self.clipper.SetInput(self.original_actor.mesh)
self.clipper.SetClipFunction(self.plane)
self.clipper.Update()
self.clip_mapper = vtk.vtkDataSetMapper()
self.clip_mapper.SetInput(self.clipper.GetOutput())
self.clip_actor = vtk.vtkActor()
self.clip_actor.SetMapper(self.clip_mapper)
def __init__(self, original_actor, plane):
PeacockActor.__init__(self, original_actor.renderer)
self.original_actor = original_actor
self.plane = plane
self.clipper = vtk.vtkTableBasedClipDataSet()
self.clipper.SetInput(self.original_actor.mesh)
self.clipper.SetClipFunction(self.plane)
self.clipper.Update()
self.clip_mapper = vtk.vtkDataSetMapper()
self.clip_mapper.SetInput(self.clipper.GetOutput())
self.clip_actor = vtk.vtkActor()
self.clip_actor.SetMapper(self.clip_mapper)
def clip(self):
'''
Activates clipping by hiding mesh_actor and replacing it with a clipped actor based on the points set in the text box. Clipping plane is specified by the plane defined by 'Start','End' and 'Clip'.
Clipping is removed by specifying zeros for the third point, and by virtue avoids a divide by zero error when calculating the clipping plane normal.
'''
if hasattr(self,'clipped_actor'):
self.ren.RemoveActor(self.clipped_actor)
#read points for plane
p1 = np.array([self.ui.point1_x_coord.value(), self.ui.point1_y_coord.value(), self.ui.point1_z_coord.value()])
p2 = np.array([self.ui.point2_x_coord.value(), self.ui.point2_y_coord.value(), self.ui.point2_z_coord.value()])
p3 = np.array([self.ui.clip_x_coord.value(), self.ui.clip_y_coord.value(), self.ui.clip_z_coord.value()])
c = p3 == np.zeros(3)
if c.all() and self.mesh_actor.GetVisibility() == 0: #no clipping plane (p3 = 0,0,0) is specified & mesh is hidden
flip_visible(self.mesh_actor)
elif not c.all():
clipPlane = vtk.vtkPlane()
clipPlane.SetOrigin(((p1+p2)/2).tolist())
#solve cross product between p1,p2 and p2,p3
xnorm = np.cross((p2-p1),(p3-p2))
xnorm = xnorm / np.sqrt(np.sum(xnorm**2))
clipPlane.SetNormal(xnorm.tolist())
clipper = vtk.vtkTableBasedClipDataSet() #needs to be table based, otherwise the grid is interpolated
clipper.SetClipFunction(clipPlane)
clipper.SetInputData(self.vtu_output) #needs to remain vtk object
clipper.GenerateClippedOutputOn()
clipper.Update()
self.clip_mapper = vtk.vtkDataSetMapper()
self.clip_mapper.SetInputData(clipper.GetClippedOutput())
self.clip_mapper.SetLookupTable(self.mesh_lut)
self.clip_mapper.SetScalarRange(self.vtu_output.GetScalarRange())
self.clipped_actor = vtk.vtkActor()
self.clipped_actor.SetMapper(self.clip_mapper)
if self.ui.mesh_display.isChecked():
self.clipped_actor.GetProperty().EdgeVisibilityOff()
else:
self.clipped_actor.GetProperty().EdgeVisibilityOn()
if self.mesh_actor.GetVisibility() == 1:
flip_visible(self.mesh_actor)
self.ren.AddActor(self.clipped_actor)
self.ui.vtkWidget.update()
def testImage(self):
r = vtk.vtkRTAnalyticSource()
r.SetWholeExtent(-5, 5, -5, 5, -5, 5)
r.Update()
s = vtk.vtkSphere()
s.SetRadius(2)
s.SetCenter(0,0,0)
c = vtk.vtkTableBasedClipDataSet()
c.SetInputConnection(r.GetOutputPort())
c.SetClipFunction(s)
c.SetInsideOut(1)
c.Update()
self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
def testImage(self):
r = vtk.vtkRTAnalyticSource()
r.SetWholeExtent(-5, 5, -5, 5, -5, 5)
r.Update()
s = vtk.vtkSphere()
s.SetRadius(2)
s.SetCenter(0,0,0)
c = vtk.vtkTableBasedClipDataSet()
c.SetInputConnection(r.GetOutputPort())
c.SetClipFunction(s)
c.SetInsideOut(1)
c.Update()
self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
def testRectilinear(self):
rt = vtk.vtkRTAnalyticSource()
rt.SetWholeExtent(-5, 5, -5, 5, -5, 5)
rt.Update()
i = rt.GetOutput()
r = vtk.vtkRectilinearGrid()
dims = i.GetDimensions()
r.SetDimensions(dims)
exts = i.GetExtent()
orgs = i.GetOrigin()
xs = vtk.vtkFloatArray()
xs.SetNumberOfTuples(dims[0])
for d in range(dims[0]):
xs.SetTuple1(d, orgs[0] + exts[0] + d)
r.SetXCoordinates(xs)
ys = vtk.vtkFloatArray()
ys.SetNumberOfTuples(dims[1])
for d in range(dims[1]):
ys.SetTuple1(d, orgs[1] + exts[2] + d)
r.SetYCoordinates(ys)
zs = vtk.vtkFloatArray()
zs.SetNumberOfTuples(dims[2])
for d in range(dims[2]):
zs.SetTuple1(d, orgs[2] + exts[4] + d)
r.SetZCoordinates(zs)
s = vtk.vtkSphere()
s.SetRadius(2)
s.SetCenter(0,0,0)
c = vtk.vtkTableBasedClipDataSet()
c.SetInputData(r)
c.SetClipFunction(s)
c.SetInsideOut(1)
c.Update()
self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
def testRectilinear(self):
rt = vtk.vtkRTAnalyticSource()
rt.SetWholeExtent(-5, 5, -5, 5, -5, 5)
rt.Update()
i = rt.GetOutput()
r = vtk.vtkRectilinearGrid()
dims = i.GetDimensions()
r.SetDimensions(dims)
exts = i.GetExtent()
orgs = i.GetOrigin()
xs = vtk.vtkFloatArray()
xs.SetNumberOfTuples(dims[0])
for d in range(dims[0]):
xs.SetTuple1(d, orgs[0] + exts[0] + d)
r.SetXCoordinates(xs)
ys = vtk.vtkFloatArray()
ys.SetNumberOfTuples(dims[1])
for d in range(dims[1]):
ys.SetTuple1(d, orgs[1] + exts[2] + d)
r.SetYCoordinates(ys)
zs = vtk.vtkFloatArray()
zs.SetNumberOfTuples(dims[2])
for d in range(dims[2]):
zs.SetTuple1(d, orgs[2] + exts[4] + d)
r.SetZCoordinates(zs)
s = vtk.vtkSphere()
s.SetRadius(2)
s.SetCenter(0,0,0)
c = vtk.vtkTableBasedClipDataSet()
c.SetInputData(r)
c.SetClipFunction(s)
c.SetInsideOut(1)
c.Update()
self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
def testStructured2D(self):
planes = ['XY', 'XZ', 'YZ']
expectedNCells = [42, 34, 68]
for plane, nCells in zip(planes,expectedNCells):
rt = vtk.vtkRTAnalyticSource()
if plane == 'XY':
rt.SetWholeExtent(-5, 5, -5, 5, 0, 0)
elif plane == 'XZ':
rt.SetWholeExtent(-5, 5, 0, 0, -5, 5)
else:
rt.SetWholeExtent(0, 0, -5, 5, -5, 5)
rt.Update()
i = rt.GetOutput()
st = vtk.vtkStructuredGrid()
st.SetDimensions(i.GetDimensions())
nps = i.GetNumberOfPoints()
ps = vtk.vtkPoints()
ps.SetNumberOfPoints(nps)
for idx in range(nps):
ps.SetPoint(idx, i.GetPoint(idx))
st.SetPoints(ps)
cyl = vtk.vtkCylinder()
cyl.SetRadius(2)
cyl.SetCenter(0,0,0)
transform = vtk.vtkTransform()
transform.RotateWXYZ(45,20,1,10)
cyl.SetTransform(transform)
c = vtk.vtkTableBasedClipDataSet()
c.SetInputData(st)
c.SetClipFunction(cyl)
c.SetInsideOut(1)
c.Update()
self.assertEqual(c.GetOutput().GetNumberOfCells(), nCells)
def testStructured2D(self):
planes = ['XY', 'XZ', 'YZ']
expectedNCells = [42, 34, 68]
for plane, nCells in zip(planes,expectedNCells):
rt = vtk.vtkRTAnalyticSource()
if plane == 'XY':
rt.SetWholeExtent(-5, 5, -5, 5, 0, 0)
elif plane == 'XZ':
rt.SetWholeExtent(-5, 5, 0, 0, -5, 5)
else:
rt.SetWholeExtent(0, 0, -5, 5, -5, 5)
rt.Update()
i = rt.GetOutput()
st = vtk.vtkStructuredGrid()
st.SetDimensions(i.GetDimensions())
nps = i.GetNumberOfPoints()
ps = vtk.vtkPoints()
ps.SetNumberOfPoints(nps)
for idx in range(nps):
ps.SetPoint(idx, i.GetPoint(idx))
st.SetPoints(ps)
cyl = vtk.vtkCylinder()
cyl.SetRadius(2)
cyl.SetCenter(0,0,0)
transform = vtk.vtkTransform()
transform.RotateWXYZ(45,20,1,10)
cyl.SetTransform(transform)
c = vtk.vtkTableBasedClipDataSet()
c.SetInputData(st)
c.SetClipFunction(cyl)
c.SetInsideOut(1)
c.Update()
self.assertEqual(c.GetOutput().GetNumberOfCells(), nCells)
def __init__(self, original_actor, plane):
PeacockActor.__init__(self, original_actor.renderer)
self.original_actor = original_actor
self.plane = plane
self.clipper = vtk.vtkTableBasedClipDataSet()
if vtk.VTK_MAJOR_VERSION <= 5:
self.clipper.SetInput(self.original_actor.mesh)
else:
self.clipper.SetInputData(self.original_actor.mesh)
self.clipper.SetClipFunction(self.plane)
self.clipper.Update()
self.clip_mapper = vtk.vtkDataSetMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
self.clip_mapper.SetInput(self.clipper.GetOutput())
else:
self.clip_mapper.SetInputConnection(self.clipper.GetOutputPort())
self.clip_actor = vtk.vtkActor()
self.clip_actor.SetMapper(self.clip_mapper)
def add_mesh_clip_plane(self,
mesh,
normal='x',
invert=False,
widget_color=None,
value=0.0,
assign_to_axis=None,
tubing=False,
origin_translation=True,
outline_translation=False,
implicit=True,
**kwargs):
"""Clip a mesh using a plane widget.
Add a mesh to the scene with a plane widget that is used to clip
the mesh interactively.
The clipped mesh is saved to the ``.plane_clipped_meshes`` attribute on
the plotter.
Parameters
----------
mesh : pyvista.Common
The input dataset to add to the scene and clip
normal : str or tuple(float)
The starting normal vector of the plane
invert : bool
Flag on whether to flip/invert the clip
kwargs : dict
All additional keyword arguments are passed to ``add_mesh`` to
control how the mesh is displayed.
"""
name = kwargs.get('name', str(hex(id(mesh))))
rng = mesh.get_data_range(kwargs.get('scalars', None))
kwargs.setdefault('clim', kwargs.pop('rng', rng))
self.add_mesh(mesh.outline(), name=name + "outline", opacity=0.0)
if isinstance(mesh, vtk.vtkPolyData):
alg = vtk.vtkClipPolyData()
# elif isinstance(mesh, vtk.vtkImageData):
# alg = vtk.vtkClipVolume()
# alg.SetMixed3DCellGeneration(True)
else:
alg = vtk.vtkTableBasedClipDataSet()
alg.SetInputDataObject(
mesh) # Use the grid as the data we desire to cut
alg.SetValue(value)
alg.SetInsideOut(invert) # invert the clip if needed
if not hasattr(self, "plane_clipped_meshes"):
self.plane_clipped_meshes = []
plane_clipped_mesh = pyvista.wrap(alg.GetOutput())
self.plane_clipped_meshes.append(plane_clipped_mesh)
def callback(normal, origin):
function = generate_plane(normal, origin)
alg.SetClipFunction(function) # the implicit function
alg.Update() # Perform the Cut
plane_clipped_mesh.shallow_copy(alg.GetOutput())
self.add_plane_widget(callback=callback,
bounds=mesh.bounds,
factor=1.25,
normal=normal,
color=widget_color,
tubing=tubing,
assign_to_axis=assign_to_axis,
origin_translation=origin_translation,
outline_translation=outline_translation,
implicit=implicit,
origin=mesh.center)
actor = self.add_mesh(plane_clipped_mesh, **kwargs)
return actor
def Execute(args):
print("clip surface")
mesh_reader = vmtkscripts.vmtkMeshReader()
mesh_reader.InputFileName = args.mesh_file
mesh_reader.Execute()
mesh2surf = vmtkscripts.vmtkMeshToSurface()
mesh2surf.Mesh = mesh_reader.Mesh
mesh2surf.CleanOutput = 0
mesh2surf.Execute()
scale_cfd = vmtkscripts.vmtkSurfaceScaling()
scale_cfd.ScaleFactor = args.scale # meters to mm
scale_cfd.Surface = mesh2surf.Surface
scale_cfd.Execute()
surface = vtk.vtkPolyData()
surface.DeepCopy(scale_cfd.Surface)
reader_trim = vmtkscripts.vmtkSurfaceReader()
reader_trim.InputFileName = args.polydata_trim
reader_trim.Execute()
br_trim = reader_trim.Surface
reader_ext = vmtkscripts.vmtkSurfaceReader()
reader_ext.InputFileName = args.polydata_ext
reader_ext.Execute()
br_ext = reader_ext.Surface
# have to make sure that they both have the same number of GetNumberOfPoints
assert br_trim.GetNumberOfPoints() == br_ext.GetNumberOfPoints()
locator = vtk.vtkPointLocator()
locator.SetDataSet(br_trim)
locator.BuildLocator()
point_ext = [0.0, 0.0, 0.0]
pt_cross = [0.0, 0.0, 0.0]
pt_dot = 0.0
count = 0
for trim_id in range(br_ext.GetNumberOfPoints()):
# get extension point
point_ext = br_ext.GetPoint(trim_id)
#closest trim point
point_trim_id = locator.FindClosestPoint(point_ext)
point_trim = br_trim.GetPoint(point_trim_id)
# check that the points are close to the same direction
pt_trim_normal = br_trim.GetPointData().GetArray(
"BoundaryNormals").GetTuple(point_trim_id)
pt_ext_normal = br_ext.GetPointData().GetArray(
"BoundaryNormals").GetTuple(trim_id)
#print(pt_trim_normal, pt_ext_normal)
pt_dot = vtk.vtkMath.Dot(pt_trim_normal, pt_ext_normal)
#vtk.vtkMath.Cross(pt_trim_normal, pt_ext_normal, pt_cross)
#print(pt_dot, vtk.vtkMath.Norm(pt_cross))#, pt_cross)
if (pt_dot < 0.95):
print("help the vectors aren't colinear")
assert pt_dot > .95
v = np.array(point_ext) - np.array(point_trim) #pt1 - pt2
v_mag = np.linalg.norm(v)
n = v / v_mag
# print("should be 1.0", np.linalg.norm(n), n)
b1, b2 = hughes_moeller(n) #orthogonal basis
#Get maximum radius
box_radius = br_ext.GetPointData().GetArray("BoundaryRadius").GetTuple(
trim_id)
box_radius_trim = br_trim.GetPointData().GetArray(
"BoundaryRadius").GetTuple(point_trim_id)
#print(box_radius_trim, box_radius)
extra_room = args.margin
extra_z = 0.0
r_max = extra_room * max([box_radius[0], box_radius_trim[0]
]) # max radius
z_max = extra_room * v_mag
#create transformation matrix
R = np.zeros((4, 4), dtype=np.float64)
R[:3, 0] = b1 #x
R[:3, 1] = b2 #y
R[:3, 2] = n #z
R[:3, 3] = np.array(point_trim) # the beginning of the clip
R[3, 3] = 1.0
trans_matrix = vtk.vtkTransform()
trans_inverse = vtk.vtkTransform()
trans_matrix.SetMatrix(list(R.ravel()))
#print(trans_matrix.GetMatrix())
trans_inverse.DeepCopy(trans_matrix)
trans_inverse.Inverse()
# point to define bounds
dims_min = [-r_max, -r_max, -extra_z * z_max]
dims_max = [r_max, r_max, z_max]
planes = vtk.vtkBox()
planes.SetBounds(dims_min[0], dims_max[0], dims_min[1], dims_max[1],
dims_min[2], dims_max[2])
planes.SetTransform(trans_inverse)
clipper = vtk.vtkTableBasedClipDataSet()
clipper.SetInputData(surface)
clipper.SetClipFunction(planes)
clipper.InsideOutOff()
#clipper.SetMergeTolerance(1.0E-6)
clipper.Update()
#print(clipper.GetMergeTolerance())
surface = clipper.GetOutput()
#test = vtk.vtkCubeSource()
#test.SetBounds (dims_min[0], dims_max[0], dims_min[1], dims_max[1], dims_min[2], dims_max[2])
#trans_cube = vtk.vtkTransformPolyDataFilter()
#trans_cube.SetInputConnection(test.GetOutputPort())
#trans_cube.SetTransform(trans_matrix)
#trans_cube.Update()
#writer2 = vmtkscripts.vmtkSurfaceWriter()
#writer2.OutputFileName = os.path.join(os.path.split(args.out_file)[0], "test_clip_box_{0}.vtp".format(count))
#writer2.Input = trans_cube.GetOutput()
#writer2.Execute()
count += 1
geom = vtk.vtkGeometryFilter()
geom.SetInputData(surface)
geom.Update()
writer = vmtkscripts.vmtkSurfaceWriter()
writer.OutputFileName = args.out_file
writer.Input = geom.GetOutput()
writer.Execute()
def main():
filename = get_program_parameters()
# Create the reader for the data.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
bounds = reader.GetOutput().GetBounds()
center = reader.GetOutput().GetCenter()
colors = vtk.vtkNamedColors()
renderer = vtk.vtkRenderer()
renderer.SetBackground(colors.GetColor3d("Wheat"))
renderer.UseHiddenLineRemovalOn()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(640, 480)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
xnorm = [-1.0, -1.0, 1.0]
clipPlane = vtk.vtkPlane()
clipPlane.SetOrigin(reader.GetOutput().GetCenter())
clipPlane.SetNormal(xnorm)
clipper = vtk.vtkTableBasedClipDataSet()
clipper.SetClipFunction(clipPlane)
clipper.SetInputData(reader.GetOutput())
clipper.SetValue(0.0)
clipper.GenerateClippedOutputOn()
clipper.Update()
insideMapper = vtk.vtkDataSetMapper()
insideMapper.SetInputData(clipper.GetOutput())
insideMapper.ScalarVisibilityOff()
insideActor = vtk.vtkActor()
insideActor.SetMapper(insideMapper)
insideActor.GetProperty().SetDiffuseColor(colors.GetColor3d("banana"))
insideActor.GetProperty().SetAmbient(.3)
insideActor.GetProperty().EdgeVisibilityOn()
clippedMapper = vtk.vtkDataSetMapper()
clippedMapper.SetInputData(clipper.GetClippedOutput())
clippedMapper.ScalarVisibilityOff()
clippedActor = vtk.vtkActor()
clippedActor.SetMapper(clippedMapper)
clippedActor.GetProperty().SetDiffuseColor(colors.GetColor3d("tomato"))
insideActor.GetProperty().SetAmbient(.3)
clippedActor.GetProperty().EdgeVisibilityOn()
# Create transforms to make a better visualization
insideTransform = vtk.vtkTransform()
insideTransform.Translate(-(bounds[1] - bounds[0]) * 0.75, 0, 0)
insideTransform.Translate(center[0], center[1], center[2])
insideTransform.RotateY(-120.0)
insideTransform.Translate(-center[0], -center[1], -center[2])
insideActor.SetUserTransform(insideTransform)
clippedTransform = vtk.vtkTransform()
clippedTransform.Translate((bounds[1] - bounds[0]) * 0.75, 0, 0)
clippedTransform.Translate(center[0], center[1], center[2])
clippedTransform.RotateY(60.0)
clippedTransform.Translate(-center[0], -center[1], -center[2])
clippedActor.SetUserTransform(clippedTransform)
renderer.AddViewProp(clippedActor)
renderer.AddViewProp(insideActor)
renderer.ResetCamera()
renderer.GetActiveCamera().Dolly(1.4)
renderer.ResetCameraClippingRange()
renderWindow.Render()
renderWindow.SetWindowName('ClipUnstructuredGridWithPlane')
renderWindow.Render()
interactor.Start()
# Generate a report
numberOfCells = clipper.GetOutput().GetNumberOfCells()
print("------------------------")
print("The inside dataset contains a \n", clipper.GetOutput().GetClassName(), " that has ", numberOfCells, " cells")
cellMap = dict()
for i in range(0, numberOfCells):
cellMap.setdefault(clipper.GetOutput().GetCellType(i), 0)
cellMap[clipper.GetOutput().GetCellType(i)] += 1
# Sort by key and put into an OrderedDict.
# An OrderedDict remembers the order in which the keys have been inserted.
for k, v in collections.OrderedDict(sorted(cellMap.items())).items():
print("\tCell type ", vtk.vtkCellTypes.GetClassNameFromTypeId(k), " occurs ", v, " times.")
numberOfCells = clipper.GetClippedOutput().GetNumberOfCells()
print("------------------------")
print("The clipped dataset contains a \n", clipper.GetClippedOutput().GetClassName(), " that has ", numberOfCells,
" cells")
outsideCellMap = dict()
for i in range(0, numberOfCells):
outsideCellMap.setdefault(clipper.GetClippedOutput().GetCellType(i), 0)
outsideCellMap[clipper.GetClippedOutput().GetCellType(i)] += 1
for k, v in collections.OrderedDict(sorted(outsideCellMap.items())).items():
print("\tCell type ", vtk.vtkCellTypes.GetClassNameFromTypeId(k), " occurs ", v, " times.")
def setFileName(self, file_name, lut):
try:
self.currently_has_actor = True
self.lut = lut
self.file_name = file_name
self.reader = vtk.vtkExodusIIReader()
self.reader.SetFileName(self.file_name)
self.reader.UpdateInformation()
self.current_dim = self.reader.GetDimensionality()
self.min_timestep = 0
self.max_timestep = 0
range = self.reader.GetTimeStepRange()
self.min_timestep = range[0]
self.max_timestep = range[1]
self.reader.SetAllArrayStatus(vtk.vtkExodusIIReader.ELEM_BLOCK, 1)
self.reader.SetAllArrayStatus(vtk.vtkExodusIIReader.NODAL, 1)
self.reader.SetAllArrayStatus(vtk.vtkExodusIIReader.NODAL_TEMPORAL, 1)
self.reader.SetTimeStep(self.max_timestep)
self.reader.Update()
self.current_variable_point_data = {}
self.current_nodal_variables = []
self.current_elemental_variables = []
self.current_nodal_components = {}
self.current_elemental_components = {}
self.component_index = -1
num_blocks = self.reader.GetNumberOfElementBlockArrays()
self.blocks = set()
self.block_to_name = {}
for i in xrange(num_blocks):
block_num = self.reader.GetObjectId(vtk.vtkExodusIIReader.ELEM_BLOCK,i)
self.blocks.add(block_num)
if 'Unnamed' not in self.reader.GetObjectName(vtk.vtkExodusIIReader.ELEM_BLOCK,i).split(' '):
self.block_to_name[block_num] = self.reader.GetObjectName(vtk.vtkExodusIIReader.ELEM_BLOCK,i).split(' ')[0]
cdp = vtk.vtkCompositeDataPipeline()
vtk.vtkAlgorithm.SetDefaultExecutivePrototype(cdp)
self.output = self.reader.GetOutput()
self.geom = vtk.vtkCompositeDataGeometryFilter()
self.geom.SetInputConnection(0,self.reader.GetOutputPort(0))
self.geom.Update()
self.data = self.geom.GetOutput()
num_nodal_variables = self.data.GetPointData().GetNumberOfArrays()
for var_num in xrange(num_nodal_variables):
var_name = self.data.GetPointData().GetArrayName(var_num)
self.current_nodal_variables.append(var_name)
components = self.data.GetPointData().GetVectors(var_name).GetNumberOfComponents()
self.current_nodal_components[var_name] = components
# self.data.GetPointData().GetVectors(value_string).GetComponentName(0)
num_elemental_variables = self.data.GetCellData().GetNumberOfArrays()
for var_num in xrange(num_elemental_variables):
var_name = self.data.GetCellData().GetArrayName(var_num)
self.current_elemental_variables.append(var_name)
components = self.data.GetCellData().GetVectors(var_name).GetNumberOfComponents()
self.current_elemental_components[var_name] = components
self.application_filter = self.render_widget.application.filterResult(self.geom)
self.mapper = vtk.vtkPolyDataMapper()
# self.mapper.SetInputConnection(self.tf.GetOutputPort())
self.mapper.SetInputConnection(self.application_filter.GetOutputPort())
self.mapper.ScalarVisibilityOn()
self.mapper.SetLookupTable(lut)
self.mapper.SetColorModeToMapScalars()
self.mapper.InterpolateScalarsBeforeMappingOn()
self.actor = vtk.vtkActor()
self.current_actors.append(self.actor)
self.actor.SetMapper(self.mapper)
self.current_actor = self.actor
self.clipper = vtk.vtkTableBasedClipDataSet()
if vtk.VTK_MAJOR_VERSION <= 5:
self.clipper.SetInput(self.output)
else:
self.clipper.SetInputData(self.output)
self.clipper.SetClipFunction(self.plane)
self.clipper.Update()
self.clip_geom = vtk.vtkCompositeDataGeometryFilter()
self.clip_geom.SetInputConnection(0,self.clipper.GetOutputPort(0))
self.clip_geom.Update()
self.clip_data = self.clip_geom.GetOutput()
self.clip_application_filter = self.render_widget.application.filterResult(self.clip_geom)
self.clip_mapper = vtk.vtkPolyDataMapper()
self.clip_mapper.SetInputConnection(self.clip_application_filter.GetOutputPort())
self.clip_mapper.ScalarVisibilityOn()
self.clip_mapper.SetLookupTable(lut)
self.clip_actor = vtk.vtkActor()
self.clip_actor.SetMapper(self.clip_mapper)
self.current_actors.append(self.clip_actor)
self.scalar_bar = vtk.vtkScalarBarActor()
self.current_actors.append(self.scalar_bar)
self.scalar_bar.SetLookupTable(self.mapper.GetLookupTable())
self.scalar_bar.SetNumberOfLabels(4)
self.current_bounds = self.actor.GetBounds()
except:
pass
def Execute(args):
print("clip surface")
reader_ctr = vmtkscripts.vmtkSurfaceReader()
reader_ctr.InputFileName = args.centerlines
reader_ctr.Execute()
centerlines = reader_ctr.Surface
reader_surface = vmtkscripts.vmtkSurfaceReader()
reader_surface.InputFileName = args.surface_file
reader_surface.Execute()
input_surface = reader_surface.Surface
dx = args.slice_thickness
# only get the first three
centroid = [float(i) for i in args.centroid.strip(" ").split(",")][0:3]
neck_centroid = np.array(centroid)
n_pts = centerlines.GetNumberOfPoints()
pt1 = np.array(centerlines.GetPoint(0)) # start point
pt2 = np.array(centerlines.GetPoint(n_pts - 1)) # end point
#print(pt1, pt2)
v = pt2 - pt1 #pt1 - pt2
v_mag = np.linalg.norm(v)
n = v / v_mag
print("should be 1.0", np.linalg.norm(n), n)
b1, b2 = hughes_moeller(n) #orthogonal basis
#Get maximum radius
radius_range = [0.0, 0.0]
centerlines.GetPointData().GetArray(
"MaximumInscribedSphereRadius").GetRange(radius_range, 0)
print(radius_range)
r_max = 2 * radius_range[-1] # max radius
#https://en.wikipedia.org/wiki/Vector_projection
# get starting point from centroid by projecting centroid onto normal direction
neck_projection = np.dot(neck_centroid - pt1, n) * n
neck_start_pt = pt1 + neck_projection
print(neck_start_pt)
#create transformation matrix
R = np.zeros((4, 4), dtype=np.float64)
R[:3, 0] = b1 #x
R[:3, 1] = b2 #y
R[:3, 2] = n #z
R[:3, 3] = neck_start_pt
R[3, 3] = 1.0
trans_matrix = vtk.vtkTransform()
trans_inverse = vtk.vtkTransform()
trans_matrix.SetMatrix(list(R.ravel()))
print(trans_matrix.GetMatrix())
trans_inverse.DeepCopy(trans_matrix)
trans_inverse.Inverse()
count = 0
# slice along normal
a1 = r_max #*b1
a2 = r_max #*b2
start_pt = np.copy(neck_start_pt)
result = itertools.cycle([(1., 1.), (-1., 1.), (-1., -1.), (1., -1.)])
end_pt = 0.0
#slice until there some reasonable overlap at the end
while (np.linalg.norm(neck_projection + (count - 0.5) * dx * n) < v_mag):
print(np.linalg.norm(neck_projection + (count - 0.5) * dx * n), v_mag)
step_dx = count * dx * n
for i in range(4):
box_dir = next(result)
# point to define bounds
#end_pt = start_pt + box_dir[0]*a1 + box_dir[1]*a2 + step_dx
dims = np.array(
[[box_dir[0] * r_max, box_dir[1] * r_max, (count + 1) * dx],
[0.0, 0.0, count * dx]])
dims_min = list(dims.min(axis=0))
dims_max = list(dims.max(axis=0))
print(dims_min, dims_max)
#planes = vtk.vtkBox()
#planes.SetBounds (dims_min[0], dims_max[0], dims_min[1], dims_max[1], dims_min[2], dims_max[2])
#planes.SetTransform(trans_inverse)
surface = vtk.vtkPolyData()
surface.DeepCopy(input_surface)
#surface = Input
for j in range(3):
for k in range(2):
plane = vtk.vtkPlane()
normal = [0.0, 0.0, 0.0]
if (k == 0):
normal[j] = -1.0
plane.SetOrigin(dims_min)
else:
normal[j] = 1.0
plane.SetOrigin(dims_max)
plane.SetNormal(normal)
plane.SetTransform(trans_inverse)
#plane.SetTransform(trans_matrix)
clipper = vtk.vtkTableBasedClipDataSet()
clipper.SetInputData(surface)
clipper.SetClipFunction(plane)
#clipper.SetOutputPointsPrecision(vtk.vtkAlgorithm.DOUBLE_PRECISION)
clipper.InsideOutOn()
#clipper.SetMergeTolerance(1.0E-6)
clipper.Update()
#print(clipper.GetMergeTolerance())
surface = clipper.GetOutput()
geom = vtk.vtkGeometryFilter()
geom.SetInputData(surface)
geom.Update()
writer = vmtkscripts.vmtkSurfaceWriter()
writer.OutputFileName = os.path.join(
args.out_dir,
"{0}_{1}_quad_{2}.vtp".format(args.out_file, count, i))
writer.Input = geom.GetOutput()
writer.Execute()
if (count == 1):
test = vtk.vtkCubeSource()
test.SetBounds(dims_min[0], dims_max[0], dims_min[1],
dims_max[1], dims_min[2], dims_max[2])
trans_cube = vtk.vtkTransformPolyDataFilter()
trans_cube.SetInputConnection(test.GetOutputPort())
trans_cube.SetTransform(trans_matrix)
trans_cube.Update()
writer2 = vmtkscripts.vmtkSurfaceWriter()
writer2.OutputFileName = os.path.join(
args.out_dir,
"{0}_{1}_quad{2}_box.vtp".format(args.out_file, count, i))
writer2.Input = trans_cube.GetOutput()
writer2.Execute()
count += 1
def setFileName(self, file_name, lut):
try:
self.currently_has_actor = True
self.lut = lut
self.file_name = file_name
self.reader = vtk.vtkExodusIIReader()
self.reader.SetFileName(self.file_name)
self.reader.UpdateInformation()
self.current_dim = self.reader.GetDimensionality()
self.min_timestep = 0
self.max_timestep = 0
range = self.reader.GetTimeStepRange()
self.min_timestep = range[0]
self.max_timestep = range[1]
self.reader.SetAllArrayStatus(vtk.vtkExodusIIReader.ELEM_BLOCK, 1)
self.reader.SetAllArrayStatus(vtk.vtkExodusIIReader.NODAL, 1)
self.reader.SetAllArrayStatus(vtk.vtkExodusIIReader.NODAL_TEMPORAL,
1)
self.reader.SetTimeStep(self.max_timestep)
self.reader.Update()
self.current_variable_point_data = {}
self.current_nodal_variables = []
self.current_elemental_variables = []
self.current_nodal_components = {}
self.current_elemental_components = {}
self.component_index = -1
num_blocks = self.reader.GetNumberOfElementBlockArrays()
self.blocks = set()
self.block_to_name = {}
for i in xrange(num_blocks):
block_num = self.reader.GetObjectId(
vtk.vtkExodusIIReader.ELEM_BLOCK, i)
self.blocks.add(block_num)
if 'Unnamed' not in self.reader.GetObjectName(
vtk.vtkExodusIIReader.ELEM_BLOCK, i).split(' '):
self.block_to_name[block_num] = self.reader.GetObjectName(
vtk.vtkExodusIIReader.ELEM_BLOCK, i).split(' ')[0]
cdp = vtk.vtkCompositeDataPipeline()
vtk.vtkAlgorithm.SetDefaultExecutivePrototype(cdp)
self.output = self.reader.GetOutput()
self.geom = vtk.vtkCompositeDataGeometryFilter()
self.geom.SetInputConnection(0, self.reader.GetOutputPort(0))
self.geom.Update()
self.data = self.geom.GetOutput()
num_nodal_variables = self.data.GetPointData().GetNumberOfArrays()
for var_num in xrange(num_nodal_variables):
var_name = self.data.GetPointData().GetArrayName(var_num)
self.current_nodal_variables.append(var_name)
components = self.data.GetPointData().GetVectors(
var_name).GetNumberOfComponents()
self.current_nodal_components[var_name] = components
# self.data.GetPointData().GetVectors(value_string).GetComponentName(0)
num_elemental_variables = self.data.GetCellData(
).GetNumberOfArrays()
for var_num in xrange(num_elemental_variables):
var_name = self.data.GetCellData().GetArrayName(var_num)
self.current_elemental_variables.append(var_name)
components = self.data.GetCellData().GetVectors(
var_name).GetNumberOfComponents()
self.current_elemental_components[var_name] = components
self.application_filter = self.render_widget.application.filterResult(
self.geom)
self.mapper = vtk.vtkPolyDataMapper()
# self.mapper.SetInputConnection(self.tf.GetOutputPort())
self.mapper.SetInputConnection(
self.application_filter.GetOutputPort())
self.mapper.ScalarVisibilityOn()
self.mapper.SetLookupTable(lut)
self.mapper.SetColorModeToMapScalars()
self.mapper.InterpolateScalarsBeforeMappingOn()
self.actor = vtk.vtkActor()
self.current_actors.append(self.actor)
self.actor.SetMapper(self.mapper)
self.current_actor = self.actor
self.clipper = vtk.vtkTableBasedClipDataSet()
if vtk.VTK_MAJOR_VERSION <= 5:
self.clipper.SetInput(self.output)
else:
self.clipper.SetInputData(self.output)
self.clipper.SetClipFunction(self.plane)
self.clipper.Update()
self.clip_geom = vtk.vtkCompositeDataGeometryFilter()
self.clip_geom.SetInputConnection(0, self.clipper.GetOutputPort(0))
self.clip_geom.Update()
self.clip_data = self.clip_geom.GetOutput()
self.clip_application_filter = self.render_widget.application.filterResult(
self.clip_geom)
self.clip_mapper = vtk.vtkPolyDataMapper()
self.clip_mapper.SetInputConnection(
self.clip_application_filter.GetOutputPort())
self.clip_mapper.ScalarVisibilityOn()
self.clip_mapper.SetLookupTable(lut)
self.clip_actor = vtk.vtkActor()
self.clip_actor.SetMapper(self.clip_mapper)
self.current_actors.append(self.clip_actor)
self.scalar_bar = vtk.vtkScalarBarActor()
self.current_actors.append(self.scalar_bar)
self.scalar_bar.SetLookupTable(self.mapper.GetLookupTable())
self.scalar_bar.SetNumberOfLabels(4)
self.current_bounds = self.actor.GetBounds()
except:
pass
