def _load_vtp(filepath, fieldname=None):
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(filepath)
reader.Update()
if fieldname is None:
return to_mesh_state(reader.GetOutput())
else:
return to_mesh_state(reader.GetOutput(), fieldname)
def _load_vtp(filepath, fieldname=None, point_arrays=[], cell_arrays=[]):
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(filepath)
reader.Update()
# Cache mesh for future lookup
part_name = filepath.split("/")[-1].replace(".vtp", "")
vtk_datasets[part_name] = reader.GetOutput()
return to_mesh_state(reader.GetOutput(), fieldname, point_arrays,
cell_arrays)
def __init__(self, data_directory):
self.color_range = [0, 1]
bike_filename = os.path.join(data_directory, "bike.vtp")
tunnel_filename = os.path.join(data_directory, "tunnel.vtu")
# Seeds settings
self.resolution = 10
self.point1 = [-0.4, 0, 0.05]
self.point2 = [-0.4, 0, 1.5]
# VTK Pipeline setup
bikeReader = vtk.vtkXMLPolyDataReader()
bikeReader.SetFileName(bike_filename)
bikeReader.Update()
self.bike_mesh = to_mesh_state(bikeReader.GetOutput())
tunnelReader = vtk.vtkXMLUnstructuredGridReader()
tunnelReader.SetFileName(tunnel_filename)
tunnelReader.Update()
self.lineSeed = vtk.vtkLineSource()
self.lineSeed.SetPoint1(*self.point1)
self.lineSeed.SetPoint2(*self.point2)
self.lineSeed.SetResolution(self.resolution)
streamTracer = vtk.vtkStreamTracer()
streamTracer.SetInputConnection(tunnelReader.GetOutputPort())
streamTracer.SetSourceConnection(self.lineSeed.GetOutputPort())
streamTracer.SetIntegrationDirectionToForward()
streamTracer.SetIntegratorTypeToRungeKutta45()
streamTracer.SetMaximumPropagation(3)
streamTracer.SetIntegrationStepUnit(2)
streamTracer.SetInitialIntegrationStep(0.2)
streamTracer.SetMinimumIntegrationStep(0.01)
streamTracer.SetMaximumIntegrationStep(0.5)
streamTracer.SetMaximumError(0.000001)
streamTracer.SetMaximumNumberOfSteps(2000)
streamTracer.SetTerminalSpeed(0.00000000001)
self.tubeFilter = vtk.vtkTubeFilter()
self.tubeFilter.SetInputConnection(streamTracer.GetOutputPort())
self.tubeFilter.SetRadius(0.01)
self.tubeFilter.SetNumberOfSides(6)
self.tubeFilter.CappingOn()
self.tubeFilter.Update()
def _load_vtp(filepath, fieldname=None, point_arrays=[], cell_arrays=[]):
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(filepath)
reader.Update()
return to_mesh_state(reader.GetOutput(), fieldname, point_arrays,
cell_arrays)
def getTubesMesh(self, color_by_field_name):
self.tubeFilter.Update()
ds = self.tubeFilter.GetOutput()
mesh_state = to_mesh_state(ds, color_by_field_name)
self.color_range = mesh_state["field"]["dataRange"]
return mesh_state
import dash
import dash_html_components as html
import dash_vtk
from dash_vtk.utils import to_mesh_state
from vtk.vtkImagingCore import vtkRTAnalyticSource
# Use VTK to get some data
data_source = vtkRTAnalyticSource()
data_source.Update() # <= Execute source to produce an output
dataset = data_source.GetOutput()
# Use helper to get a mesh structure that can be passed as-is to a Mesh
# RTData is the name of the field
mesh_state = to_mesh_state(dataset)
content = dash_vtk.View([
dash_vtk.GeometryRepresentation([dash_vtk.Mesh(state=mesh_state)]),
])
# Dash setup
app = dash.Dash(__name__)
server = app.server
app.layout = html.Div(
style={
"width": "100%",
"height": "calc(100vh - 15px)"
},
children=[content],
import dash
import dash_core_components as dcc
import dash_html_components as html
import vtk
import dash_vtk
from dash_vtk.utils import to_mesh_state
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName("./data/flow_pyevtk.vtu")
reader.Update() # Needed because of GetScalarRange
output = reader.GetOutput()
mesh_state = to_mesh_state(reader.GetOutput())
vtk_view = dash_vtk.View(
id="vtk-view",
children=[
dash_vtk.GeometryRepresentation(
children=[dash_vtk.Mesh(state=mesh_state)], )
],
)
app = dash.Dash(__name__, external_stylesheets=[])
app.layout = html.Div(
style={
"height": "calc(100vh - 16px)",
"width": "100%"
},
children=[html.Div(vtk_view, style={
"height": "100%",
"width": "100%"
})],
head_vti = os.path.join(repo_path, 'demos', 'data', 'head.vti')
# Load dataset from dist
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(head_vti)
reader.Update()
# Extract iso-mesh from image
contour = vtk.vtkContourFilter()
contour.SetInputConnection(reader.GetOutputPort())
contour.SetNumberOfContours(1)
contour.SetValue(0, 1500)
contour.Update()
# Get mesh to dash_vtk
mesh_state = to_mesh_state(contour.GetOutput())
content = dash_vtk.View([
dash_vtk.GeometryRepresentation([
dash_vtk.Mesh(state=mesh_state)
]),
])
# Dash setup
app = dash.Dash(__name__)
server = app.server
app.layout = html.Div(
style={"width": "100%", "height": "calc(100vh - 15px)"},
children=[content],
)
def fea_vtk_upload(node_contents, elem_contents, elem_data_contents,
cs_name, rng_slide, toggle_edges, is_cleared):
ctx = dash.callback_context
if not ctx.triggered:
raise PreventUpdate
trig_id = ctx.triggered[0]['prop_id'].split('.')[0]
# scenario 1: nodes data, but elems wasnt cleared (clears elems)
if trig_id == f'{APP_ID}_nodes_upload' and not is_cleared[0]:
return [dash.no_update, [True], dash.no_update, None]
# scenario 2: elems data, but nodes wasnt cleared (clears nodes)
if trig_id == f'{APP_ID}_elems_upload' and not is_cleared[0]:
return [dash.no_update, [True], None, dash.no_update]
# scenario 3: nodes data, but no elems data
if trig_id == f'{APP_ID}_nodes_upload' and elem_contents is None:
raise PreventUpdate
# scenario 4: elems data, but no nodes data
if trig_id == f'{APP_ID}_elems_upload' and node_contents is None:
raise PreventUpdate
# scenario 5: data for both mesh, but no results
if all([
node_contents is not None, elem_contents is not None,
is_cleared[0], elem_data_contents is None
]):
uGrid, _ = ns_export_to_uGrid(node_contents, elem_contents)
mesh_state = to_mesh_state(uGrid)
return [
dash_vtk.GeometryRepresentation(
[dash_vtk.Mesh(state=mesh_state)],
property={
"edgeVisibility": False,
"opacity": 0.25,
'representation': 2
}),
[False],
dash.no_update,
dash.no_update,
]
# scenario 6: data for the whole shebang
if all([
node_contents is not None, elem_contents is not None,
elem_data_contents is not None
]):
uGrid, rng = ns_export_to_uGrid(node_contents, elem_contents,
elem_data_contents)
mesh_state1 = to_mesh_state(uGrid)
if rng_slide[0] == 0. and rng_slide[1] != 1.:
# threshold to keep values below upper value of range slider
thresh = uGrid.threshold_percent(rng_slide[1], invert=True)
elif rng_slide[0] != 0. and rng_slide[1] == 1.:
# threshold to keep values above lower value of range slider
thresh = uGrid.threshold_percent(rng_slide[0])
elif rng_slide[0] == 0. and rng_slide[1] == 1.:
thresh = uGrid.copy()
else:
# threshold to keep values in range
thresh = uGrid.threshold_percent(rng_slide)
mesh_state2 = to_mesh_state(thresh, field_to_keep='my_array')
if 1 in toggle_edges:
show_edges = True
else:
show_edges = False
return [
[
# this is the ghost display to see the outline of the part
dash_vtk.GeometryRepresentation(
[dash_vtk.Mesh(state=mesh_state1)],
property={
"edgeVisibility": False,
"opacity": .15
},
),
# this is the threshold solid elements within the range slider values
dash_vtk.GeometryRepresentation(
[dash_vtk.Mesh(state=mesh_state2)],
property={
"edgeVisibility": show_edges,
"opacity": 1
},
colorMapPreset=cs_name,
showCubeAxes=False,
colorDataRange=rng),
],
[False],
dash.no_update,
dash.no_update,
]
