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)
