def read_obj_files( number_of_buildings, begin_building_index, end_building_index, lod, files, file_offset): """ Builds a multiblock dataset (similar with one built by the CityGML reader) from a list of OBJ files. """ if number_of_buildings == UNINITIALIZED and begin_building_index != UNINITIALIZED and end_building_index != UNINITIALIZED: building_range = range(begin_building_index, end_building_index) else: building_range = range(0, min(len(files), number_of_buildings)) root = vtk.vtkMultiBlockDataSet() for i in building_range: reader = vtk.vtkOBJReader() reader.SetFileName(files[i]) reader.Update() if i == 0: gdal_utils.read_offset(files[i], file_offset) polydata = reader.GetOutput() if (polydata.GetNumberOfPoints() == 0): logging.warning("Empty OBJ file: {}".format(files[i])) continue texture_file = get_obj_texture_file_name(files[i]) set_field(polydata, "texture_uri", texture_file) building = vtk.vtkMultiBlockDataSet() building.SetBlock(0, polydata) root.SetBlock(root.GetNumberOfBlocks(), building) return root
def main(): colors = vtk.vtkNamedColors() # PART 1 Make some Data. # Make a tree. root = vtk.vtkMultiBlockDataSet() branch = vtk.vtkMultiBlockDataSet() root.SetBlock(0, branch) # Make some leaves. leaf1 = vtk.vtkSphereSource() leaf1.SetCenter(0, 0, 0) leaf1.Update() branch.SetBlock(0, leaf1.GetOutput()) leaf2 = vtk.vtkSphereSource() leaf2.SetCenter(1.75, 2.5, 0) leaf2.SetRadius(1.5) leaf2.Update() branch.SetBlock(1, leaf2.GetOutput()) leaf3 = vtk.vtkSphereSource() leaf3.SetCenter(4, 0, 0) leaf3.SetRadius(2) leaf3.Update() root.SetBlock(1, leaf3.GetOutput()) # PART 2 Do something with the data # a non composite aware filter, the pipeline will iterate edges = vtk.vtkExtractEdges() edges.SetInputData(root) # PART 3 Show the data # also demonstrate a composite aware filter # this filter aggregates all blocks into one polydata # this is handy for display, although fairly limited # see vtkCompositePolyDataMapper2 for something better polydata = vtk.vtkCompositeDataGeometryFilter() polydata.SetInputConnection(edges.GetOutputPort()) # Create the Renderer, RenderWindow, and RenderWindowInteractor. renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(0, polydata.GetOutputPort(0)) actor = vtk.vtkActor() actor.GetProperty().SetColor(colors.GetColor3d("Yellow")) actor.GetProperty().SetLineWidth(2) actor.SetMapper(mapper) # Enable user interface interactor. renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d("CornflowerBlue")) renderWindow.Render() renderWindowInteractor.Start()
def test_multi_block_init_vtk(): multi = vtk.vtkMultiBlockDataSet() multi.SetBlock(0, vtk.vtkRectilinearGrid()) multi.SetBlock(1, vtk.vtkStructuredGrid()) multi = pyvista.MultiBlock(multi) assert isinstance(multi, pyvista.MultiBlock) assert multi.n_blocks == 2 assert isinstance(multi.GetBlock(0), pyvista.RectilinearGrid) assert isinstance(multi.GetBlock(1), pyvista.StructuredGrid) multi = vtk.vtkMultiBlockDataSet() multi.SetBlock(0, vtk.vtkRectilinearGrid()) multi.SetBlock(1, vtk.vtkStructuredGrid()) multi = pyvista.MultiBlock(multi, deep=True) assert isinstance(multi, pyvista.MultiBlock) assert multi.n_blocks == 2 assert isinstance(multi.GetBlock(0), pyvista.RectilinearGrid) assert isinstance(multi.GetBlock(1), pyvista.StructuredGrid) # Test nested structure multi = vtk.vtkMultiBlockDataSet() multi.SetBlock(0, vtk.vtkRectilinearGrid()) multi.SetBlock(1, vtk.vtkImageData()) nested = vtk.vtkMultiBlockDataSet() nested.SetBlock(0, vtk.vtkUnstructuredGrid()) nested.SetBlock(1, vtk.vtkStructuredGrid()) multi.SetBlock(2, nested) # Wrap the nested structure multi = pyvista.MultiBlock(multi) assert isinstance(multi, pyvista.MultiBlock) assert multi.n_blocks == 3 assert isinstance(multi.GetBlock(0), pyvista.RectilinearGrid) assert isinstance(multi.GetBlock(1), pyvista.UniformGrid) assert isinstance(multi.GetBlock(2), pyvista.MultiBlock)
def write_data(engine, file_name, steps_per_file, n_its): # initialize the analysis adaptor aw = ADIOS2AnalysisAdaptor.New() aw.SetEngineName(engine) aw.SetFileName(file_name) aw.SetStepsPerFile(steps_per_file) aw.SetDebugMode(1) # create the datasets # the first mesh is an image im = vtk.vtkMultiBlockDataSet() im.SetNumberOfBlocks(n_ranks) im.SetBlock(rank, get_image(rank, rank, 0, 16, 0, 1)) # the second mesh is unstructured ug = vtk.vtkMultiBlockDataSet() ug.SetNumberOfBlocks(n_ranks) ug.SetBlock(rank, get_polydata(16)) # associate a name with each mesh meshes = {'image': im, 'unstructured': ug} # loop over time steps i = 0 while i < n_its: t = float(i) it = i # pass into the data adaptor status_message('initializing the VTKDataAdaptor ' \ 'step %d time %0.1f'%(it,t)) da = VTKDataAdaptor.New() da.SetDataTime(t) da.SetDataTimeStep(it) for meshName, mesh in meshes.items(): da.SetDataObject(meshName, mesh) # execute the analysis adaptor status_message('executing ADIOS2AnalysisAdaptor %s ' \ 'step %d time %0.1f'%(engine,it,t)) aw.Execute(da) # free up data da.ReleaseData() da = None i += 1 # force free up the adaptor aw.Finalize() status_message('finished writing %d steps' % (n_its)) # set the return value return 0
def MakeMultiBlock(t, x0,y0, dx,dy, nx, ny, nbx, nby): nBlocks = nbx*nby md = MeshMetadata.New() md.NumBlocks = nBlocks md.BlockOwner = [-1]*nBlocks md.BlockIds = range(0,nBlocks) part = BlockPartitioner.New() md = part.GetPartition(comm, md) mbds = vtk.vtkMultiBlockDataSet() mbds.SetNumberOfBlocks(nBlocks) bit = mbds.NewIterator() bit.SetSkipEmptyNodes(0) bit.InitTraversal() j = 0 while j < nby: i = 0 while i < nbx: q = j*nbx + i if md.BlockOwner[q] == rank: blk = MakeBlock(t, x0,y0, dx,dy, nx,ny, nbx,nby, i,j) mbds.SetDataSet(bit, blk) bit.GoToNextItem() i += 1 j += 1 return mbds
def createMB(piece, num_pieces): output = vtk.vtkMultiBlockDataSet() output.SetNumberOfBlocks(3) output.SetBlock(0, createData([piece], [piece], num_pieces)) output.SetBlock(1, createData(range(num_pieces), [piece], num_pieces)) output.SetBlock(2, createData(range(num_pieces), range(num_pieces), num_pieces)) return output
def assemble_multiblock(internalData, edgeDataDict): """Assemble the multiblock data set from the internal field and boundary data. Parameters ---------- internalData : vtkPolyData The polydata with the internal field edgeDataDict : dictionary A dictionary with each entry being a vtkPolydata corresponding to one edge. Returns ------- vtkMultiBlockDataSet The assembled dataset. """ multiBlock = vtk.vtkMultiBlockDataSet() multiBlock.SetNumberOfBlocks(len(edgeDataDict) + 1) multiBlock.SetBlock(0, internalData) multiBlock.GetMetaData(0).Set(vtk.vtkCompositeDataSet.NAME(), "internalField") i = 1 for boundary in edgeDataDict: multiBlock.SetBlock(i, edgeDataDict[boundary]) multiBlock.GetMetaData(i).Set(vtk.vtkCompositeDataSet.NAME(), boundary) i += 1 return multiBlock
def asdf_to_mbds(self, tree, mbds): def shape_3d(shape): if len(shape) == 3: return shape elif len(shape) == 2: return (1, ) + shape elif len(shape) == 1: return (1, 1) + shape else: return (1, 1, np.prod(shape)) # mbds = vtk.MultiBlockDataSet() for (i, k) in enumerate(tree): obj = tree[k] # print(obj) if isinstance(obj, dict): child_mbds = vtk.vtkMultiBlockDataSet() self.asdf_to_mbds(obj, child_mbds) mbds.SetBlock(i, child_mbds) mbds.GetMetaData(i).Set(vtk.vtkCompositeDataSet.NAME(), k) elif hasattr(obj, 'shape'): vtkdata = vtk.vtkImageData() dim = tuple(reversed(shape_3d(obj.shape[0:-1]))) arr = obj[:] arr.shape = (np.prod(dim), arr.shape[-1]) vtkdata.SetDimensions(dim) data = dsa.WrapDataObject(vtkdata) data.PointData.append(arr, k) mbds.SetBlock(i, vtkdata) mbds.GetMetaData(i).Set(vtk.vtkCompositeDataSet.NAME(), k)
def h5_to_mbds(self, group, mbds): def shape_3d(shape): if len(shape) == 3: return shape elif len(shape) == 2: return (1,) + shape elif len(shape) == 1: return (1, 1) + shape else: return (0, 0, 0) # mbds = vtk.MultiBlockDataSet() for (i, k) in enumerate(group): obj = group[k] # print(obj) if isinstance(obj, h5py.Group): child_mbds = vtk.vtkMultiBlockDataSet() self.h5_to_mbds(obj, child_mbds) mbds.SetBlock(i, child_mbds) mbds.GetMetaData(i).Set(vtk.vtkCompositeDataSet.NAME(), k) elif isinstance(obj, h5py.Dataset): vtkdata = vtk.vtkImageData() shape = tuple(reversed(shape_3d(obj.shape))) # print(shape) vtkdata.SetDimensions(shape) data = dsa.WrapDataObject(vtkdata) arr = obj[:].flatten() # print(arr) data.PointData.append(arr, k) mbds.SetBlock(i, vtkdata) mbds.GetMetaData(i).Set(vtk.vtkCompositeDataSet.NAME(), k)
def exportScene(scene, filePrefix, ext='x3d', names=[]): renWin = scene['window'] ren = scene['renderer'] if ext == 'x3d': writer = vtk.vtkX3DExporter() writer.SetInput(renWin) writer.SetFileName(filePrefix + '.x3d') writer.Update() writer.Write() elif ext == 'obj': writer = vtk.vtkOBJExporter() writer.SetFilePrefix(filePrefix) writer.SetInput(renWin) writer.Write() elif ext == 'vtm': actors = ren.GetActors() actors.InitTraversal() mb = vtk.vtkMultiBlockDataSet() mb.SetNumberOfBlocks(actors.GetNumberOfItems()) for i in range(actors.GetNumberOfItems()): actor = actors.GetNextItem() block = actor.GetMapper().GetInput() mb.GetMetaData(i).Set(vtk.vtkCompositeDataSet.NAME(), names[i]) mb.SetBlock(i, block) writer = vtk.vtkXMLMultiBlockDataWriter() if vtk.VTK_MAJOR_VERSION <= 5: writer.SetInput(mb) else: writer.SetInputData(mb) writer.SetFileName(filePrefix + '.vtm') writer.Write()
def test_multi_block_init_vtk(): multi = vtk.vtkMultiBlockDataSet() multi.SetBlock(0, vtk.vtkRectilinearGrid()) multi.SetBlock(1, vtk.vtkTable()) multi = pyvista.MultiBlock(multi) assert isinstance(multi, pyvista.MultiBlock) assert multi.n_blocks == 2 assert isinstance(multi[0], pyvista.RectilinearGrid) assert isinstance(multi[1], vtk.vtkTable) multi = vtk.vtkMultiBlockDataSet() multi.SetBlock(0, vtk.vtkRectilinearGrid()) multi.SetBlock(1, vtk.vtkTable()) multi = pyvista.MultiBlock(multi, deep=True) assert isinstance(multi, pyvista.MultiBlock) assert multi.n_blocks == 2 assert isinstance(multi[0], pyvista.RectilinearGrid) assert isinstance(multi[1], vtk.vtkTable)
def main(): colors = vtk.vtkNamedColors() # Create Sphere 1. sphere1 = vtk.vtkSphereSource() sphere1.SetRadius(3) sphere1.SetCenter(0, 0, 0) sphere1.Update() # Create Sphere 2. sphere2 = vtk.vtkSphereSource() sphere2.SetRadius(2) sphere2.SetCenter(2, 0, 0) sphere2.Update() mbds = vtk.vtkMultiBlockDataSet() mbds.SetNumberOfBlocks(3) mbds.SetBlock(0, sphere1.GetOutput()) # Leave block 1 NULL. NULL blocks are valid and should be handled by # algorithms that process multiblock datasets. Especially when # running in parallel where the blocks owned by other processes are # NULL in this process. mbds.SetBlock(2, sphere2.GetOutput()) mapper = vtk.vtkCompositePolyDataMapper2() mapper.SetInputDataObject(mbds) cdsa = vtk.vtkCompositeDataDisplayAttributes() mapper.SetCompositeDataDisplayAttributes(cdsa) # You can use the vtkCompositeDataDisplayAttributes to set the color, # opacity and visibiliy of individual blocks of the multiblock dataset. # Attributes are mapped by block pointers (vtkDataObject*), so these can # be queried by their flat index through a convenience function in the # attribute class (vtkCompositeDataDisplayAttributes::DataObjectFromIndex). # Alternatively, one can set attributes directly through the mapper using # flat indices. # # This sets the block at flat index 3 red # Note that the index is the flat index in the tree, so the whole multiblock # is index 0 and the blocks are flat indexes 1, 2 and 3. This affects # the block returned by mbds.GetBlock(2). mapper.SetBlockColor(3, colors.GetColor3d("Red")) actor = vtk.vtkActor() actor.SetMapper(mapper) # Create the Renderer, RenderWindow, and RenderWindowInteractor. renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Enable user interface interactor. renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d("SteelBlue")) renderWindow.Render() renderWindowInteractor.Start()
def RequestData(self, vtkself, request, inputs, output): in_mbds = vtk.vtkMultiBlockDataSet.GetData(inputs[0]) if in_mbds is None: in_mbds = vtk.vtkMultiBlockDataSet() in_mbds.SetBlock(0, vtk.vtkImageData.GetData(inputs[0])) in_mbds.GetMetaData(0).Set(vtk.vtkCompositeDataSet.NAME(), "ImageData") out_mbds = self.OutputDataClass.GetData(output) out_mbds.ShallowCopy(mbdstree.map_mbds(self.splitdatatree, in_mbds))
def callback(mesh_name, structure_only): self.validate_mesh_name(mesh_name) # local bodies pd = self.grid if not structure_only: pass # global dataset mb = vtk.vtkMultiBlockDataSet() mb.SetNumberOfBlocks(n_ranks) mb.SetBlock(rank, pd) return mb
def callback(mesh_name, structure_only): self.validate_mesh_name(mesh_name) # local bodies pd = vtk.vtkPolyData() if not structure_only: pd.SetPoints(self.points) pd.SetVerts(self.cells) # global dataset mb = vtk.vtkMultiBlockDataSet() mb.SetNumberOfBlocks(n_ranks) mb.SetBlock(rank, pd) return mb
def writePolyData(polyDataList, outFile): mb = vtk.vtkMultiBlockDataSet() mb.SetNumberOfBlocks(len(polyDataList)) for i, polyData in enumerate(polyDataList): mb.SetBlock(i, polyData) writer = vtk. vtkXMLMultiBlockDataWriter() writer.SetFileName(outFile) writer.SetInput(mb) writer.Write()
def tubeBlocks(self): '''Generates a tube vtkMultiBlockDataSet.''' if self._tubeBlocksModified: self._tubeBlocksModified = False blocks = vtk.vtkMultiBlockDataSet() for tubeId in self.tubePolys: poly = self.tubePolys[tubeId] curIndex = blocks.GetNumberOfBlocks() blocks.SetBlock(curIndex, poly) blocks.GetMetaData(curIndex).Set(TUBE_ID_KEY, tubeId) self._tubeBlocks = blocks return self._tubeBlocks
def compute_and_visualize_tracts(trekker, position, affine, affine_vtk, n_tracts_max): """ Compute tractograms using the Trekker library. :param trekker: Trekker library instance :type trekker: Trekker.T :param position: 3 double coordinates (x, y, z) in list or array :type position: list :param affine: 4 x 4 numpy double array :type affine: numpy.ndarray :param affine_vtk: vtkMatrix4x4 isntance with affine transformation matrix :type affine_vtk: vtkMatrix4x4 :param n_tracts_max: maximum number of tracts to compute :type n_tracts_max: int """ # root = vtk.vtkMultiBlockDataSet() # Juuso's # seed = np.array([[-8.49, -8.39, 2.5]]) # Baran M1 # seed = np.array([[27.53, -77.37, 46.42]]) seed_trk = img_utils.convert_world_to_voxel(position, affine) bundle = vtk.vtkMultiBlockDataSet() n_branches, n_tracts, count_loop = 0, 0, 0 n_threads = 2 * const.N_CPU - 1 while n_tracts < n_tracts_max: n_param = 1 + (count_loop % 10) # rescale the alpha value that defines the opacity of the branch # the n interval is [1, 10] and the new interval is [51, 255] # the new interval is defined to have no 0 opacity (minimum is 51, i.e., 20%) alpha = (n_param - 1) * (255 - 51) / (10 - 1) + 51 trekker.minFODamp(n_param * 0.01) # print("seed example: {}".format(seed_trk)) trekker.seed_coordinates(np.repeat(seed_trk, n_threads, axis=0)) # print("trk list len: ", len(trekker.run())) trk_list = trekker.run() n_tracts += len(trk_list) if len(trk_list): branch = compute_tracts(trk_list, n_tract=0, alpha=alpha) bundle.SetBlock(n_branches, branch) n_branches += 1 count_loop += 1 if (count_loop == 20) and (n_tracts == 0): break Publisher.sendMessage('Remove tracts') if n_tracts: Publisher.sendMessage('Update tracts', root=bundle, affine_vtk=affine_vtk, coord_offset=position, coord_offset_w=seed_trk[0].tolist())
def writePolyData(polyDataList, outFile): mb = vtk.vtkMultiBlockDataSet() mb.SetNumberOfBlocks(len(polyDataList)) for i, polyData in enumerate(polyDataList): print i, type(polyData) mb.SetBlock(i, polyData) writer = vtk.vtkXMLMultiBlockDataWriter() writer.SetFileName(outFile) writer.SetInput(mb) writer.Write()
def sample_random(mpData, outfile, x): numPieces = mpData.GetNumberOfPieces() print("pieces:", numPieces) multiblock = vtk.vtkMultiBlockDataSet() multiblock.SetNumberOfBlocks(numPieces) # ...do the random sampling w = vtk.vtkXMLMultiBlockDataWriter() w.SetInputData(multiblock) filename = outfile w.SetFileName(filename) w.Write()
def fluidity_to_mblock(state, dump_filename=None): """Convert a fluidity python state into a vtk multiblock dataset. Individual blocks are created for: 1. P0DG and P1 continuous fields 2. P1DG fields (if present) 3. P2 fields (if present) 4. P2DG fields (if present) Returns the vtkMultiBlockDataSet object.""" mblock = vtk.vtkMultiBlockDataSet() # Deal with the P1 data (always present ugrid = fluidity_to_ugrid_p1(state, is_p1, is_p0, state.vector_fields['Coordinate']) mblock.SetBlock(0, ugrid) mblock.GetMetaData(0).Set(vtk.vtkCompositeDataSet.NAME(), 'P1CG') dummy = 1 for name, mesh_test in (('P1DG', is_p1dg), ('P2CG', is_p2), ('P2DG', is_p2dg)): # ugrid = fluidity_to_ugrid_by_mesh(state, mesh_test, exclude=['Old']) # old_ugrid = fluidity_to_ugrid_by_mesh(state, mesh_test, prefix='Old') ugrid = fluidity_to_ugrid_by_mesh(state, mesh_test, exclude=['Old']) if ugrid: mblock.SetBlock(dummy, ugrid) mblock.GetMetaData(dummy).Set(vtk.vtkCompositeDataSet.NAME(), name) #mblock.SetBlock(dummy+1, old_ugrid) #mblock.GetMetaData( dummy+1 ).Set( vtk.vtkCompositeDataSet.NAME(), # 'Old'+name ) dummy += 1 ugrid = fluidity_to_ugrid_p1(state, is_surface_p1, is_surface_p0, state.vector_fields['SurfaceCoordinate']) mblock.SetBlock(dummy, ugrid) mblock.GetMetaData(dummy).Set(vtk.vtkCompositeDataSet.NAME(), 'Boundary') if dump_filename: writer = vtk.vtkXMLMultiBlockDataWriter() if vtk.vtkVersion.GetVTKMajorVersion() < 6: writer.SetInput(mblock) else: writer.SetInputData(mblock) writer.SetFileName(dump_filename) writer.Write() return mblock
def process_tre(in_file, out_dir, phi_vals, theta_vals, width, height): import itk, vtk from vtk.web.dataset_builder import ImageDataSetBuilder reader = itk.SpatialObjectReader[3].New() reader.SetFileName(in_file) reader.Update() blocks = vtk.vtkMultiBlockDataSet() tubeGroup = reader.GetGroup() for tube in _iter_tubes(tubeGroup): polydata = _tube_to_polydata(tube) index = blocks.GetNumberOfBlocks() blocks.SetBlock(index, polydata) prod = vtk.vtkTrivialProducer() prod.SetOutput(blocks) mapper = vtk.vtkCompositePolyDataMapper2() mapper.SetInputConnection(prod.GetOutputPort()) cdsa = vtk.vtkCompositeDataDisplayAttributes() cdsa.SetBlockColor(1, (1, 1, 0)) cdsa.SetBlockColor(2, (0, 1, 1)) mapper.SetCompositeDataDisplayAttributes(cdsa) window = vtk.vtkRenderWindow() window.SetSize(width, height) renderer = vtk.vtkRenderer() window.AddRenderer(renderer) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer.AddActor(actor) renderer.ResetCamera() window.Render() idb = ImageDataSetBuilder(out_dir, 'image/jpg', { 'type': 'spherical', 'phi': phi_vals, 'theta': theta_vals }) idb.start(window, renderer) idb.writeImages() idb.stop()
def run(self): trekker, affine, offset, n_tracts_total, seed_radius, n_threads = self.inp # as a single block, computes all the maximum number of tracts at once, not optimal for navigation n_threads = n_tracts_total p_old = np.array([[0., 0., 0.]]) root = vtk.vtkMultiBlockDataSet() # Compute the tracts # print('ComputeTractsThread: event {}'.format(self.event.is_set())) while not self.event.is_set(): try: coord, m_img, m_img_flip = self.coord_queue.get_nowait() # translate the coordinate along the normal vector of the object/coil coord_offset = m_img_flip[:3, -1] - offset * m_img_flip[:3, 2] # coord_offset = np.array([[27.53, -77.37, 46.42]]) dist = abs(np.linalg.norm(p_old - np.asarray(coord_offset))) p_old = coord_offset.copy() seed_trk = img_utils.convert_world_to_voxel( coord_offset, affine) # Juuso's # seed_trk = np.array([[-8.49, -8.39, 2.5]]) # Baran M1 # seed_trk = np.array([[27.53, -77.37, 46.42]]) # print("Seed: {}".format(seed)) # set the seeds for trekker, one seed is repeated n_threads times # trekker has internal multiprocessing approach done in C. Here the number of available threads is give, # but in case a large number of tracts is requested, it will compute all in parallel automatically # for a more fluent navigation, better to compute the maximum number the computer handles trekker.seed_coordinates(np.repeat(seed_trk, n_threads, axis=0)) # run the trekker, this is the slowest line of code, be careful to just use once! trk_list = trekker.run() if trk_list: # if the seed is outside the defined radius, restart the bundle computation if dist >= seed_radius: root = tracts_computation(trk_list, root, 0) self.visualization_queue.put_nowait((coord, m_img, root)) self.coord_queue.task_done() time.sleep(self.sle) except queue.Empty: pass except queue.Full: self.coord_queue.task_done()
def main(): colors = vtk.vtkNamedColors() # Set the background color. colors.SetColor("BkgColor", [0.3, 0.2, 0.1, 1.0]) input1 = vtk.vtkPolyData() input2 = vtk.vtkPolyData() sphereSource = vtk.vtkSphereSource() sphereSource.SetCenter(5, 0, 0) sphereSource.Update() input1.ShallowCopy(sphereSource.GetOutput()) coneSource = vtk.vtkConeSource() coneSource.Update() input2.ShallowCopy(coneSource.GetOutput()) multiblock = vtk.vtkMultiBlockDataSet() multiblock.SetNumberOfBlocks(2) multiblock.SetBlock(0, input1) multiblock.SetBlock(1, input2) # Create a mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(multiblock.GetBlock(0)) actor = vtk.vtkActor() actor.SetMapper(mapper) # Create a renderer, render window, and interactor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Add the actors to the scene renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d("BkgColor")) # Render and interact renderWindowInteractor.Initialize() renderWindow.Render() renderer.GetActiveCamera().Zoom(0.9) renderWindow.Render() renderWindowInteractor.Start()
def test(self): """`SurferGridReader` and `WriteImageDataToSurfer`: Test reader and writer for Surfer format""" # create some input datasets grid0 = PVGeo.model_build.CreateTensorMesh().Apply() grid1 = PVGeo.model_build.CreateEvenRectilinearGrid().Apply() # make a composite dataset comp = vtk.vtkMultiBlockDataSet() comp.SetBlock(0, grid0) comp.SetBlock(1, grid1) # test the wirter writer = WriteCellCenterData() fname = os.path.join(self.fname) writer.SetFileName(fname) writer.Write(comp)
def tree_to_mbds(tree): mbds = vtk.vtkMultiBlockDataSet() for (i, (k, v)) in enumerate(tree.items()): if isinstance(v, Image): blockimage = vtk.vtkImageData() blockdata = blockimage.GetPointData() for (name, arr) in v.data.items(): blockimage.SetDimensions(tuple(reversed(arr.shape[0:-1]))) vtkarr = vtkarray_from_numpy(arr, vector=True) vtkarr.SetName(name) blockdata.AddArray(vtkarr) mbds.SetBlock(i, blockimage) else: mbds.SetBlock(i, tree_to_mbds(v)) mbds.GetMetaData(i).Set(vtk.vtkCompositeDataSet.NAME(), k) return mbds
def save_MultiBlock(struct_PolyData, outFile): surface_names = struct_PolyData.keys() nb_blk = len(surface_names) mb = vtk.vtkMultiBlockDataSet() mb.SetNumberOfBlocks(nb_blk) for i, surfn in enumerate(surface_names): mb.SetBlock(i, struct_PolyData[surfn]) mb.GetMetaData(i).Set(vtk.vtkCompositeDataSet.NAME(), surfn) writer = vtk.vtkXMLMultiBlockDataWriter() writer.SetFileName(outFile) writer.SetInputData(mb) writer.Write()
def print_manager(): 'I have EXCLUSIVE rights to call the "print" keyword' while True: job = print_queue.get() # for line in job: root = vtk.vtkMultiBlockDataSet() if len(job[1]) > 0: trekker.seed_coordinates(np.repeat(job[1], n_tracts, axis=0)) trk_list = trekker.run() root = dti.tracts_computation(trk_list, root, 0) print('The count is {} for {} tracts'.format( job[0], len(trk_list))) else: print('The count is {} and job 1 {}'.format(job[0], job[1])) print_queue.task_done()
def run(self): if self._pause_: return else: # self.mutex.acquire() try: seed = self.position chunck_size = 10 nchuncks = math.floor(self.n_tracts / chunck_size) # print("The chunck_size: ", chunck_size) # print("The nchuncks: ", nchuncks) root = vtk.vtkMultiBlockDataSet() # n = 1 n_tracts = 0 # while n <= nchuncks: for n in range(nchuncks): # Compute the tracts trk_list = [] # for _ in range(chunck_size): self.tracker.set_seeds(np.repeat(seed, chunck_size, axis=0)) if self.tracker.run(): trk_list.extend(self.tracker.run()) # Transform tracts to array trk_arr = [ np.asarray(trk_n).T if trk_n else None for trk_n in trk_list ] # Compute the directions trk_dir = [simple_direction(trk_n) for trk_n in trk_arr] # Compute the vtk tubes out_list = [ compute_tubes_vtk(trk_arr_n, trk_dir_n) for trk_arr_n, trk_dir_n in zip(trk_arr, trk_dir) ] # Compute the actor root = tracts_root(out_list, root, n_tracts) n_tracts += len(out_list) # wx.CallAfter(Publisher.sendMessage, 'Update tracts', flag=True, root=root, affine_vtk=self.affine_vtk) finally: self.mutex.release()
def _assemble_multiblock_data(self, internalData, boundaryData): multiBlock = vtk.vtkMultiBlockDataSet() multiBlock.SetNumberOfBlocks(2) multiBlock.SetBlock(0, internalData) multiBlock.GetMetaData(0).Set(vtk.vtkCompositeDataSet.NAME(), "internalField") multiBlock.SetBlock(1, boundaryData) multiBlock.GetMetaData(1).Set(vtk.vtkCompositeDataSet.NAME(), "boundary") boundaryNames = vtk.vtkStringArray() boundaryNames.SetName("boundaries") boundaryNames.InsertNextValue("boundary") internalData.GetFieldData().AddArray(boundaryNames) return multiBlock
def combine_tracts_branch(out_list): """Combines a set of tracts in vtkMultiBlockDataSet :param out_list: List of vtkTubeFilters representing the tracts :type out_list: list :return: A collection of tracts as a vtkMultiBlockDataSet :rtype: vtkMultiBlockDataSet """ branch = vtk.vtkMultiBlockDataSet() # create tracts only when at least one was computed # print("Len outlist in root: ", len(out_list)) if not out_list.count(None) == len(out_list): for n, tube in enumerate(out_list): branch.SetBlock(n, tube.GetOutput()) return branch
def createData(non_null_ranks, non_empty_ranks, num_ranks): mb = vtk.vtkMultiBlockDataSet() mb.SetNumberOfBlocks(num_ranks) for i in non_null_ranks: mb.SetBlock(i, createDataSet(i not in non_empty_ranks)) return mb
# Each rank tests the next ranks data. assert result.GetPointData().GetNumberOfArrays() == numprocs and \ result.GetCellData().GetNumberOfArrays() == numprocs assert result.GetPointData().GetArray("PD-%d" % ((rank+1)%numprocs)) is not None and \ result.GetCellData().GetArray("CD-%d" % ((rank+1)%numprocs)) is not None #----------------------------------------------------------------------------- if rank == 0: print("Testing on composite dataset") #----------------------------------------------------------------------------- # Dataset with identical arrays for non-empty datasets on all ranks. mb = vtk.vtkMultiBlockDataSet() mb.SetNumberOfBlocks(numprocs) mb.SetBlock(rank, get_dataset(pa="pa", ca="ca")) cleanArrays.SetInputDataObject(mb) cleanArrays.FillPartialArraysOff() cleanArrays.Update() result = cleanArrays.GetOutputDataObject(0) assert result.GetBlock(rank).GetPointData().GetNumberOfArrays() == 1 and \ result.GetBlock(rank).GetCellData().GetNumberOfArrays() == 1 cleanArrays.FillPartialArraysOn() cleanArrays.Update() result = cleanArrays.GetOutputDataObject(0) assert result.GetBlock(rank).GetPointData().GetNumberOfArrays() == 1 and \ result.GetBlock(rank).GetCellData().GetNumberOfArrays() == 1
ExtractGrid1.SetVOI(14, 29, 0, 32, 0, 24) ExtractGrid1.SetSampleRate(1, 1, 1) ExtractGrid1.SetIncludeBoundary(0) ExtractGrid2 = vtk.vtkExtractGrid() ExtractGrid2.SetInputData(output) ExtractGrid2.SetVOI(29, 56, 0, 32, 0, 24) ExtractGrid2.SetSampleRate(1, 1, 1) ExtractGrid2.SetIncludeBoundary(0) LineSourceWidget0 = vtk.vtkLineSource() LineSourceWidget0.SetPoint1(3.05638, -3.00497, 28.2211) LineSourceWidget0.SetPoint2(3.05638, 3.95916, 28.2211) LineSourceWidget0.SetResolution(20) mbds = vtk.vtkMultiBlockDataSet() mbds.SetNumberOfBlocks(3) i = 0 while i < 3: eval("ExtractGrid" + str(i)).Update() exec("sg" + str(i) + " = vtk.vtkStructuredGrid()") eval("sg" + str(i)).ShallowCopy(eval("ExtractGrid" + str(i)).GetOutput()) mbds.SetBlock(i, eval("sg" + str(i))) i += 1 Stream0 = vtk.vtkStreamTracer() Stream0.SetInputData(mbds) Stream0.SetSourceConnection(LineSourceWidget0.GetOutputPort()) Stream0.SetIntegrationStepUnit(2) Stream0.SetMaximumPropagation(20)
def main(file_, o): """Main program""" sp = StatePoint(file_) sp.read_results() validate_options(sp, o) if o.list: print_available(sp) return if o.vtk: if not o.output[-4:] == ".vtm": o.output += ".vtm" else: if not o.output[-5:] == ".silo": o.output += ".silo" if o.vtk: try: import vtk except: print('The vtk python bindings do not appear to be installed properly.\n' 'On Ubuntu: sudo apt-get install python-vtk\n' 'See: http://www.vtk.org/') return else: try: import silomesh except: print('The silomesh package does not appear to be installed properly.\n' 'See: https://github.com/nhorelik/silomesh/') return if o.vtk: blocks = vtk.vtkMultiBlockDataSet() blocks.SetNumberOfBlocks(5) block_idx = 0 else: silomesh.init_silo(o.output) # Tally loop ################################################################# for tally in sp.tallies: # skip non-mesh tallies or non-user-specified tallies if o.tallies and not tally.id in o.tallies: continue if not 'mesh' in tally.filters: continue print("Processing Tally {}...".format(tally.id)) # extract filter options and mesh parameters for this tally filtercombos = get_filter_combos(tally) meshparms = get_mesh_parms(sp, tally) nx,ny,nz = meshparms[:3] ll = meshparms[3:6] ur = meshparms[6:9] if o.vtk: ww = [(u-l)/n for u,l,n in zip(ur,ll,(nx,ny,nz))] grid = grid = vtk.vtkImageData() grid.SetDimensions(nx+1,ny+1,nz+1) grid.SetOrigin(*ll) grid.SetSpacing(*ww) else: silomesh.init_mesh('Tally_{}'.format(tally.id), *meshparms) # Score loop ############################################################### for sid,score in enumerate(tally.scores): # skip non-user-specified scrores for this tally if o.scores and tally.id in o.scores and not sid in o.scores[tally.id]: continue # Filter loop ############################################################ for filterspec in filtercombos: # skip non-user-specified filter bins skip = False if o.filters and tally.id in o.filters: for filter_,bin in filterspec[1:]: if filter_ in o.filters[tally.id] and \ not bin in o.filters[tally.id][filter_]: skip = True break if skip: continue # find and sanitize the variable name for this score varname = get_sanitized_filterspec_name(tally, score, filterspec) if o.vtk: vtkdata = vtk.vtkDoubleArray() vtkdata.SetName(varname) dataforvtk = {} else: silomesh.init_var(varname) lbl = "\t Score {}.{} {}:\t\t{}".format(tally.id, sid+1, score, varname) # Mesh fill loop ####################################################### for x in range(1,nx+1): sys.stdout.write(lbl+" {0}%\r".format(int(x/nx*100))) sys.stdout.flush() for y in range(1,ny+1): for z in range(1,nz+1): filterspec[0][1] = (x,y,z) val = sp.get_value(tally.id-1, filterspec, sid)[o.valerr] if o.vtk: # vtk cells go z, y, x, so we store it now and enter it later i = (z-1)*nx*ny + (y-1)*nx + x-1 dataforvtk[i] = float(val) else: silomesh.set_value(float(val), x, y, z) # end mesh fill loop print() if o.vtk: for i in range(nx*ny*nz): vtkdata.InsertNextValue(dataforvtk[i]) grid.GetCellData().AddArray(vtkdata) del vtkdata else: silomesh.finalize_var() # end filter loop # end score loop if o.vtk: blocks.SetBlock(block_idx, grid) block_idx += 1 else: silomesh.finalize_mesh() # end tally loop if o.vtk: writer = vtk.vtkXMLMultiBlockDataWriter() writer.SetFileName(o.output) writer.SetInput(blocks) writer.Write() else: silomesh.finalize_silo()
sphere1.Update() sphere2 = vtk.vtkSphereSource() sphere2.SetRadius(attrs[0]) sphere2.SetCenter(0, -attrs[1] / 2, 0) sphere2.SetThetaResolution(15) sphere2.SetPhiResolution(15) sphere2.Update() cylinder = vtk.vtkCylinderSource() cylinder.SetRadius(attrs[0]) cylinder.SetHeight(attrs[1]) cylinder.SetResolution(15) cylinder.Update() data = vtk.vtkMultiBlockDataSet() data.SetNumberOfBlocks(3) data.SetBlock(0, sphere1.GetOutput()) data.SetBlock(1, sphere2.GetOutput()) data.SetBlock(2, cylinder.GetOutput()) source = vtk.vtkMultiBlockDataGroupFilter() add_compatiblity_methods(source) source.AddInputData(data) readers[shape_name] = source mapper = vtk.vtkCompositePolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) mappers[shape_name] = (x for x in [mapper]) fixed_mappers = dict() for shape_name in io.shapes():
extractL.AddCellRange(0,sampleL.GetOutput().GetNumberOfCells()) extractL.Update() # # Extract voxel cells extractR = vtk.vtkExtractCells() extractR.SetInputConnection(sampleR.GetOutputPort()) extractR.AddCellRange(0,sampleR.GetOutput().GetNumberOfCells()) extractR.Update() # Create a composite dataset. Throw in an extra polydata which should be skipped. sphere = vtk.vtkSphereSource() sphere.SetCenter(1,0,0) sphere.Update() composite = vtk.vtkMultiBlockDataSet() composite.SetBlock(0,extractL.GetOutput()) composite.SetBlock(1,extractR.GetOutput()) composite.SetBlock(2,sphere.GetOutput()) # Scalar tree is used to clone for each of the composite pieces stree = vtk.vtkSpanSpace() stree.SetDataSet(extractL.GetOutput()) stree.ComputeResolutionOn() stree.SetScalarRange(0.25,0.75) stree.SetComputeScalarRange(computeScalarRange) # Now contour the cells, using scalar tree contour = vtk.vtkContour3DLinearGrid() contour.SetInputData(composite) contour.SetValue(0, 0.5)