def getCutActor(vtk_r,
origin=[0, 0, 0],
normal=[0, 0, 1],
scalarField=None,
scalarRange=None):
plane = vtk.vtkPlane()
plane.SetOrigin(*origin)
plane.SetNormal(*normal)
cutter = vtk.vtkCutter()
cutter.GenerateTrianglesOff()
cutter.SetCutFunction(plane)
cutter.SetInputConnection(vtk_r.GetOutputPort())
geoFilter = vtk.vtkCompositeDataGeometryFilter()
geoFilter.SetInputConnection(cutter.GetOutputPort())
cutterMapper = vtk.vtkPolyDataMapper()
cutterMapper.SetInputConnection(geoFilter.GetOutputPort())
colorMapper(cutterMapper, scalarField, scalarRange)
cutActor = vtk.vtkActor()
cutActor.GetProperty().SetEdgeVisibility(1)
cutActor.SetMapper(cutterMapper)
return cutActor
def _buildVtkBlocksActor(self, binfo):
if binfo.multiblock_index is not None:
eb = vtk.vtkExtractBlock()
eb.SetInputConnection(self._reader.getVtkOutputPort())
eb.AddIndex(binfo.multiblock_index)
eb.Update()
geometry = vtk.vtkCompositeDataGeometryFilter()
geometry.SetInputConnection(0, eb.GetOutputPort(0))
geometry.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(geometry.GetOutputPort())
else:
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(0, self._reader.getVtkOutputPort())
mapper.ScalarVisibilityOff()
mapper.InterpolateScalarsBeforeMappingOn()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.VisibilityOn()
return actor
def __init__(self, eb, camera):
do = eb.GetOutput()
self._bounds = self._computeBounds(do)
self._info = {
'cells': do.GetNumberOfCells(),
'points': do.GetNumberOfPoints(),
}
self._geometry = vtk.vtkCompositeDataGeometryFilter()
self._geometry.SetInputConnection(0, eb.GetOutputPort(0))
self._geometry.Update()
self._mapper = vtk.vtkPolyDataMapper()
self._mapper.SetInputConnection(self._geometry.GetOutputPort())
self._mapper.SetScalarModeToUsePointFieldData()
self._mapper.InterpolateScalarsBeforeMappingOn()
self._actor = vtk.vtkActor()
self._actor.SetMapper(self._mapper)
self._actor.SetScale(0.99999)
self._actor.VisibilityOn()
self._property = self._actor.GetProperty()
self._property.SetRepresentationToSurface()
self._color = [1, 1, 1]
bnds = self._actor.GetBounds()
self._cob = common.centerOfBounds(bnds)
self._setUpSilhouette(camera)
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 runVectorExample(filename):
vtkdata = prepareVectorExample(filename)
comp_filter = vtk.vtkCompositeDataGeometryFilter()
comp_filter.SetInputData(vtkdata)
comp_filter.Update()
renderPolyData(init(), comp_filter.GetOutput())
# renderMultiblockData(init(), vtkdata)
run()
def extract_geometry(self):
"""Combines the geomertry of all blocks into a single ``PolyData``
object. Place this filter at the end of a pipeline before a polydata
consumer such as a polydata mapper to extract geometry from all blocks
and append them to one polydata object.
"""
gf = vtk.vtkCompositeDataGeometryFilter()
gf.SetInputData(self)
gf.Update()
return wrap(gf.GetOutputDataObject(0))
def main():
colors = vtk.vtkNamedColors()
# Input file and variable
filename, nodal_var = get_program_parameters()
# Read Exodus Data
reader = vtk.vtkExodusIIReader()
reader.SetFileName(filename)
reader.UpdateInformation()
reader.SetTimeStep(10)
reader.SetAllArrayStatus(vtk.vtkExodusIIReader.NODAL,
1) # enables all NODAL variables
reader.Update()
# print(reader) # uncomment this to show the file information
# Create Geometry
geometry = vtk.vtkCompositeDataGeometryFilter()
geometry.SetInputConnection(0, reader.GetOutputPort(0))
geometry.Update()
# Mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(geometry.GetOutputPort())
mapper.SelectColorArray(nodal_var)
mapper.SetScalarModeToUsePointFieldData()
mapper.InterpolateScalarsBeforeMappingOn()
# Actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Renderer
renderer = vtk.vtkRenderer()
renderer.AddViewProp(actor)
renderer.SetBackground(colors.GetColor3d('DimGray'))
renderer.GetActiveCamera().SetPosition(9.0, 9.0, 7.0)
renderer.GetActiveCamera().SetFocalPoint(0, 0, 0)
renderer.GetActiveCamera().SetViewUp(0.2, -0.7, 0.7)
renderer.GetActiveCamera().SetDistance(14.5)
# Window and Interactor
window = vtk.vtkRenderWindow()
window.AddRenderer(renderer)
window.SetSize(600, 600)
window.SetWindowName('ReadExodusData')
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(window)
interactor.Initialize()
# Show the result
window.Render()
interactor.Start()
def getStuctureActor(vtk_r, blockIndex, scalarField="p_rgh", scalarRange=None):
"""Return an actor with the ship structure
"""
#--------------------------------- Structure
structureOnly = vtk.vtkExtractBlock()
structureOnly.SetInputConnection(vtk_r.GetOutputPort())
structureOnly.AddIndex(blockIndex)
structureDataFilter = vtk.vtkCompositeDataGeometryFilter()
structureDataFilter.SetInputConnection(structureOnly.GetOutputPort())
structureMapper = vtk.vtkDataSetMapper()
structureMapper.SetInputConnection(structureDataFilter.GetOutputPort())
colorMapper(structureMapper, scalarField, scalarRange)
structureActor = vtk.vtkActor()
structureActor.GetProperty().SetEdgeVisibility(0)
structureActor.SetMapper(structureMapper)
return structureActor
def __init__(self, eb):
do = eb.GetOutput()
self._info = {'points': do.GetNumberOfPoints()}
self._geometry = vtk.vtkCompositeDataGeometryFilter()
self._geometry.SetInputConnection(0, eb.GetOutputPort(0))
self._geometry.Update()
self._mapper = vtk.vtkPolyDataMapper()
self._mapper.SetInputConnection(self._geometry.GetOutputPort())
self._mapper.SetScalarModeToUsePointFieldData()
self._mapper.InterpolateScalarsBeforeMappingOn()
self._actor = vtk.vtkActor()
self._actor.SetMapper(self._mapper)
self._actor.VisibilityOff()
self._property = self._actor.GetProperty()
def getSymPlaneVtkActor(vtk_r,
blockIndex,
scalarField="alpha.water",
scalarRange=None):
"""return symmetry plane colored by field
"""
#SymmetryPlane
symPlane = vtk.vtkExtractBlock()
symPlane.SetInputConnection(vtk_r.GetOutputPort())
symPlane.AddIndex(blockIndex)
symPlaneDataFilter = vtk.vtkCompositeDataGeometryFilter()
symPlaneDataFilter.SetInputConnection(symPlane.GetOutputPort())
symPlaneMapper = vtk.vtkDataSetMapper()
symPlaneMapper.SetInputConnection(symPlaneDataFilter.GetOutputPort())
colorMapper(symPlaneMapper, scalarField, scalarRange)
symPlaneActor = vtk.vtkActor()
symPlaneActor.GetProperty().SetEdgeVisibility(1)
symPlaneActor.SetMapper(symPlaneMapper)
return symPlaneActor
def load_vtk_structured(self, file_name):
self.fname = file_name
#reader = vtk.vtkUnstructuredGridReader()
reader = vtk.vtkXMLMultiBlockDataReader()
reader.SetFileName(file_name)
reader.Update()
Merge = vtk.vtkMultiBlockMergeFilter()
Merge.AddInput(reader.GetOutput())
Merge.Update()
Mb = vtk.vtkStructuredGridOutlineFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
Mb.SetInput(Merge.GetOutput())
else:
Mb.SetInputData(Merge.GetOutput())
Geom01 = vtk.vtkCompositeDataGeometryFilter()
Geom01.SetInputConnection(Merge.GetOutputPort())
self.output = Geom01.GetOutput()
self.vtk_pts = self.output.GetPointData()
self.vtk_n_pts = self.output.GetNumberOfPoints()
self.vtk_n_cells = self.output.GetNumberOfCells()
self.vtk_n_props = self.vtk_pts.GetNumberOfArrays()
self.reader = reader
#get_range = self.output.GetScalarRange()
#print get_range
print " [Vtk_unstructured_reader]:"
print " Cells: %d" % (self.vtk_n_cells)
print " Point: %d" % (self.vtk_n_pts)
print " Props: ",
for i in range(self.vtk_n_props):
print "\'%s\'" % (self.vtk_pts.GetArrayName(i)),
print
print "\n+[Vtk_multiblock_reader]: \'%s\'" % file_name
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
# Input file and variable filename = 'mug.e' nodal_var = 'convected' # Read Exodus Data reader = vtk.vtkExodusIIReader() reader.SetFileName(filename) reader.UpdateInformation() reader.SetTimeStep(10) reader.SetAllArrayStatus(vtk.vtkExodusIIReader.NODAL, 1) # enables all NODAL variables reader.Update() #print reader # uncomment this to show the file information # Create Geometry geometry = vtk.vtkCompositeDataGeometryFilter() geometry.SetInputConnection(0, reader.GetOutputPort(0)) geometry.Update() # Mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(geometry.GetOutputPort()) mapper.SelectColorArray(nodal_var) mapper.SetScalarModeToUsePointFieldData() # Actor actor = vtk.vtkActor() actor.SetMapper(mapper) # Renderer renderer = vtk.vtkRenderer()
def export_plotter_vtkjs(plotter, filename, compress_arrays=False):
"""Export a plotter's rendering window to the VTKjs format."""
sceneName = os.path.split(filename)[1]
doCompressArrays = compress_arrays
# Generate timestamp and use it to make subdirectory within the top level output dir
timeStamp = time.strftime("%a-%d-%b-%Y-%H-%M-%S")
root_output_directory = os.path.split(filename)[0]
output_dir = os.path.join(root_output_directory, timeStamp)
mkdir_p(output_dir)
renderers = plotter.ren_win.GetRenderers()
scDirs = []
sceneComponents = []
textureToSave = {}
for rIdx in range(renderers.GetNumberOfItems()):
renderer = renderers.GetItemAsObject(rIdx)
renProps = renderer.GetViewProps()
for rpIdx in range(renProps.GetNumberOfItems()):
renProp = renProps.GetItemAsObject(rpIdx)
if not renProp.GetVisibility():
continue
if hasattr(renProp,
'GetMapper') and renProp.GetMapper() is not None:
mapper = renProp.GetMapper()
dataObject = mapper.GetInputDataObject(0, 0)
dataset = None
if dataObject is None:
continue
if dataObject.IsA('vtkCompositeDataSet'):
if dataObject.GetNumberOfBlocks() == 1:
dataset = dataObject.GetBlock(0)
else:
gf = vtk.vtkCompositeDataGeometryFilter()
gf.SetInputData(dataObject)
gf.Update()
dataset = gf.GetOutput()
else:
dataset = mapper.GetInput()
if dataset and not isinstance(
dataset, (vtk.vtkPolyData, vtk.vtkImageData)):
# All data must be PolyData surfaces
gf = vtk.vtkGeometryFilter()
gf.SetInputData(dataset)
gf.Update()
dataset = gf.GetOutputDataObject(0)
if dataset: # and dataset.GetPoints(): # NOTE: vtkImageData does not have points
componentName = 'data_%d_%d' % (
rIdx, rpIdx) # getComponentName(renProp)
scalarVisibility = mapper.GetScalarVisibility()
#arrayAccessMode = mapper.GetArrayAccessMode()
#colorArrayName = mapper.GetArrayName() #TODO: if arrayAccessMode == 1 else mapper.GetArrayId()
colorMode = mapper.GetColorMode()
scalarMode = mapper.GetScalarMode()
lookupTable = mapper.GetLookupTable()
dsAttrs = None
arrayLocation = ''
if scalarVisibility:
if scalarMode == 3 or scalarMode == 1: # VTK_SCALAR_MODE_USE_POINT_FIELD_DATA or VTK_SCALAR_MODE_USE_POINT_DATA
dsAttrs = dataset.GetPointData()
arrayLocation = 'pointData'
# VTK_SCALAR_MODE_USE_CELL_FIELD_DATA or VTK_SCALAR_MODE_USE_CELL_DATA
elif scalarMode == 4 or scalarMode == 2:
dsAttrs = dataset.GetCellData()
arrayLocation = 'cellData'
colorArray = None
dataArray = None
if dsAttrs:
dataArray = dsAttrs.GetArray(
0) # Force getting the active array
if dataArray:
# component = -1 => let specific instance get scalar from vector before mapping
colorArray = lookupTable.MapScalars(
dataArray, colorMode, -1)
colorArrayName = '__CustomRGBColorArray__'
colorArray.SetName(colorArrayName)
colorMode = 0
else:
colorArrayName = ''
color_array_info = {
'colorArray': colorArray,
'location': arrayLocation
}
scDirs.append(
write_data_set('',
dataset,
output_dir,
color_array_info,
new_name=componentName,
compress=doCompressArrays))
# Handle texture if any
textureName = None
if renProp.GetTexture() and renProp.GetTexture().GetInput(
):
textureData = renProp.GetTexture().GetInput()
textureName = 'texture_%d' % get_object_id(textureData)
textureToSave[textureName] = textureData
representation = renProp.GetProperty().GetRepresentation(
) if hasattr(renProp, 'GetProperty') else 2
colorToUse = renProp.GetProperty().GetDiffuseColor(
) if hasattr(renProp, 'GetProperty') else [1, 1, 1]
if representation == 1:
colorToUse = renProp.GetProperty().GetColor(
) if hasattr(renProp, 'GetProperty') else [1, 1, 1]
pointSize = renProp.GetProperty().GetPointSize(
) if hasattr(renProp, 'GetProperty') else 1.0
opacity = renProp.GetProperty().GetOpacity() if hasattr(
renProp, 'GetProperty') else 1.0
edgeVisibility = renProp.GetProperty().GetEdgeVisibility(
) if hasattr(renProp, 'GetProperty') else False
p3dPosition = renProp.GetPosition() if renProp.IsA(
'vtkProp3D') else [0, 0, 0]
p3dScale = renProp.GetScale() if renProp.IsA(
'vtkProp3D') else [1, 1, 1]
p3dOrigin = renProp.GetOrigin() if renProp.IsA(
'vtkProp3D') else [0, 0, 0]
p3dRotateWXYZ = renProp.GetOrientationWXYZ(
) if renProp.IsA('vtkProp3D') else [0, 0, 0, 0]
sceneComponents.append({
"name": componentName,
"type": "httpDataSetReader",
"httpDataSetReader": {
"url": componentName
},
"actor": {
"origin": p3dOrigin,
"scale": p3dScale,
"position": p3dPosition,
},
"actorRotation": p3dRotateWXYZ,
"mapper": {
"colorByArrayName": colorArrayName,
"colorMode": colorMode,
"scalarMode": scalarMode
},
"property": {
"representation": representation,
"edgeVisibility": edgeVisibility,
"diffuseColor": colorToUse,
"pointSize": pointSize,
"opacity": opacity
},
"lookupTable": {
"tableRange":
lookupTable.GetRange(),
"hueRange":
lookupTable.GetHueRange() if hasattr(
lookupTable, 'GetHueRange') else [0.5, 0]
}
})
if textureName:
sceneComponents[-1]['texture'] = textureName
# Save texture data if any
for key, val in textureToSave.items():
write_data_set('',
val,
output_dir,
None,
new_name=key,
compress=doCompressArrays)
cameraClippingRange = plotter.camera.GetClippingRange()
sceneDescription = {
"fetchGzip": doCompressArrays,
"background": plotter.background_color,
"camera": {
"focalPoint": plotter.camera.GetFocalPoint(),
"position": plotter.camera.GetPosition(),
"viewUp": plotter.camera.GetViewUp(),
"clippingRange": [elt for elt in cameraClippingRange],
},
"centerOfRotation": plotter.camera.GetFocalPoint(),
"scene": sceneComponents
}
indexFilePath = os.path.join(output_dir, 'index.json')
with open(indexFilePath, 'w') as outfile:
json.dump(sceneDescription, outfile, indent=4)
# -----------------------------------------------------------------------------
# Now zip up the results and get rid of the temp directory
sceneFileName = os.path.join(root_output_directory,
'%s%s' % (sceneName, FILENAME_EXTENSION))
try:
import zlib
compression = zipfile.ZIP_DEFLATED
except:
compression = zipfile.ZIP_STORED
zf = zipfile.ZipFile(sceneFileName, mode='w')
try:
for dirName, subdirList, fileList in os.walk(output_dir):
for fname in fileList:
fullPath = os.path.join(dirName, fname)
relPath = '%s/%s' % (sceneName,
os.path.relpath(fullPath, output_dir))
zf.write(fullPath, arcname=relPath, compress_type=compression)
finally:
zf.close()
shutil.rmtree(output_dir)
print('Finished exporting dataset to: ', sceneFileName)
def render_window_serializer(render_window):
"""
Function to convert a vtk render window in a list of 2-tuple where first value
correspond to a relative file path in the `vtkjs` directory structure and values
of the binary content of the corresponding file.
"""
render_window.OffScreenRenderingOn() # to not pop a vtk windows
render_window.Render()
renderers = render_window.GetRenderers()
objIds = []
scDirs = []
sceneComponents = []
textureToSave = {}
for renderer in renderers:
for renProp in renderer.GetViewProps():
if not renProp.GetVisibility() or not isinstance(
renProp, vtk.vtkActor):
continue
if hasattr(renProp, 'GetMapper'):
mapper = renProp.GetMapper()
if mapper is None:
continue
dataObject = mapper.GetInputDataObject(0, 0)
dataset = None
if dataObject.IsA('vtkCompositeDataSet'):
if dataObject.GetNumberOfBlocks() == 1:
dataset = dataObject.GetBlock(0)
else:
gf = vtk.vtkCompositeDataGeometryFilter()
gf.SetInputData(dataObject)
gf.Update()
dataset = gf.GetOutput()
elif dataObject.IsA('vtkUnstructuredGrid'):
gf = vtk.vtkGeometryFilter()
gf.SetInputData(dataObject)
gf.Update()
dataset = gf.GetOutput()
else:
dataset = mapper.GetInput()
if dataset and not isinstance(dataset, (vtk.vtkPolyData)):
# All data must be PolyData surfaces!
gf = vtk.vtkGeometryFilter()
gf.SetInputData(dataset)
gf.Update()
dataset = gf.GetOutputDataObject(0)
if dataset and dataset.GetPoints():
componentName = str(id(renProp))
scalar_visibility = mapper.GetScalarVisibility()
array_access_mode = mapper.GetArrayAccessMode()
array_name = mapper.GetArrayName(
) # if arrayAccessMode == 1 else mapper.GetArrayId()
array_id = mapper.GetArrayId()
color_mode = mapper.GetColorMode()
scalar_mode = mapper.GetScalarMode()
arrayLocation = ''
colorArray = None
dataArray = None
colorArrayName = ''
lookupTable = mapper.GetLookupTable()
if scalar_visibility:
dataArray, arrayLocation = get_dataset_scalars(
dataset, scalar_mode, array_access_mode, array_id,
array_name)
# component = -1 => let specific instance get scalar from vector before mapping
if dataArray:
if dataArray.GetLookupTable():
lookupTable = dataArray.GetLookupTable()
colorArray = dataArray.GetLookupTable(
).MapScalars(dataArray, color_mode, -1)
else:
colorArray = lookupTable.MapScalars(
dataArray, color_mode, -1)
colorArrayName = '__CustomRGBColorArray__'
colorArray.SetName(colorArrayName)
color_mode = 0
colorArrayInfo = {
'colorArray': colorArray,
'location': arrayLocation
}
_write_data_set(scDirs,
dataset,
colorArrayInfo,
newDSName=componentName)
# Handle texture if any
textureName = None
if renProp.GetTexture() and renProp.GetTexture().GetInput(
):
textureData = renProp.GetTexture().GetInput()
textureName = 'texture_%d' % _get_object_id(
textureData, objIds)
textureToSave[textureName] = textureData
sceneComponents.append({
"name":
componentName,
"type":
"httpDataSetReader",
"httpDataSetReader": {
"url": componentName
},
"actor": {
# vtkProp
"visibility":
renProp.GetVisibility()
if renProp.IsA('vtkProp') else 0,
"pickable":
renProp.GetPickable()
if renProp.IsA('vtkProp') else 0,
"dragable":
renProp.GetDragable()
if renProp.IsA('vtkProp') else 0,
"useBounds":
renProp.GetUseBounds()
if renProp.IsA('vtkProp') else 0,
# vtkProp3D
"origin":
renProp.GetOrigin()
if renProp.IsA('vtkProp3D') else [0, 0, 0],
"scale":
renProp.GetScale()
if renProp.IsA('vtkProp3D') else [1, 1, 1],
"position":
renProp.GetPosition()
if renProp.IsA('vtkProp3D') else [0, 0, 0],
# vtkActor
'forceOpaque':
renProp.GetForceOpaque()
if renProp.IsA('vtkActor') else 0,
'forceTranslucent':
renProp.GetForceTranslucent()
if renProp.IsA('vtkActor') else 0,
},
"actorRotation":
renProp.GetOrientationWXYZ()
if renProp.IsA('vtkProp3D') else [0, 0, 0, 0],
"mapper": {
"colorByArrayName": colorArrayName,
"colorMode": color_mode,
"scalarMode": scalar_mode
},
"property":
extract_renprop_properties(renProp),
"lookupTable": {
"range":
lookupTable.GetRange(),
"hueRange":
lookupTable.GetHueRange() if hasattr(
lookupTable, 'GetHueRange') else [0.5, 0]
}
})
if textureName:
sceneComponents[-1]['texture'] = textureName
# Save texture data if any
for key, val in textureToSave.items():
_write_data_set(scDirs, val, None, newDSName=key)
activeCamera = renderer.GetActiveCamera()
background = renderer.GetBackground()
sceneDescription = {
"fetchGzip": False,
"background": background,
"camera": {
"focalPoint": activeCamera.GetFocalPoint(),
"position": activeCamera.GetPosition(),
"viewUp": activeCamera.GetViewUp(),
"clippingRange": activeCamera.GetClippingRange()
},
"centerOfRotation": renderer.GetCenter(),
"scene": sceneComponents,
}
scDirs.append(['index.json', json.dumps(sceneDescription, indent=4)])
# create binary stream of the vtkjs directory structure
compression = zipfile.ZIP_DEFLATED
with BytesIO() as in_memory:
zf = zipfile.ZipFile(in_memory, mode="w")
try:
for dirPath, data in scDirs:
zf.writestr(dirPath, data, compress_type=compression)
finally:
zf.close()
in_memory.seek(0)
return in_memory.read()
def construct_palettes(render_window):
"""
"""
legend = {}
render_window.OffScreenRenderingOn() # to not pop a vtk windows
render_window.Render()
renderers = render_window.GetRenderers()
for renderer in renderers:
for renProp in renderer.GetViewProps():
if not renProp.GetVisibility() or not isinstance(
renProp, vtk.vtkActor):
continue
if hasattr(renProp, 'GetMapper'):
mapper = renProp.GetMapper()
if mapper is None:
continue
dataObject = mapper.GetInputDataObject(0, 0)
dataset = None
if dataObject.IsA('vtkCompositeDataSet'):
if dataObject.GetNumberOfBlocks() == 1:
dataset = dataObject.GetBlock(0)
else:
gf = vtk.vtkCompositeDataGeometryFilter()
gf.SetInputData(dataObject)
gf.Update()
dataset = gf.GetOutput()
elif dataObject.IsA('vtkUnstructuredGrid'):
gf = vtk.vtkGeometryFilter()
gf.SetInputData(dataObject)
gf.Update()
dataset = gf.GetOutput()
else:
dataset = mapper.GetInput()
if dataset and not isinstance(dataset, (vtk.vtkPolyData)):
# All data must be PolyData surfaces!
gf = vtk.vtkGeometryFilter()
gf.SetInputData(dataset)
gf.Update()
dataset = gf.GetOutputDataObject(0)
if dataset and dataset.GetPoints():
scalar_visibility = mapper.GetScalarVisibility()
array_access_mode = mapper.GetArrayAccessMode()
array_name = mapper.GetArrayName(
) # if arrayAccessMode == 1 else mapper.GetArrayId()
array_id = mapper.GetArrayId()
scalar_mode = mapper.GetScalarMode()
dataArray = None
lookupTable = mapper.GetLookupTable()
if scalar_visibility:
dataArray, _ = get_dataset_scalars(
dataset, scalar_mode, array_access_mode, array_id,
array_name)
# component = -1 => let specific instance get scalar from vector before mapping
if dataArray:
if dataArray.GetLookupTable():
lookupTable = dataArray.GetLookupTable()
if array_name and legend is not None:
legend.update({
array_name:
vtk_lut_to_palette(lookupTable)
})
return legend
#print reader # uncomment this to show the file information blk0 = reader.GetOutput().GetBlock(0).GetBlock(0) data = vtk.vtkDoubleArray() data.SetName(varname) data.SetNumberOfTuples(blk0.GetCellData().GetArray(0).GetNumberOfTuples()) data.FillComponent(0, vtk.vtkMath.Nan()) blk0.GetCellData().AddArray(data) lookup = vtk.vtkLookupTable() lookup.SetNanColor(0.5, 0.5, 0.5, 1) lookup.SetTableRange(0, 2) # Create Geometry geometry = vtk.vtkCompositeDataGeometryFilter() geometry.SetInputConnection(0, reader.GetOutputPort(0)) geometry.Update() # Mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(geometry.GetOutputPort()) mapper.SelectColorArray(varname) mapper.SetLookupTable(lookup) mapper.UseLookupTableScalarRangeOn() mapper.SetScalarModeToUseCellFieldData() mapper.InterpolateScalarsBeforeMappingOn() # Actor actor = vtk.vtkActor() actor.SetMapper(mapper)
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 main():
colors = vtk.vtkNamedColors()
# Create and populate the AMR dataset
# The dataset should look like
# Level 0
# uniform grid, dimensions 11, 11, 11, AMR box (0, 0, 0) - (9, 9, 9)
# Level 1 - refinement ratio : 2
# uniform grid, dimensions 11, 11, 11, AMR box (0, 0, 0) - (9, 9, 9)
# uniform grid, dimensions 11, 11, 11, AMR box (10, 10, 10) - (19, 19, 19)
# Use MakeScalars() above to fill the scalar arrays
amr = vtk.vtkOverlappingAMR()
blocksPerLevel = [1, 2]
amr.Initialize(2, blocksPerLevel)
origin = [0.0, 0.0, 0.0]
spacing = [1.0, 1.0, 1.0]
dims = [11, 11, 11]
ug1 = vtk.vtkUniformGrid()
# Geometry
ug1.SetOrigin(origin)
ug1.SetSpacing(spacing)
ug1.SetDimensions(dims)
# Data
scalars = vtk.vtkFloatArray()
ug1.GetPointData().SetScalars(scalars)
MakeScalars(dims, origin, spacing, scalars)
lo = [0, 0, 0]
hi = [9, 9, 9]
box1 = vtk.vtkAMRBox()
amr.SetAMRBox(0, 0, box1)
amr.SetDataSet(0, 0, ug1)
spacing2 = [0.5, 0.5, 0.5]
ug2 = vtk.vtkUniformGrid()
# Geometry
ug2.SetOrigin(origin)
ug2.SetSpacing(spacing2)
ug2.SetDimensions(dims)
# Data
scalars = vtk.vtkFloatArray()
ug2.GetPointData().SetScalars(scalars)
MakeScalars(dims, origin, spacing2, scalars)
lo2 = [0, 0, 0]
hi2 = [9, 9, 9]
box2 = vtk.vtkAMRBox()
amr.SetAMRBox(1, 0, box2)
amr.SetDataSet(1, 0, ug2)
origin3 = [5, 5, 5]
ug3 = vtk.vtkUniformGrid()
# Geometry
ug3.SetOrigin(origin3)
ug3.SetSpacing(spacing2)
ug3.SetDimensions(dims)
# Data
scalars = vtk.vtkFloatArray()
ug3.GetPointData().SetScalars(scalars)
MakeScalars(dims, origin3, spacing2, scalars)
lo3 = [10, 10, 10]
hi3 = [19, 19, 19]
box3 = vtk.vtkAMRBox()
amr.SetAMRBox(1, 1, box3)
amr.SetDataSet(1, 1, ug3)
amr.SetRefinementRatio(0, 2)
# Render the amr data here.
of = vtk.vtkOutlineFilter()
of.SetInputData(amr)
geomFilter = vtk.vtkCompositeDataGeometryFilter()
geomFilter.SetInputConnection(of.GetOutputPort())
# Create an iso-surface - at 10.
cf = vtk.vtkContourFilter()
cf.SetInputData(amr)
cf.SetNumberOfContours(1)
cf.SetValue(0, 10.0)
geomFilter2 = vtk.vtkCompositeDataGeometryFilter()
geomFilter2.SetInputConnection(cf.GetOutputPort())
# Create the render window, renderer, and interactor.
aren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(aren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Associate the geometry with a mapper and the mapper to an actor.
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(geomFilter.GetOutputPort())
actor1 = vtk.vtkActor()
actor1.GetProperty().SetColor(colors.GetColor3d("Yellow"))
actor1.SetMapper(mapper)
# Associate the geometry with a mapper and the mapper to an actor.
mapper2 = vtk.vtkPolyDataMapper()
mapper2.SetInputConnection(geomFilter2.GetOutputPort())
actor2 = vtk.vtkActor()
actor2.SetMapper(mapper2)
# Add the actor to the renderer and start handling events.
aren.AddActor(actor1)
aren.AddActor(actor2)
aren.SetBackground(colors.GetColor3d("CornflowerBlue"))
renWin.Render()
iren.Start()
def go(self):
print "Mapping",self.cfdData,"to",self.feaMesh
# identify inner wall points
"""
reader = vtk.vtkSTLReader()
reader.SetFileName(self.feaMesh)
reader.ScalarTagsOn()
reader.Update()
feadata = reader.GetOutput()
"""
reader = vtk.vtkExodusIIReader()
reader.SetFileName(self.feaMesh)
reader.UpdateInformation()
reader.SetAllArrayStatus(vtk.vtkExodusIIReader.NODAL, 1) # enables all NODAL variables
reader.GenerateGlobalNodeIdArrayOn()
reader.GenerateGlobalElementIdArrayOn()
reader.ExodusModelMetadataOn()
reader.Update()
feadata = vtk.vtkCompositeDataGeometryFilter()
feadata.SetInputConnection(0, reader.GetOutputPort(0))
feadata.Update()
transform = vtk.vtkTransform()
transform.Scale(1000, 1000, 1000)
test = vtk.vtkTransformPolyDataFilter()
test.SetTransform(transform)
test.SetInput(feadata.GetOutput())
test.Update()
feadata = test.GetOutput()
normals = vtk.vtkPolyDataNormals()
normals.SetInput(feadata)
normals.ComputeCellNormalsOn()
normals.ComputePointNormalsOn()
normals.ConsistencyOn()
normals.AutoOrientNormalsOn()
normals.SplittingOn()
normals.Update()
feabody = normals.GetOutput()
norms = feabody.GetPointData().GetArray('Normals')
norms_n = numpy_support.vtk_to_numpy(norms)
#print (norms_n)
feapnts = feabody.GetPoints().GetData()
feapnts_n = numpy_support.vtk_to_numpy(feapnts)
#print (feapnts_n)
reader = vtk.vtkPolyDataReader()
reader.SetFileName(self.cfdData)
reader.ReadAllVectorsOn()
reader.ReadAllScalarsOn()
reader.Update()
cfddata = reader.GetOutput()
transform = vtk.vtkTransform()
transform.Scale(1000, 1000, 1000)
test = vtk.vtkTransformPolyDataFilter()
test.SetTransform(transform)
test.SetInputConnection(reader.GetOutputPort())
test.Update()
cfddata = test.GetOutput()
"""
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName("volume.vtk")
reader.ReadAllVectorsOn()
reader.ReadAllScalarsOn()
reader.Update()
cfdvol = reader.GetOutput()
"""
cfdpnts = cfddata.GetPoints().GetData()
cfdpnts_n = numpy_support.vtk_to_numpy(cfdpnts)
pointLocator = vtk.vtkPointLocator()
pointLocator.SetDataSet(feabody)
pointLocator.BuildLocator()
innerIds = []
for cfdpnt in cfdpnts_n:
id = pointLocator.FindClosestPoint(cfdpnt)
innerIds.append(id)
innerIds = np.unique(innerIds)
# foreach fea innerpoint
# find the intersection point to cfddata
# probe field cfddata using intersection point
# append the field data to feabody
caster = pycaster.rayCaster(cfddata)
interPoints={}
interPointsSave = vtk.vtkPoints()
ptcount=0
for id in innerIds:
feainpnt = feapnts_n[id]
feainnorm = norms_n[id]
sourcePnt = feainpnt
targetPnt = feainpnt+(feainnorm*100)
pointsIntersection = caster.castRay(sourcePnt, targetPnt)
if len(pointsIntersection)!=0:
interPointsSave.InsertPoint(ptcount, pointsIntersection[0]+(feainnorm*0))
interPoints[id]=ptcount
ptcount+=1
else:
targetPnt = feainpnt-(feainnorm*100)
pointsIntersection = caster.castRay(sourcePnt, targetPnt)
if len(pointsIntersection)!=0:
interPointsSave.InsertPoint(ptcount, pointsIntersection[0]-(feainnorm*0))
interPoints[id]=ptcount
ptcount+=1
# for each interPoint, probe cfddata fields
innerPointData = vtk.vtkPolyData()
innerPointData.SetPoints(interPointsSave)
"""
# IF LOADING FROM VOLUME
transform = vtk.vtkTransform()
transform.Scale(0.001,0.001,0.001)
test = vtk.vtkTransformPolyDataFilter()
test.SetTransform(transform)
test.SetInput(innerPointData)
test.Update()
innerPointData = test.GetOutput()
"""
probe = vtk.vtkProbeFilter()
probe.SetInput(innerPointData)
probe.SetSource(cfddata)
pd = vtk.vtkAppendPolyData()
pd.AddInputConnection(probe.GetOutputPort())
pd.Update()
probeData=pd.GetOutput()
# detect all fields
#fields=[]
#for f in range(0,probeData.GetPointData().GetNumberOfArrays()):
# fields.append(probeData.GetPointData().GetArrayName(f))
globalNodeIds=numpy_support.vtk_to_numpy(feabody.GetPointData().GetArray('PedigreeNodeId'))
fieldData={}
for f in self.fields:
fieldData[f]=numpy_support.vtk_to_numpy(probeData.GetPointData().GetArray(f))
for f in self.fields:
ff = open("bc/"+f+"/"+f+"_"+self.cfdData.split("_")[1].replace(".vtk",".inp"),'w')
if (f == "T"):
ff.write("*BOUNDARY\n")
elif (f == "p"):
ff.write("*CLOAD\n")
for id in innerIds:
try:
#print ",".join([str(globalNodeIds[id]),'11','11',str(fieldData[f][interPoints[id]])])
if fieldData[f][interPoints[id]] != 0:
if (f == "T"):
ff.write(",".join([str(globalNodeIds[id]),'11','11',str(fieldData[f][interPoints[id]])])+"\n")
elif (f == "p"):
ff.write(",".join([str(globalNodeIds[id]),'3',str(fieldData[f][interPoints[id]])])+"\n")
except:
pass
ff.close()
#writer = vtk.vtkDataSetWriter()
#writer.SetFileName('probe.vtk')
#writer.SetInput(probe.GetOutput())
#writer.Write()
"""
# WRITE INTERSECTION POINTS TO FILE
interPointsSave = vtk.vtkPoints()
ptcount=0
for pnt in interPoints:
interPointsSave.InsertPoint(ptcount, pnt)
ptcount+=1
innerPointData = vtk.vtkPolyData()
innerPointData.SetPoints(interPointsSave)
writer = vtk.vtkDataSetWriter()
writer.SetFileName('points.vtk')
writer.SetInput(innerPointData)
writer.Write()
"""
"""
def render_window_serializer(render_window):
"""
Function to convert a vtk render window in a list of 2-tuple where first value
correspond to a relative file path in the `vtkjs` directory structure and values
of the binary content of the corresponding file.
"""
render_window.OffScreenRenderingOn() # to not pop a vtk windows
render_window.Render()
renderers = render_window.GetRenderers()
doCompressArrays = False
objIds = []
scDirs = []
sceneComponents = []
textureToSave = {}
for renderer in renderers:
renProps = renderer.GetViewProps()
for rpIdx in range(renProps.GetNumberOfItems()):
renProp = renProps.GetItemAsObject(rpIdx)
if not renProp.GetVisibility():
continue
if hasattr(renProp, 'GetMapper'):
mapper = renProp.GetMapper()
if mapper is None:
continue
dataObject = mapper.GetInputDataObject(0, 0)
dataset = None
if dataObject.IsA('vtkCompositeDataSet'):
if dataObject.GetNumberOfBlocks() == 1:
dataset = dataObject.GetBlock(0)
else:
gf = vtk.vtkCompositeDataGeometryFilter()
gf.SetInputData(dataObject)
gf.Update()
dataset = gf.GetOutput()
elif dataObject.IsA('vtkUnstructuredGrid'):
gf = vtk.vtkGeometryFilter()
gf.SetInputData(dataObject)
gf.Update()
dataset = gf.GetOutput()
else:
dataset = mapper.GetInput()
if dataset and not isinstance(dataset, (vtk.vtkPolyData)):
# All data must be PolyData surfaces!
gf = vtk.vtkGeometryFilter()
gf.SetInputData(dataset)
gf.Update()
dataset = gf.GetOutputDataObject(0)
if dataset and dataset.GetPoints():
componentName = str(id(renProp))
scalarVisibility = mapper.GetScalarVisibility()
arrayAccessMode = mapper.GetArrayAccessMode()
colorArrayName = mapper.GetArrayName(
) if arrayAccessMode == 1 else mapper.GetArrayId()
colorMode = mapper.GetColorMode()
scalarMode = mapper.GetScalarMode()
lookupTable = mapper.GetLookupTable()
dsAttrs = None
arrayLocation = ''
if scalarVisibility:
if scalarMode == 0:
# By default (ScalarModeToDefault), the filter will use point data,
# and if no point data is available, then cell data is used
# https://vtk.org/doc/nightly/html/classvtkMapper.html#af330900726eb1a5e18e5f7f557306e52
if dataset.GetPointData().GetNumberOfArrays() >= 1:
dsAttrs = dataset.GetPointData()
arrayLocation = 'pointData'
else:
dsAttrs = dataset.GetCellData()
arrayLocation = 'cellData'
if scalarMode == 3 or scalarMode == 1: # VTK_SCALAR_MODE_USE_POINT_FIELD_DATA or VTK_SCALAR_MODE_USE_POINT_DATA
dsAttrs = dataset.GetPointData()
arrayLocation = 'pointData'
elif scalarMode == 4 or scalarMode == 2: # VTK_SCALAR_MODE_USE_CELL_FIELD_DATA or VTK_SCALAR_MODE_USE_CELL_DATA
dsAttrs = dataset.GetCellData()
arrayLocation = 'cellData'
colorArray = None
dataArray = None
if dsAttrs:
if colorArrayName >= 0:
dataArray = dsAttrs.GetArray(colorArrayName)
elif dsAttrs.GetNumberOfArrays() >= 1:
dataArray = dsAttrs.GetArray(0)
if dataArray:
# component = -1 => let specific instance get scalar from vector before mapping
colorArray = lookupTable.MapScalars(
dataArray, colorMode, -1)
colorArrayName = '__CustomRGBColorArray__'
colorArray.SetName(colorArrayName)
colorMode = 0
else:
colorArrayName = ''
colorArrayInfo = {
'colorArray': colorArray,
'location': arrayLocation
}
_write_data_set(scDirs,
dataset,
colorArrayInfo,
newDSName=componentName,
compress=doCompressArrays)
# Handle texture if any
textureName = None
if renProp.GetTexture() and renProp.GetTexture().GetInput(
):
textureData = renProp.GetTexture().GetInput()
textureName = 'texture_%d' % _get_object_id(
textureData, objIds)
textureToSave[textureName] = textureData
representation = renProp.GetProperty().GetRepresentation(
) if hasattr(renProp, 'GetProperty') else 2
if representation == 1:
colorToUse = renProp.GetProperty().GetColor(
) if hasattr(renProp, 'GetProperty') else [1, 1, 1]
else:
colorToUse = renProp.GetProperty().GetDiffuseColor(
) if hasattr(renProp, 'GetProperty') else [1, 1, 1]
pointSize = renProp.GetProperty().GetPointSize(
) if hasattr(renProp, 'GetProperty') else 1.0
opacity = renProp.GetProperty().GetOpacity() if hasattr(
renProp, 'GetProperty') else 1.0
edgeVisibility = renProp.GetProperty().GetEdgeVisibility(
) if hasattr(renProp, 'GetProperty') else False
p3dPosition = renProp.GetPosition() if renProp.IsA(
'vtkProp3D') else [0, 0, 0]
p3dScale = renProp.GetScale() if renProp.IsA(
'vtkProp3D') else [1, 1, 1]
p3dOrigin = renProp.GetOrigin() if renProp.IsA(
'vtkProp3D') else [0, 0, 0]
p3dRotateWXYZ = renProp.GetOrientationWXYZ(
) if renProp.IsA('vtkProp3D') else [0, 0, 0, 0]
sceneComponents.append({
"name": componentName,
"type": "httpDataSetReader",
"httpDataSetReader": {
"url": componentName
},
"actor": {
"origin": p3dOrigin,
"scale": p3dScale,
"position": p3dPosition,
},
"actorRotation": p3dRotateWXYZ,
"mapper": {
"colorByArrayName": colorArrayName,
"colorMode": colorMode,
"scalarMode": scalarMode
},
"property": {
"representation": representation,
"edgeVisibility": edgeVisibility,
"diffuseColor": colorToUse,
"pointSize": pointSize,
"opacity": opacity
},
"lookupTable": {
"tableRange":
lookupTable.GetRange(),
"hueRange":
lookupTable.GetHueRange() if hasattr(
lookupTable, 'GetHueRange') else [0.5, 0]
}
})
if textureName:
sceneComponents[-1]['texture'] = textureName
# Save texture data if any
for key, val in textureToSave.items():
_write_data_set(scDirs,
val,
None,
newDSName=key,
compress=doCompressArrays)
activeCamera = renderer.GetActiveCamera()
background = renderer.GetBackground()
sceneDescription = {
"fetchGzip": doCompressArrays,
"background": background,
"camera": {
"focalPoint": activeCamera.GetFocalPoint(),
"position": activeCamera.GetPosition(),
"viewUp": activeCamera.GetViewUp(),
"clippingRange": activeCamera.GetClippingRange()
},
"centerOfRotation": renderer.GetCenter(),
"scene": sceneComponents,
}
scDirs.append(['index.json', json.dumps(sceneDescription, indent=4)])
# create binary stream of the vtkjs directory structure
compression = zipfile.ZIP_DEFLATED
in_memory = BytesIO()
zf = zipfile.ZipFile(in_memory, mode="w")
try:
for dirPath, data in (scDirs):
zf.writestr(dirPath, data, compress_type=compression)
finally:
zf.close()
in_memory.seek(0)
return in_memory
def getFreeSurfaceActor(vtk_r, scale=[1, 1, 1], fsRange=None):
aa = vtk.vtkAssignAttribute()
aa.SetInputConnection(vtk_r.GetOutputPort())
aa.Assign('alpha.water', "SCALARS", "POINT_DATA")
isoContour = vtk.vtkContourFilter()
isoContour.SetInputConnection(aa.GetOutputPort())
isoContour.SetValue(0, 0.5)
# isoContour.SetGenerateTriangles(0)
isoContour.SetNumberOfContours(1)
isoContourDataFilter = vtk.vtkCompositeDataGeometryFilter()
isoContourDataFilter.SetInputConnection(isoContour.GetOutputPort())
transform = vtk.vtkTransform()
transform.Scale(*scale)
tf = vtk.vtkTransformPolyDataFilter()
tf.SetInputConnection(isoContourDataFilter.GetOutputPort())
tf.SetTransform(transform)
# Use an ArrayCalculator to get the iso-contour elevation
calc = vtk.vtkArrayCalculator()
calc.SetInputConnection(tf.GetOutputPort())
calc.SetAttributeModeToUsePointData()
calc.AddCoordinateScalarVariable("coordsZ", 2)
calc.SetFunction("coordsZ")
calc.SetResultArrayName("coordsZ")
#--- Map the data
isoContourMapper = vtk.vtkDataSetMapper()
isoContourMapper.SetInputConnection(calc.GetOutputPort())
#---Select node property to display
lutBlueRed = vtk.vtkLookupTable()
lutBlueRed.SetHueRange(2. / 3., 0.)
lutBlueRed.SetVectorModeToMagnitude()
lutBlueRed.Build()
scalarBar = vtk.vtkScalarBarActor()
scalarBar.SetLookupTable(lutBlueRed)
scalarBar.SetWidth(0.05)
scalarBar.SetHeight(0.25)
scalarBar.SetTitle("Z(m)")
scalarBar.GetTitleTextProperty().SetColor(0., 0., 0.)
scalarBar.GetLabelTextProperty().SetColor(0., 0., 0.)
isoContourMapper.SelectColorArray("coordsZ")
# isoContourMapper.SetScalarModeToUsePointData()
isoContourMapper.SetScalarModeToUsePointFieldData()
isoContourMapper.SetLookupTable(lutBlueRed)
if fsRange is not None:
isoContourMapper.SetScalarRange(*fsRange)
isoContourMapper.SetUseLookupTableScalarRange(0)
#---Add actor
fsActor = vtk.vtkActor()
fsActor.GetProperty().SetEdgeVisibility(0)
fsActor.SetMapper(isoContourMapper)
fsActor.GetProperty().SetOpacity(0.7)
return fsActor, scalarBar
