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 __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 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 __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