def testReader3D(self):
names = [("multi-ascii.xyz", "multi-ascii.q"), ("multi-bin-C.xyz", "multi-bin-C.q"), ("multi-bin.xyz", "multi-bin.q"), ("multi-bin.xyz", "multi-bin-oflow.q")]
for name in names:
r = vtk.vtkMultiBlockPLOT3DReader()
print "Testing ", name[0]
if name[0] == "multi-ascii.xyz":
r.BinaryFileOff()
r.MultiGridOn()
else:
r.AutoDetectFormatOn()
r.SetFileName(str(VTK_DATA_ROOT) + "/Data/" + name[0])
r.SetQFileName(str(VTK_DATA_ROOT) + "/Data/" + name[1])
r.Update()
output = r.GetOutput()
self.assertEqual(output.GetNumberOfBlocks(), 2)
b0 = output.GetBlock(0)
self.assertEqual(int(b0.GetFieldData().GetArray("Properties").GetValue(0)), 2)
pd = b0.GetPointData()
self.assertEqual(int(pd.GetArray("Momentum").GetComponent(10, 2)), 0)
self.assertEqual(int(pd.GetArray("StagnationEnergy").GetValue(3)), 9)
b1 = output.GetBlock(1)
self.assertEqual(int(b1.GetFieldData().GetArray("Properties").GetValue(0)), 2)
pd = b1.GetPointData()
self.assertEqual(int(pd.GetArray("Momentum").GetComponent(10, 2)), 0)
self.assertEqual(int(pd.GetArray("StagnationEnergy").GetValue(3)), 3)
def testReader2D(self):
names = [("multi-bin-2D.xyz", "multi-bin-2D.q")]
for name in names:
r = vtk.vtkMultiBlockPLOT3DReader()
print("Testing ", name[0])
r.AutoDetectFormatOn()
r.SetFileName(str(VTK_DATA_ROOT) + "/Data/" + name[0])
r.SetQFileName(str(VTK_DATA_ROOT) + "/Data/" + name[1])
r.Update()
output = r.GetOutput()
self.assertEqual(output.GetNumberOfBlocks(), 2)
b0 = output.GetBlock(0)
self.assertEqual(
int(b0.GetFieldData().GetArray("Properties").GetValue(0)), 2)
pd = b0.GetPointData()
self.assertEqual(int(pd.GetArray("Momentum").GetComponent(10, 2)),
0)
self.assertEqual(int(pd.GetArray("StagnationEnergy").GetValue(3)),
9)
b1 = output.GetBlock(1)
self.assertEqual(
int(b1.GetFieldData().GetArray("Properties").GetValue(0)), 2)
pd = b1.GetPointData()
self.assertEqual(int(pd.GetArray("Momentum").GetComponent(10, 2)),
0)
self.assertEqual(int(pd.GetArray("StagnationEnergy").GetValue(3)),
1)
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkMultiBlockPLOT3DReader(), 'Reading vtkMultiBlockPLOT3D.',
(), ('vtkMultiBlockPLOT3D',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def main():
xyz_filename, g_filename = get_program_parameters()
colors = vtk.vtkNamedColors()
reader = vtk.vtkMultiBlockPLOT3DReader()
reader.SetXYZFileName(xyz_filename)
reader.SetQFileName(g_filename)
reader.SetScalarFunctionNumber(100)
reader.SetVectorFunctionNumber(202)
reader.Update()
geometry_filter = vtk.vtkStructuredGridGeometryFilter()
geometry_filter.SetInputData(reader.GetOutput().GetBlock(0))
geometry_filter.Update()
# Visualize
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(geometry_filter.GetOutputPort())
mapper.ScalarVisibilityOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d("LimeGreen"))
render_window.Render()
render_window_interactor.Start()
def read_plot3d(filename, q_filenames=(), auto_detect=True, attrs=None):
"""Read a Plot3D grid file (e.g., grid.in) and optional q file(s).
Parameters
----------
filename : str
The string filename to the data file to read.
q_filenames : str or tuple(str), optional
The string filename of the q-file, or iterable of such filenames.
auto_detect : bool, optional
When this option is turned on, the reader will try to figure out the
values of various options such as byte order, byte count etc. Default is
True.
attrs : dict, optional
A dictionary of attributes to call on the reader. Keys of dictionary are
the attribute/method names and values are the arguments passed to those
calls. If you do not have any attributes to call, pass ``None`` as the
value.
Returns
-------
mesh : pyvista.MultiBlock
Data read from the file.
"""
filename = _process_filename(filename)
reader = vtk.vtkMultiBlockPLOT3DReader()
reader.SetFileName(filename)
# q_filenames may be a list or a single filename
if q_filenames:
if isinstance(q_filenames, (str, pathlib.Path)):
q_filenames = [q_filenames]
q_filenames = [_process_filename(f) for f in q_filenames]
if hasattr(reader, 'AddFileName'):
# AddFileName was added to vtkMultiBlockPLOT3DReader sometime around
# VTK 8.2. This method supports reading multiple q files.
for q_filename in q_filenames:
reader.AddFileName(q_filename)
else:
# SetQFileName is used to add a single q file to be read, and is still
# supported in VTK9.
if len(q_filenames) > 0:
if len(q_filenames) > 1:
raise RuntimeError(
'Reading of multiple q files is not supported '
'with this version of VTK.')
reader.SetQFileName(q_filenames[0])
attrs = {} if not attrs else attrs
attrs['SetAutoDetectFormat'] = auto_detect
return standard_reader_routine(reader, filename=None, attrs=attrs)
def make_models(self):
"""
make models
"""
# Read some structured data.
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin")
pl3d.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin")
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
pl3d_output = pl3d.GetOutput().GetBlock(0)
# Here we subsample the grid. The SetVOI method requires six values
# specifying (imin,imax, jmin,jmax, kmin,kmax) extents. In this
# example we extracting a plane. Note that the VOI is clamped to zero
# (min) and the maximum i-j-k value; that way we can use the
# -1000,1000 specification and be sure the values are clamped. The
# SampleRate specifies that we take every point in the i-direction;
# every other point in the j-direction; and every third point in the
# k-direction. IncludeBoundaryOn makes sure that we get the boundary
# points even if the SampleRate does not coincident with the boundary.
extract = vtk.vtkExtractGrid()
extract.SetInputData(pl3d_output)
extract.SetVOI(self.slice_factor, self.slice_factor, -1000, 1000, -1000, 1000)
extract.SetSampleRate(1, 2, 3)
extract.IncludeBoundaryOn()
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(extract.GetOutputPort())
mapper.SetScalarRange(.18, .7)
self.surface_actor = vtk.vtkActor()
self.surface_actor.SetMapper(mapper)
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3d_output)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
self.outline_actor = vtk.vtkActor()
self.outline_actor.SetMapper(outlineMapper)
self.outline_actor.GetProperty().SetColor(0, 0, 0)
self.extract_model = extract
#!/usr/bin/env python # This example demonstrates the subsampling of a structured grid. import vtk from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Read some structured data. pl3d = vtk.vtkMultiBlockPLOT3DReader() pl3d.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin") pl3d.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin") pl3d.SetScalarFunctionNumber(100) pl3d.SetVectorFunctionNumber(202) pl3d.Update() pl3d_output = pl3d.GetOutput().GetBlock(0) # Here we subsample the grid. The SetVOI method requires six values # specifying (imin,imax, jmin,jmax, kmin,kmax) extents. In this # example we extracting a plane. Note that the VOI is clamped to zero # (min) and the maximum i-j-k value; that way we can use the # -1000,1000 specification and be sure the values are clamped. The # SampleRate specifies that we take every point in the i-direction; # every other point in the j-direction; and every third point in the # k-direction. IncludeBoundaryOn makes sure that we get the boundary # points even if the SampleRate does not coincident with the boundary. extract = vtk.vtkExtractGrid() extract.SetInputData(pl3d_output) extract.SetVOI(30, 30, -1000, 1000, -1000, 1000) extract.SetSampleRate(1, 2, 3) extract.IncludeBoundaryOn()
def main():
colors = vtk.vtkNamedColors()
fileName1, fileName2, numOfStreamLines, illustration = get_program_parameters(
)
if illustration:
numOfStreamLines = 25
# Start by loading some data.
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(fileName1)
pl3d.SetQFileName(fileName2)
pl3d.SetScalarFunctionNumber(100) # Density
pl3d.SetVectorFunctionNumber(202) # Momentum
pl3d.Update()
pl3d_output = pl3d.GetOutput().GetBlock(0)
# Create the Renderer, RenderWindow and RenderWindowInteractor.
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Needed by: vtkStreamTracer and vtkLineWidget.
seeds = vtk.vtkPolyData()
streamline = vtk.vtkActor()
seeds2 = vtk.vtkPolyData()
streamline2 = vtk.vtkActor()
# The line widget is used seed the streamlines.
lineWidget = vtk.vtkLineWidget()
lineWidget.SetResolution(numOfStreamLines)
lineWidget.SetInputData(pl3d_output)
lineWidget.GetPolyData(seeds)
if illustration:
lineWidget.SetAlignToNone()
lineWidget.SetPoint1(0.974678, 5.073630, 31.217961)
lineWidget.SetPoint2(0.457544, -4.995921, 31.080175)
else:
lineWidget.SetAlignToYAxis()
lineWidget.ClampToBoundsOn()
lineWidget.PlaceWidget()
# Associate the line widget with the interactor and setup callbacks.
lineWidget.SetInteractor(iren)
lineWidget.AddObserver("StartInteractionEvent",
EnableActorCallback(streamline))
lineWidget.AddObserver("InteractionEvent",
GenerateStreamlinesCallback(seeds, renWin))
# The second line widget is used seed more streamlines.
lineWidget2 = vtk.vtkLineWidget()
lineWidget2.SetResolution(numOfStreamLines)
lineWidget2.SetInputData(pl3d_output)
lineWidget2.GetPolyData(seeds2)
lineWidget2.SetKeyPressActivationValue('L')
lineWidget2.SetAlignToZAxis()
lineWidget.ClampToBoundsOn()
lineWidget2.PlaceWidget()
# Associate the line widget with the interactor and setup callbacks.
lineWidget2.SetInteractor(iren)
lineWidget2.AddObserver("StartInteractionEvent",
EnableActorCallback(streamline2))
lineWidget2.AddObserver("InteractionEvent",
GenerateStreamlinesCallback(seeds2, renWin))
# Here we set up two streamlines.
rk4 = vtk.vtkRungeKutta4()
streamer = vtk.vtkStreamTracer()
streamer.SetInputData(pl3d_output)
streamer.SetSourceData(seeds)
streamer.SetMaximumPropagation(100)
streamer.SetInitialIntegrationStep(0.2)
streamer.SetIntegrationDirectionToForward()
streamer.SetComputeVorticity(1)
streamer.SetIntegrator(rk4)
rf = vtk.vtkRibbonFilter()
rf.SetInputConnection(streamer.GetOutputPort())
rf.SetWidth(0.1)
rf.SetWidthFactor(5)
streamMapper = vtk.vtkPolyDataMapper()
streamMapper.SetInputConnection(rf.GetOutputPort())
streamMapper.SetScalarRange(pl3d_output.GetScalarRange())
streamline.SetMapper(streamMapper)
streamline.VisibilityOff()
streamer2 = vtk.vtkStreamTracer()
streamer2.SetInputData(pl3d_output)
streamer2.SetSourceData(seeds2)
streamer2.SetMaximumPropagation(100)
streamer2.SetInitialIntegrationStep(0.2)
streamer2.SetIntegrationDirectionToForward()
streamer2.SetComputeVorticity(1)
streamer2.SetIntegrator(rk4)
rf2 = vtk.vtkRibbonFilter()
rf2.SetInputConnection(streamer2.GetOutputPort())
rf2.SetWidth(0.1)
rf2.SetWidthFactor(5)
streamMapper2 = vtk.vtkPolyDataMapper()
streamMapper2.SetInputConnection(rf2.GetOutputPort())
streamMapper2.SetScalarRange(pl3d_output.GetScalarRange())
streamline2.SetMapper(streamMapper2)
streamline2.VisibilityOff()
# Get an outline of the data set for context.
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3d_output)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.GetProperty().SetColor(colors.GetColor3d("Black"))
outlineActor.SetMapper(outlineMapper)
# Add the actors to the renderer, set the background and size.
ren.AddActor(outlineActor)
ren.AddActor(streamline)
ren.AddActor(streamline2)
renWin.SetSize(512, 512)
cam = ren.GetActiveCamera()
if illustration:
# We need to directly display the streamlines in this case.
lineWidget.EnabledOn()
streamline.VisibilityOn()
lineWidget.GetPolyData(seeds)
renWin.Render()
cam.SetClippingRange(14.216207, 68.382915)
cam.SetFocalPoint(9.718210, 0.458166, 29.399900)
cam.SetPosition(-15.827551, -16.997463, 54.003120)
cam.SetViewUp(0.616076, 0.179428, 0.766979)
ren.SetBackground(colors.GetColor3d("Silver"))
else:
cam.SetClippingRange(3.95297, 50)
cam.SetFocalPoint(9.71821, 0.458166, 29.3999)
cam.SetPosition(2.7439, -37.3196, 38.7167)
cam.SetViewUp(-0.16123, 0.264271, 0.950876)
ren.SetBackground(colors.GetColor3d("Silver"))
iren.Initialize()
renWin.Render()
iren.Start()
def main():
fileName1, fileName2 = get_program_parameters()
colors = vtk.vtkNamedColors()
# Set the background color.
colors.SetColor('BkgColor', [65, 99, 149, 255])
# Read a vtk file
#
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(fileName1)
pl3d.SetQFileName(fileName2)
pl3d.SetScalarFunctionNumber(100) # Density
pl3d.SetVectorFunctionNumber(202) # Momentum
pl3d.Update()
pl3dOutput = pl3d.GetOutput().GetBlock(0)
# What do we know about the data?
# Get the extent of the data: imin,imax, jmin,jmax, kmin,kmax
extent = pl3dOutput.GetExtent()
scalarRange = pl3dOutput.GetScalarRange()
# Planes are specified using a imin,imax, jmin,jmax, kmin,kmax coordinate
# specification. Min and max i,j,k values are clamped to 0 and maximum value.
# See the variable named extent for the values.
#
plane = vtk.vtkStructuredGridGeometryFilter()
plane.SetInputData(pl3dOutput)
plane.SetExtent(10, 10, 1, extent[3], 1, extent[5])
plane2 = vtk.vtkStructuredGridGeometryFilter()
plane2.SetInputData(pl3dOutput)
plane2.SetExtent(30, 30, 1, extent[3], 1, extent[5])
plane3 = vtk.vtkStructuredGridGeometryFilter()
plane3.SetInputData(pl3dOutput)
plane3.SetExtent(45, 45, 1, extent[3], 1, extent[5])
# We use an append filter because that way we can do the warping, etc. just
# using a single pipeline and actor.
#
appendF = vtk.vtkAppendPolyData()
appendF.AddInputConnection(plane.GetOutputPort())
appendF.AddInputConnection(plane2.GetOutputPort())
appendF.AddInputConnection(plane3.GetOutputPort())
# Warp
warp = vtk.vtkWarpVector()
warp.SetInputConnection(appendF.GetOutputPort())
warp.SetScaleFactor(0.005)
warp.Update()
normals = vtk.vtkPolyDataNormals()
normals.SetInputData(warp.GetPolyDataOutput())
normals.SetFeatureAngle(45)
planeMapper = vtk.vtkPolyDataMapper()
planeMapper.SetInputConnection(normals.GetOutputPort())
planeMapper.SetScalarRange(scalarRange)
planeActor = vtk.vtkActor()
planeActor.SetMapper(planeMapper)
# The outline provides context for the data and the planes.
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3dOutput)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(colors.GetColor3d('Black'))
# Create the RenderWindow, Renderer and both Actors
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
#
ren.AddActor(planeActor)
ren.AddActor(outlineActor)
ren.SetBackground(colors.GetColor3d('BkgColor'))
renWin.SetSize(512, 512)
renWin.SetWindowName('VelocityProfile')
iren.Initialize()
renWin.Render()
ren.GetActiveCamera().SetPosition(19.8562, -31.8912, 47.0755)
ren.GetActiveCamera().SetFocalPoint(8.255, 0.147815, 29.7631)
ren.GetActiveCamera().SetViewUp(-0.0333325, 0.465756, 0.884285)
ren.GetActiveCamera().SetClippingRange(17.3078, 64.6375)
renWin.Render()
iren.Start()
vtk.vtkNamedColors().GetColorRGB(colorName, rgb)
return rgb
# Demonstrate the generation of a structured grid from field data. The output
# should be similar to combIso.tcl.
#
# NOTE: This test only works if the current directory is writable
#
try:
channel = open("combsg.vtk", "wb")
channel.close()
channel = open("SGridField.vtk", "wb")
channel.close()
# Create a reader and write out the field
comb = vtk.vtkMultiBlockPLOT3DReader()
comb.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin")
comb.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin")
comb.SetScalarFunctionNumber(100)
comb.Update()
output = comb.GetOutput().GetBlock(0)
wsg = vtk.vtkStructuredGridWriter()
wsg.SetInputData(output)
wsg.SetFileTypeToBinary()
wsg.SetFileName("combsg.vtk")
wsg.Write()
pl3d = vtk.vtkStructuredGridReader()
pl3d.SetFileName("combsg.vtk")
def main():
colors = vtk.vtkNamedColors()
xyxFile, qFile = get_program_parameters()
# Read the data.
#
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.AutoDetectFormatOn()
pl3d.SetXYZFileName(xyxFile)
pl3d.SetQFileName(qFile)
pl3d.SetScalarFunctionNumber(153)
pl3d.SetVectorFunctionNumber(200)
pl3d.Update()
sg = pl3d.GetOutput().GetBlock(0)
# blue to red lut
#
lut = vtk.vtkLookupTable()
lut.SetHueRange(0.667, 0.0)
# Computational planes.
floorComp = vtk.vtkStructuredGridGeometryFilter()
floorComp.SetExtent(0, 37, 0, 75, 0, 0)
floorComp.SetInputData(sg)
floorComp.Update()
floorMapper = vtk.vtkPolyDataMapper()
floorMapper.SetInputConnection(floorComp.GetOutputPort())
floorMapper.ScalarVisibilityOff()
floorMapper.SetLookupTable(lut)
floorActor = vtk.vtkActor()
floorActor.SetMapper(floorMapper)
floorActor.GetProperty().SetRepresentationToWireframe()
floorActor.GetProperty().SetColor(colors.GetColor3d("Beige"))
floorActor.GetProperty().SetLineWidth(2)
subFloorComp = vtk.vtkStructuredGridGeometryFilter()
subFloorComp.SetExtent(0, 37, 0, 15, 22, 22)
subFloorComp.SetInputData(sg)
subFloorMapper = vtk.vtkPolyDataMapper()
subFloorMapper.SetInputConnection(subFloorComp.GetOutputPort())
subFloorMapper.SetLookupTable(lut)
subFloorMapper.SetScalarRange(sg.GetScalarRange())
subFloorActor = vtk.vtkActor()
subFloorActor.SetMapper(subFloorMapper)
subFloor2Comp = vtk.vtkStructuredGridGeometryFilter()
subFloor2Comp.SetExtent(0, 37, 60, 75, 22, 22)
subFloor2Comp.SetInputData(sg)
subFloor2Mapper = vtk.vtkPolyDataMapper()
subFloor2Mapper.SetInputConnection(subFloor2Comp.GetOutputPort())
subFloor2Mapper.SetLookupTable(lut)
subFloor2Mapper.SetScalarRange(sg.GetScalarRange())
subFloor2Actor = vtk.vtkActor()
subFloor2Actor.SetMapper(subFloor2Mapper)
postComp = vtk.vtkStructuredGridGeometryFilter()
postComp.SetExtent(10, 10, 0, 75, 0, 37)
postComp.SetInputData(sg)
postMapper = vtk.vtkPolyDataMapper()
postMapper.SetInputConnection(postComp.GetOutputPort())
postMapper.SetLookupTable(lut)
postMapper.SetScalarRange(sg.GetScalarRange())
postActor = vtk.vtkActor()
postActor.SetMapper(postMapper)
postActor.GetProperty().SetColor(colors.GetColor3d("Beige"))
fanComp = vtk.vtkStructuredGridGeometryFilter()
fanComp.SetExtent(0, 37, 38, 38, 0, 37)
fanComp.SetInputData(sg)
fanMapper = vtk.vtkPolyDataMapper()
fanMapper.SetInputConnection(fanComp.GetOutputPort())
fanMapper.SetLookupTable(lut)
fanMapper.SetScalarRange(sg.GetScalarRange())
fanActor = vtk.vtkActor()
fanActor.SetMapper(fanMapper)
fanActor.GetProperty().SetColor(colors.GetColor3d("Beige"))
# streamers
#
# spherical seed points
rake = vtk.vtkPointSource()
rake.SetCenter(-0.74, 0, 0.3)
rake.SetNumberOfPoints(10)
# a line of seed points
seedsComp = vtk.vtkStructuredGridGeometryFilter()
seedsComp.SetExtent(10, 10, 37, 39, 1, 35)
seedsComp.SetInputData(sg)
streamers = vtk.vtkStreamTracer()
streamers.SetInputConnection(pl3d.GetOutputPort())
# streamers SetSource [rake GetOutput]
streamers.SetSourceConnection(seedsComp.GetOutputPort())
streamers.SetMaximumPropagation(250)
streamers.SetInitialIntegrationStep(.2)
streamers.SetMinimumIntegrationStep(.01)
streamers.SetIntegratorType(2)
streamers.Update()
tubes = vtk.vtkTubeFilter()
tubes.SetInputConnection(streamers.GetOutputPort())
tubes.SetNumberOfSides(8)
tubes.SetRadius(.08)
tubes.SetVaryRadius(0)
mapTubes = vtk.vtkPolyDataMapper()
mapTubes.SetInputConnection(tubes.GetOutputPort())
mapTubes.SetScalarRange(sg.GetScalarRange())
tubesActor = vtk.vtkActor()
tubesActor.SetMapper(mapTubes)
# outline
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(sg)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(colors.GetColor3d("Beige"))
# Create graphics stuff.
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size.
#
ren1.AddActor(outlineActor)
ren1.AddActor(floorActor)
ren1.AddActor(subFloorActor)
ren1.AddActor(subFloor2Actor)
ren1.AddActor(postActor)
ren1.AddActor(fanActor)
ren1.AddActor(tubesActor)
aCam = vtk.vtkCamera()
aCam.SetFocalPoint(0.00657892, 0, 2.41026)
aCam.SetPosition(-1.94838, -47.1275, 39.4607)
aCam.SetViewUp(0.00653193, 0.617865, 0.786257)
ren1.ResetCamera()
aCam.Dolly(1.)
aCam.SetClippingRange(1, 100)
ren1.SetBackground(colors.GetColor3d("SlateGray"))
ren1.SetActiveCamera(aCam)
renWin.SetSize(640, 480)
renWin.Render()
iren.Start()
def __init__(self, parent, data_dir):
super(QGlyphViewer, self).__init__(parent)
# Make tha actual QtWidget a child so that it can be re parented
interactor = QVTKRenderWindowInteractor(self)
self.layout = QtWidgets.QHBoxLayout()
self.layout.addWidget(interactor)
self.layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.layout)
# Read the data
xyx_file = os.path.join(data_dir, "combxyz.bin")
q_file = os.path.join(data_dir, "combq.bin")
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(xyx_file)
pl3d.SetQFileName(q_file)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
blocks = pl3d.GetOutput()
b0 = blocks.GetBlock(0)
# Setup VTK environment
renderer = vtk.vtkRenderer()
render_window = interactor.GetRenderWindow()
render_window.AddRenderer(renderer)
interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
render_window.SetInteractor(interactor)
renderer.SetBackground(0.2, 0.2, 0.2)
# Draw Outline
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(b0)
outline_mapper = vtk.vtkPolyDataMapper()
outline_mapper.SetInputConnection(outline.GetOutputPort())
outline_actor = vtk.vtkActor()
outline_actor.SetMapper(outline_mapper)
outline_actor.GetProperty().SetColor(1, 1, 1)
renderer.AddActor(outline_actor)
renderer.ResetCamera()
# Draw Outline
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(b0)
outline_mapper = vtk.vtkPolyDataMapper()
outline_mapper.SetInputConnection(outline.GetOutputPort())
outline_actor = vtk.vtkActor()
outline_actor.SetMapper(outline_mapper)
outline_actor.GetProperty().SetColor(1, 1, 1)
renderer.AddActor(outline_actor)
renderer.ResetCamera()
# Threshold points
threshold = vtk.vtkThresholdPoints()
threshold.SetInputData(b0)
threshold.ThresholdByUpper(0.5)
# Draw arrows
arrow = vtk.vtkArrowSource()
glyphs = vtk.vtkGlyph3D()
glyphs.SetInputData(b0)
glyphs.SetSourceConnection(arrow.GetOutputPort())
glyphs.SetInputConnection(threshold.GetOutputPort())
glyphs.SetVectorModeToUseVector()
glyphs.SetScaleModeToScaleByVector()
glyphs.SetScaleFactor(0.005)
glyphs.SetColorModeToColorByVector()
# Mapper
glyph_mapper = vtk.vtkPolyDataMapper()
glyph_mapper.SetInputConnection(glyphs.GetOutputPort())
glyph_actor = vtk.vtkActor()
glyph_actor.SetMapper(glyph_mapper)
glyph_mapper.UseLookupTableScalarRangeOn()
renderer.AddActor(glyph_actor)
# Set color lookuptable
glyphs.Update()
s0, sf = glyphs.GetOutput().GetScalarRange()
lut = vtk.vtkColorTransferFunction()
lut.AddRGBPoint(s0, 1, 0, 0)
lut.AddRGBPoint(sf, 0, 1, 0)
glyph_mapper.SetLookupTable(lut)
# Register pick listener
self.b0 = b0
self.renderer = renderer
self.interactor = interactor
self.threshold = threshold
self.render_window = render_window
self.picker = vtk.vtkCellPicker()
self.picker.AddObserver("EndPickEvent", self.process_pick)
self.interactor.SetPicker(self.picker)
self.glyphs = glyphs
#
# You will most likely use vtkFieldDataToAttributeDataFilter, vtkHedgeHog,
# and vtkProgrammableAttributeDataFilter.
#
# Create the RenderWindow, Renderer and interactor
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# create pipeline
#
# get the pressure gradient vector field
pl3d_gradient = vtk.vtkMultiBlockPLOT3DReader()
pl3d_gradient.SetXYZFileName("" + str(VTK_DATA_ROOT) + "/Data/combxyz.bin")
pl3d_gradient.SetQFileName("" + str(VTK_DATA_ROOT) + "/Data/combq.bin")
pl3d_gradient.SetScalarFunctionNumber(100)
pl3d_gradient.SetVectorFunctionNumber(210)
pl3d_gradient.Update()
pl3d_g_output = pl3d_gradient.GetOutput().GetBlock(0)
# get the velocity vector field
pl3d_velocity = vtk.vtkMultiBlockPLOT3DReader()
pl3d_velocity.SetXYZFileName("" + str(VTK_DATA_ROOT) + "/Data/combxyz.bin")
pl3d_velocity.SetQFileName("" + str(VTK_DATA_ROOT) + "/Data/combq.bin")
pl3d_velocity.SetScalarFunctionNumber(100)
pl3d_velocity.SetVectorFunctionNumber(200)
pl3d_velocity.Update()
pl3d_v_output = pl3d_velocity.GetOutput().GetBlock(0)
# contour the scalar fields
#
# You will most likely use vtkFieldDataToAttributeDataFilter, vtkHedgeHog,
# and vtkProgrammableAttributeDataFilter.
#
# Create the RenderWindow, Renderer and interactor
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# create pipeline
#
# get the pressure gradient vector field
pl3d_gradient = vtk.vtkMultiBlockPLOT3DReader()
pl3d_gradient.SetXYZFileName("" + str(VTK_DATA_ROOT) + "/Data/combxyz.bin")
pl3d_gradient.SetQFileName("" + str(VTK_DATA_ROOT) + "/Data/combq.bin")
pl3d_gradient.SetScalarFunctionNumber(100)
pl3d_gradient.SetVectorFunctionNumber(210)
pl3d_gradient.Update()
pl3d_g_output = pl3d_gradient.GetOutput().GetBlock(0)
# get the velocity vector field
pl3d_velocity = vtk.vtkMultiBlockPLOT3DReader()
pl3d_velocity.SetXYZFileName("" + str(VTK_DATA_ROOT) + "/Data/combxyz.bin")
pl3d_velocity.SetQFileName("" + str(VTK_DATA_ROOT) + "/Data/combq.bin")
pl3d_velocity.SetScalarFunctionNumber(100)
pl3d_velocity.SetVectorFunctionNumber(200)
pl3d_velocity.Update()
pl3d_v_output = pl3d_velocity.GetOutput().GetBlock(0)
# contour the scalar fields
ren1.SetBackground(.8,.8,.2)
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
vectorLabels = "Velocity Vorticity Momentum Pressure_Gradient"
vectorFunctions = "200 201 202 210"
camera = vtk.vtkCamera()
light = vtk.vtkLight()
# All text actors will share the same text prop
textProp = vtk.vtkTextProperty()
textProp.SetFontSize(10)
textProp.SetFontFamilyToArial()
textProp.SetColor(.3,1,1)
i = 0
for vectorFunction in vectorFunctions.split():
locals()[get_variable_name("pl3d", vectorFunction, "")] = vtk.vtkMultiBlockPLOT3DReader()
locals()[get_variable_name("pl3d", vectorFunction, "")].SetXYZFileName("" + str(VTK_DATA_ROOT) + "/Data/bluntfinxyz.bin")
locals()[get_variable_name("pl3d", vectorFunction, "")].SetQFileName("" + str(VTK_DATA_ROOT) + "/Data/bluntfinq.bin")
locals()[get_variable_name("pl3d", vectorFunction, "")].SetVectorFunctionNumber(expr.expr(globals(), locals(),["int","(","vectorFunction",")"]))
locals()[get_variable_name("pl3d", vectorFunction, "")].Update()
output = locals()[get_variable_name("pl3d", vectorFunction, "")].GetOutput().GetBlock(0)
locals()[get_variable_name("plane", vectorFunction, "")] = vtk.vtkStructuredGridGeometryFilter()
locals()[get_variable_name("plane", vectorFunction, "")].SetInputData(output)
locals()[get_variable_name("plane", vectorFunction, "")].SetExtent(25,25,0,100,0,100)
locals()[get_variable_name("hog", vectorFunction, "")] = vtk.vtkHedgeHog()
locals()[get_variable_name("hog", vectorFunction, "")].SetInputConnection(locals()[get_variable_name("plane", vectorFunction, "")].GetOutputPort())
maxnorm = output.GetPointData().GetVectors().GetMaxNorm()
locals()[get_variable_name("hog", vectorFunction, "")].SetScaleFactor(expr.expr(globals(), locals(),["1.0","/","maxnorm"]))
locals()[get_variable_name("mapper", vectorFunction, "")] = vtk.vtkPolyDataMapper()
locals()[get_variable_name("mapper", vectorFunction, "")].SetInputConnection(locals()[get_variable_name("hog", vectorFunction, "")].GetOutputPort())
locals()[get_variable_name("actor", vectorFunction, "")] = vtk.vtkActor()
def main():
xyzFile, qFile = get_program_parameters()
colors = vtk.vtkNamedColors()
# Create pipeline. Read structured grid data.
#
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(xyzFile)
pl3d.SetQFileName(qFile)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
pl3dOutput = pl3d.GetOutput().GetBlock(0)
# A convenience, use this filter to limit data for experimentation.
extract = vtk.vtkExtractGrid()
extract.SetVOI(1, 55, -1000, 1000, -1000, 1000)
extract.SetInputData(pl3dOutput)
# The (implicit) plane is used to do the cutting
plane = vtk.vtkPlane()
plane.SetOrigin(0, 4, 2)
plane.SetNormal(0, 1, 0)
# The cutter is set up to process each contour value over all cells
# (SetSortByToSortByCell). This results in an ordered output of polygons
# which is key to the compositing.
cutter = vtk.vtkCutter()
cutter.SetInputConnection(extract.GetOutputPort())
cutter.SetCutFunction(plane)
cutter.GenerateCutScalarsOff()
cutter.SetSortByToSortByCell()
clut = vtk.vtkLookupTable()
clut.SetHueRange(0, 0.67)
clut.Build()
cutterMapper = vtk.vtkPolyDataMapper()
cutterMapper.SetInputConnection(cutter.GetOutputPort())
cutterMapper.SetScalarRange(0.18, 0.7)
cutterMapper.SetLookupTable(clut)
cut = vtk.vtkActor()
cut.SetMapper(cutterMapper)
# Add in some surface geometry for interest.
iso = vtk.vtkContourFilter()
iso.SetInputData(pl3dOutput)
iso.SetValue(0, .22)
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(iso.GetOutputPort())
normals.SetFeatureAngle(60)
isoMapper = vtk.vtkPolyDataMapper()
isoMapper.SetInputConnection(normals.GetOutputPort())
isoMapper.ScalarVisibilityOff()
isoActor = vtk.vtkActor()
isoActor.SetMapper(isoMapper)
isoActor.GetProperty().SetDiffuseColor(colors.GetColor3d('Tomato'))
isoActor.GetProperty().SetSpecularColor(colors.GetColor3d('White'))
isoActor.GetProperty().SetDiffuse(0.8)
isoActor.GetProperty().SetSpecular(0.5)
isoActor.GetProperty().SetSpecularPower(30)
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3dOutput)
outlineStrip = vtk.vtkStripper()
outlineStrip.SetInputConnection(outline.GetOutputPort())
outlineTubes = vtk.vtkTubeFilter()
outlineTubes.SetInputConnection(outline.GetOutputPort())
outlineTubes.SetInputConnection(outlineStrip.GetOutputPort())
outlineTubes.SetRadius(0.1)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outlineTubes.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
# Create the RenderWindow, Renderer and Interactor.
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size.
#
ren1.AddActor(outlineActor)
outlineActor.GetProperty().SetColor(colors.GetColor3d('Banana'))
ren1.AddActor(isoActor)
isoActor.VisibilityOn()
ren1.AddActor(cut)
n = 20
opacity = 1.0 / float(n) * 5.0
cut.GetProperty().SetOpacity(1)
ren1.SetBackground(colors.GetColor3d('SlateGray'))
renWin.SetSize(640, 480)
renWin.SetWindowName('PseudoVolumeRendering')
ren1.GetActiveCamera().SetClippingRange(3.95297, 50)
ren1.GetActiveCamera().SetFocalPoint(9.71821, 0.458166, 29.3999)
ren1.GetActiveCamera().SetPosition(2.7439, -37.3196, 38.7167)
ren1.GetActiveCamera().ComputeViewPlaneNormal()
ren1.GetActiveCamera().SetViewUp(-0.16123, 0.264271, 0.950876)
# Cut: generates n cut planes normal to camera's view plane.
#
plane.SetNormal(ren1.GetActiveCamera().GetViewPlaneNormal())
plane.SetOrigin(ren1.GetActiveCamera().GetFocalPoint())
cutter.GenerateValues(n, -5, 5)
clut.SetAlphaRange(opacity, opacity)
renWin.Render()
iren.Start()
def main():
colors = vtk.vtkNamedColors()
xyxFile, qFile = get_program_parameters()
# Read the data.
#
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.AutoDetectFormatOn()
pl3d.SetXYZFileName(xyxFile)
pl3d.SetQFileName(qFile)
pl3d.SetScalarFunctionNumber(153)
pl3d.SetVectorFunctionNumber(200)
pl3d.Update()
sg = pl3d.GetOutput().GetBlock(0)
# blue to red lut
#
lut = vtk.vtkLookupTable()
lut.SetHueRange(0.667, 0.0)
seeds = [[-0.74, 0.0, 0.3], [-0.74, 0.0, 1.0], [-0.74, 0.0, 2.0],
[-0.74, 0.0, 3.0]]
renderers = list()
for s in range(0, len(seeds)):
# computational planes
floorComp = vtk.vtkStructuredGridGeometryFilter()
floorComp.SetExtent(0, 37, 0, 75, 0, 0)
floorComp.SetInputData(sg)
floorComp.Update()
floorMapper = vtk.vtkPolyDataMapper()
floorMapper.SetInputConnection(floorComp.GetOutputPort())
floorMapper.ScalarVisibilityOff()
floorMapper.SetLookupTable(lut)
floorActor = vtk.vtkActor()
floorActor.SetMapper(floorMapper)
floorActor.GetProperty().SetRepresentationToWireframe()
floorActor.GetProperty().SetColor(colors.GetColor3d("Black"))
floorActor.GetProperty().SetLineWidth(2)
postComp = vtk.vtkStructuredGridGeometryFilter()
postComp.SetExtent(10, 10, 0, 75, 0, 37)
postComp.SetInputData(sg)
postMapper = vtk.vtkPolyDataMapper()
postMapper.SetInputConnection(postComp.GetOutputPort())
postMapper.SetLookupTable(lut)
postMapper.SetScalarRange(sg.GetScalarRange())
postActor = vtk.vtkActor()
postActor.SetMapper(postMapper)
postActor.GetProperty().SetColor(colors.GetColor3d("Black"))
# streamers
#
# spherical seed points
rake = vtk.vtkPointSource()
rake.SetCenter(seeds[s])
rake.SetNumberOfPoints(10)
streamers = vtk.vtkStreamTracer()
streamers.SetInputConnection(pl3d.GetOutputPort())
# streamers SetSource [rake GetOutput]
streamers.SetSourceConnection(rake.GetOutputPort())
streamers.SetMaximumPropagation(250)
streamers.SetInitialIntegrationStep(.2)
streamers.SetMinimumIntegrationStep(.01)
streamers.SetIntegratorType(2)
streamers.Update()
tubes = vtk.vtkTubeFilter()
tubes.SetInputConnection(streamers.GetOutputPort())
tubes.SetNumberOfSides(8)
tubes.SetRadius(.08)
tubes.SetVaryRadius(0)
mapTubes = vtk.vtkPolyDataMapper()
mapTubes.SetInputConnection(tubes.GetOutputPort())
mapTubes.SetScalarRange(sg.GetScalarRange())
tubesActor = vtk.vtkActor()
tubesActor.SetMapper(mapTubes)
renderer = vtk.vtkRenderer()
renderer.AddActor(floorActor)
renderer.AddActor(postActor)
renderer.AddActor(tubesActor)
renderer.SetBackground(colors.GetColor3d("SlateGray"))
renderers.append(renderer)
renderWindow = vtk.vtkRenderWindow()
# Setup viewports for the renderers
rendererSize = 256
xGridDimensions = 2
yGridDimensions = 2
renderWindow.SetSize(rendererSize * xGridDimensions,
rendererSize * yGridDimensions)
for row in range(0, yGridDimensions):
for col in range(xGridDimensions):
index = row * xGridDimensions + col
# (xmin, ymin, xmax, ymax)
viewport = [
float(col) / xGridDimensions,
float(yGridDimensions - (row + 1)) / yGridDimensions,
float(col + 1) / xGridDimensions,
float(yGridDimensions - row) / yGridDimensions
]
renderers[index].SetViewport(viewport)
camera = vtk.vtkCamera()
camera.SetFocalPoint(0.918037, -0.0779233, 2.69513)
camera.SetPosition(0.840735, -23.6176, 8.50211)
camera.SetViewUp(0.00227904, 0.239501, 0.970893)
camera.SetClippingRange(1, 100)
renderers[0].SetActiveCamera(camera)
for r in range(0, len(renderers)):
renderWindow.AddRenderer(renderers[r])
if r > 0:
renderers[r].SetActiveCamera(camera)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.SetSize(512, 512)
renderWindow.Render()
interactor.Start()
def main():
xyzFile, qFile = get_program_parameters()
colors = vtk.vtkNamedColors()
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# The cut data.
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(xyzFile)
pl3d.SetQFileName(qFile)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
sg = pl3d.GetOutput().GetBlock(0)
plane = vtk.vtkPlane()
plane.SetOrigin(sg.GetCenter())
plane.SetNormal(-0.287, 0, 0.9579)
planeCut = vtk.vtkCutter()
planeCut.SetInputData(pl3d.GetOutput().GetBlock(0))
planeCut.SetCutFunction(plane)
cutMapper = vtk.vtkDataSetMapper()
cutMapper.SetInputConnection(planeCut.GetOutputPort())
cutMapper.SetScalarRange(sg.GetPointData().GetScalars().GetRange())
cutActor = vtk.vtkActor()
cutActor.SetMapper(cutMapper)
# Extract the plane.
compPlane = vtk.vtkStructuredGridGeometryFilter()
compPlane.SetInputData(sg)
compPlane.SetExtent(0, 100, 0, 100, 9, 9)
planeMapper = vtk.vtkPolyDataMapper()
planeMapper.SetInputConnection(compPlane.GetOutputPort())
planeMapper.ScalarVisibilityOff()
planeActor = vtk.vtkActor()
planeActor.SetMapper(planeMapper)
planeActor.GetProperty().SetRepresentationToWireframe()
planeActor.GetProperty().SetColor(colors.GetColor3d("Wheat"))
# Outline.
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3d.GetOutput().GetBlock(0))
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(colors.GetColor3d("Wheat"))
# Add the actors to the renderer, set the background and size.
#
ren1.AddActor(outlineActor)
ren1.AddActor(planeActor)
ren1.AddActor(cutActor)
ren1.SetBackground(colors.GetColor3d("SlateGray"))
renWin.SetSize(640, 480)
ren1.GetActiveCamera().SetClippingRange(3.95297, 50)
ren1.GetActiveCamera().SetFocalPoint(9.71821, 0.458166, 29.3999)
ren1.GetActiveCamera().SetPosition(2.7439, -37.3196, 38.7167)
ren1.GetActiveCamera().SetViewUp(-0.16123, 0.264271, 0.950876)
ren1.ResetCamera()
ren1.GetActiveCamera().Elevation(30)
# Render the image.
#
renWin.Render()
iren.Start()
def main():
xyzFile, qFile = get_program_parameters()
colors = vtk.vtkNamedColors()
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# The cut data.
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(xyzFile)
pl3d.SetQFileName(qFile)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
sg = pl3d.GetOutput().GetBlock(0)
plane = vtk.vtkPlane()
plane.SetOrigin(sg.GetCenter())
plane.SetNormal(-0.287, 0, 0.9579)
planeCut = vtk.vtkCutter()
planeCut.SetInputData(pl3d.GetOutput().GetBlock(0))
planeCut.SetCutFunction(plane)
cutMapper = vtk.vtkDataSetMapper()
cutMapper.SetInputConnection(planeCut.GetOutputPort())
cutMapper.SetScalarRange(sg.GetPointData().GetScalars().GetRange())
cutActor = vtk.vtkActor()
cutActor.SetMapper(cutMapper)
# Extract the plane.
compPlane = vtk.vtkStructuredGridGeometryFilter()
compPlane.SetInputData(sg)
compPlane.SetExtent(0, 100, 0, 100, 9, 9)
planeMapper = vtk.vtkPolyDataMapper()
planeMapper.SetInputConnection(compPlane.GetOutputPort())
planeMapper.ScalarVisibilityOff()
planeActor = vtk.vtkActor()
planeActor.SetMapper(planeMapper)
planeActor.GetProperty().SetRepresentationToWireframe()
planeActor.GetProperty().SetColor(colors.GetColor3d('Wheat'))
# Outline.
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3d.GetOutput().GetBlock(0))
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(colors.GetColor3d('Wheat'))
# Add the actors to the renderer, set the background and size.
#
ren1.AddActor(outlineActor)
ren1.AddActor(planeActor)
ren1.AddActor(cutActor)
ren1.SetBackground(colors.GetColor3d('SlateGray'))
renWin.SetSize(640, 480)
renWin.SetWindowName('CutStructuredGrid')
camera = ren1.GetActiveCamera()
camera.SetPosition(5.02611, -23.535, 50.3979)
camera.SetFocalPoint(9.33614, 0.0414149, 30.112)
camera.SetViewUp(-0.0676794, 0.657814, 0.750134)
camera.SetDistance(31.3997)
camera.SetClippingRange(12.1468, 55.8147)
# Render the image.
#
renWin.Render()
iren.Start()
def testAll(self):
# cut data
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin")
pl3d.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin")
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
pl3d_output = pl3d.GetOutput().GetBlock(0)
range = pl3d_output.GetPointData().GetScalars().GetRange()
min = range[0]
max = range[1]
value = (min + max) / 2.0
cf = vtk.vtkGridSynchronizedTemplates3D()
cf.SetInputData(pl3d_output)
cf.SetValue(0, value)
cf.GenerateTrianglesOff()
cf.Update()
self.failUnlessEqual(
cf.GetOutputDataObject(0).GetNumberOfPoints(), 4674)
self.failUnlessEqual(
cf.GetOutputDataObject(0).GetNumberOfCells(), 4012)
cf.GenerateTrianglesOn()
cf.Update()
self.failUnlessEqual(
cf.GetOutputDataObject(0).GetNumberOfPoints(), 4674)
self.failUnlessEqual(
cf.GetOutputDataObject(0).GetNumberOfCells(), 8076)
# cf ComputeNormalsOff
cfMapper = vtk.vtkPolyDataMapper()
cfMapper.SetInputConnection(cf.GetOutputPort())
cfMapper.SetScalarRange(
pl3d_output.GetPointData().GetScalars().GetRange())
cfActor = vtk.vtkActor()
cfActor.SetMapper(cfMapper)
# outline
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3d_output)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(0, 0, 0)
# # Graphics stuff
# Create the RenderWindow, Renderer and both Actors
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
#
ren1.AddActor(outlineActor)
ren1.AddActor(cfActor)
ren1.SetBackground(1, 1, 1)
renWin.SetSize(400, 400)
cam1 = ren1.GetActiveCamera()
cam1.SetClippingRange(3.95297, 50)
cam1.SetFocalPoint(9.71821, 0.458166, 29.3999)
cam1.SetPosition(2.7439, -37.3196, 38.7167)
cam1.SetViewUp(-0.16123, 0.264271, 0.950876)
iren.Initialize()
# render the image
#
# loop over surfaces
i = 0
while i < 17:
cf.SetValue(0, min + (i / 16.0) * (max - min))
renWin.Render()
cf.SetValue(0, min + (0.2) * (max - min))
renWin.Render()
i += 1
def main():
dataFn1, dataFn2, textureFn = get_program_parameters()
colors = vtk.vtkNamedColors()
# Read the data.
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(dataFn1)
pl3d.SetQFileName(dataFn2)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
output = pl3d.GetOutput().GetBlock(0)
# Make the wall (floor).
wall = vtk.vtkStructuredGridGeometryFilter()
wall.SetInputData(output)
wall.SetExtent(0, 100, 0, 0, 0, 100)
wallMap = vtk.vtkPolyDataMapper()
wallMap.SetInputConnection(wall.GetOutputPort())
wallMap.ScalarVisibilityOff()
wallActor = vtk.vtkActor()
wallActor.SetMapper(wallMap)
wallActor.GetProperty().SetColor(colors.GetColor3d('PeachPuff'))
# Make the fin (rear wall)
fin = vtk.vtkStructuredGridGeometryFilter()
fin.SetInputData(output)
fin.SetExtent(0, 100, 0, 100, 0, 0)
finMap = vtk.vtkPolyDataMapper()
finMap.SetInputConnection(fin.GetOutputPort())
finMap.ScalarVisibilityOff()
finActor = vtk.vtkActor()
finActor.SetMapper(finMap)
finActor.GetProperty().SetColor(colors.GetColor3d('DarkSlateGray'))
# Get the texture.
tmap = vtk.vtkStructuredPointsReader()
tmap.SetFileName(textureFn)
texture = vtk.vtkTexture()
texture.SetInputConnection(tmap.GetOutputPort())
texture.InterpolateOff()
texture.RepeatOff()
# Create the rendering window, renderer, and interactive renderer.
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Make the planes to threshold and texture.
plane = list()
thresh = list()
planeMap = list()
planeActor = list()
# Define the extents of planes that we will use.
planeExtents = [[10, 10, 0, 100, 0, 100],
[30, 30, 0, 100, 0, 100],
[35, 35, 0, 100, 0, 100]]
# Now set up the pipeline.
for i in range(0, len(planeExtents)):
plane.append(vtk.vtkStructuredGridGeometryFilter())
plane[i].SetInputData(output)
plane[i].SetExtent(*planeExtents[i])
thresh.append(vtk.vtkThresholdTextureCoords())
thresh[i].SetInputConnection(plane[i].GetOutputPort())
thresh[i].SetInputConnection(plane[i].GetOutputPort())
# If you want an image similar to Fig 9-43(a) in the VTK textbook,
# set thresh[i].ThresholdByUpper(1.5) for all planes.
if i == 1:
thresh[i].ThresholdByLower(1.5)
elif i == 2:
thresh[i].ThresholdBetween(1.5, 1.8)
else:
thresh[i].ThresholdByUpper(1.5)
planeMap.append(vtk.vtkDataSetMapper())
planeMap[i].SetInputConnection(thresh[i].GetOutputPort())
planeMap[i].SetScalarRange(output.GetScalarRange())
planeActor.append(vtk.vtkActor())
planeActor[i].SetMapper(planeMap[i])
planeActor[i].SetTexture(texture)
# The slight transparency gives a nice effect.
planeActor[i].GetProperty().SetOpacity(0.999)
ren.AddActor(planeActor[i])
# Get an outline of the data set for context.
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(output)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineProp = outlineActor.GetProperty()
outlineProp.SetColor(colors.GetColor3d('Black'))
# Add the remaining actors to the renderer, set the background and size.
ren.AddActor(outlineActor)
ren.AddActor(wallActor)
ren.AddActor(finActor)
ren.SetBackground(colors.GetColor3d('MistyRose'))
renWin.SetSize(512, 512)
renWin.SetWindowName('TextureThreshold')
cam = vtk.vtkCamera()
cam.SetClippingRange(1.51176, 75.5879)
cam.SetFocalPoint(2.33749, 2.96739, 3.61023)
cam.SetPosition(10.8787, 5.27346, 15.8687)
cam.SetViewAngle(30)
cam.SetViewUp(-0.0610856, 0.987798, -0.143262)
ren.SetActiveCamera(cam)
iren.Initialize()
iren.Start()
def main():
xyzFn, qFn = get_program_parameters()
colors = vtk.vtkNamedColors()
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(xyzFn)
pl3d.SetQFileName(qFn)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
pl3dOutput = pl3d.GetOutput().GetBlock(0)
plane = vtk.vtkStructuredGridGeometryFilter()
plane.SetInputData(pl3dOutput)
plane.SetExtent(1, 100, 1, 100, 7, 7)
lut = vtk.vtkLookupTable()
planeMapper = vtk.vtkPolyDataMapper()
planeMapper.SetLookupTable(lut)
planeMapper.SetInputConnection(plane.GetOutputPort())
planeMapper.SetScalarRange(pl3dOutput.GetScalarRange())
planeActor = vtk.vtkActor()
planeActor.SetMapper(planeMapper)
# This creates an outline around the data.
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3dOutput)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
# Much of the following is commented out. To try different lookup tables,
# uncomment the appropriate portions.
#
# This creates a black to white lut.
# lut.SetHueRange(0, 0)
# lut.SetSaturationRange(0, 0)
# lut.SetValueRange(0.2, 1.0)
# This creates a red to blue lut.
# lut.SetHueRange(0.0, 0.667)
# This creates a blue to red lut.
# lut.SetHueRange(0.667, 0.0)
# This creates a weird effect. The Build() method causes the lookup table
# to allocate memory and create a table based on the correct hue, saturation,
# value, and alpha (transparency) range. Here we then manually overwrite the
# values generated by the Build() method.
lut.SetNumberOfColors(256)
lut.SetHueRange(0.0, 0.667)
lut.Build()
# Create the RenderWindow, Renderer and both Actors.
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size.
#
ren1.AddActor(outlineActor)
ren1.AddActor(planeActor)
ren1.SetBackground(colors.GetColor3d('SlateGray'))
ren1.TwoSidedLightingOff()
renWin.SetSize(512, 512)
renWin.SetWindowName('Rainbow')
iren.Initialize()
cam1 = ren1.GetActiveCamera()
cam1.SetClippingRange(3.95297, 50)
cam1.SetFocalPoint(8.88908, 0.595038, 29.3342)
cam1.SetPosition(-12.3332, 31.7479, 41.2387)
cam1.SetViewUp(0.060772, -0.319905, 0.945498)
iren.Start()
def lazy_vtkMultiBlockPLOT3DReader():
"""Lazy import of the vtkMultiBlockPLOT3DReader."""
return vtk.vtkMultiBlockPLOT3DReader()
def main():
colors = vtk.vtkNamedColors()
fileName1, fileName2 = get_program_parameters()
# Create the pipeline.
#
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(fileName1)
pl3d.SetQFileName(fileName2)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
sg = pl3d.GetOutput().GetBlock(0)
# We create three planes and position them in the correct position
# using transform filters. They are then appended together and used as
# a probe.
plane = vtk.vtkPlaneSource()
plane.SetResolution(50, 50)
transP1 = vtk.vtkTransform()
transP1.Translate(3.7, 0.0, 28.37)
transP1.Scale(5, 5, 5)
transP1.RotateY(90)
tpd1 = vtk.vtkTransformPolyDataFilter()
tpd1.SetInputConnection(plane.GetOutputPort())
tpd1.SetTransform(transP1)
outTpd1 = vtk.vtkOutlineFilter()
outTpd1.SetInputConnection(tpd1.GetOutputPort())
mapTpd1 = vtk.vtkPolyDataMapper()
mapTpd1.SetInputConnection(outTpd1.GetOutputPort())
tpd1Actor = vtk.vtkActor()
tpd1Actor.SetMapper(mapTpd1)
tpd1Actor.GetProperty().SetColor(0, 0, 0)
tpd1Actor.GetProperty().SetLineWidth(2.0)
transP2 = vtk.vtkTransform()
transP2.Translate(9.2, 0.0, 31.20)
transP2.Scale(5, 5, 5)
transP2.RotateY(90)
tpd2 = vtk.vtkTransformPolyDataFilter()
tpd2.SetInputConnection(plane.GetOutputPort())
tpd2.SetTransform(transP2)
outTpd2 = vtk.vtkOutlineFilter()
outTpd2.SetInputConnection(tpd2.GetOutputPort())
mapTpd2 = vtk.vtkPolyDataMapper()
mapTpd2.SetInputConnection(outTpd2.GetOutputPort())
tpd2Actor = vtk.vtkActor()
tpd2Actor.SetMapper(mapTpd2)
tpd2Actor.GetProperty().SetColor(0, 0, 0)
tpd2Actor.GetProperty().SetLineWidth(2.0)
transP3 = vtk.vtkTransform()
transP3.Translate(13.27, 0.0, 33.30)
transP3.Scale(5, 5, 5)
transP3.RotateY(90)
tpd3 = vtk.vtkTransformPolyDataFilter()
tpd3.SetInputConnection(plane.GetOutputPort())
tpd3.SetTransform(transP3)
outTpd3 = vtk.vtkOutlineFilter()
outTpd3.SetInputConnection(tpd3.GetOutputPort())
mapTpd3 = vtk.vtkPolyDataMapper()
mapTpd3.SetInputConnection(outTpd3.GetOutputPort())
tpd3Actor = vtk.vtkActor()
tpd3Actor.SetMapper(mapTpd3)
tpd3Actor.GetProperty().SetColor(0, 0, 0)
tpd3Actor.GetProperty().SetLineWidth(2.0)
appendF = vtk.vtkAppendPolyData()
appendF.AddInputConnection(tpd1.GetOutputPort())
appendF.AddInputConnection(tpd2.GetOutputPort())
appendF.AddInputConnection(tpd3.GetOutputPort())
# The vtkProbeFilter takes two inputs. One is a dataset to use as the probe
# geometry (SetInputConnection) the other is the data to probe
# (SetSourceConnection). The output dataset structure (geometry and
# topology) of the probe is the same as the structure of the input. The
# probing process generates new data values resampled from the source.
probe = vtk.vtkProbeFilter()
probe.SetInputConnection(appendF.GetOutputPort())
probe.SetSourceData(sg)
contour = vtk.vtkContourFilter()
contour.SetInputConnection(probe.GetOutputPort())
contour.GenerateValues(50, sg.GetScalarRange())
contourMapper = vtk.vtkPolyDataMapper()
contourMapper.SetInputConnection(contour.GetOutputPort())
contourMapper.SetScalarRange(sg.GetScalarRange())
planeActor = vtk.vtkActor()
planeActor.SetMapper(contourMapper)
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(sg)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(0, 0, 0)
outlineActor.GetProperty().SetLineWidth(2.0)
# Create the RenderWindow, Renderer and both Actors
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
ren1.AddActor(outlineActor)
ren1.AddActor(planeActor)
ren1.AddActor(tpd1Actor)
ren1.AddActor(tpd2Actor)
ren1.AddActor(tpd3Actor)
ren1.SetBackground(colors.GetColor3d("Gainsboro"))
renWin.SetSize(640, 480)
ren1.ResetCamera()
ren1.GetActiveCamera().SetClippingRange(3.95297, 50)
ren1.GetActiveCamera().SetFocalPoint(8.88908, 0.595038, 29.3342)
ren1.GetActiveCamera().SetPosition(-12.3332, 31.7479, 41.2387)
ren1.GetActiveCamera().SetViewUp(0.060772, -0.319905, 0.945498)
renWin.Render()
iren.Start()
def testAll(self):
# cut data
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin")
pl3d.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin")
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
pl3d_output = pl3d.GetOutput().GetBlock(0)
range = pl3d_output.GetPointData().GetScalars().GetRange()
min = range[0]
max = range[1]
value = (min + max) / 2.0
# cf = vtk.vtkGridSynchronizedTemplates3D()
cf = vtk.vtkContourFilter()
cf.SetInputData(pl3d_output)
cf.SetValue(0, value)
cf.GenerateTrianglesOff()
cf.Update()
self.failUnlessEqual(
cf.GetOutputDataObject(0).GetNumberOfPoints(), 4674)
self.failUnlessEqual(
cf.GetOutputDataObject(0).GetNumberOfCells(), 4012)
cf.GenerateTrianglesOn()
cf.Update()
self.failUnlessEqual(
cf.GetOutputDataObject(0).GetNumberOfPoints(), 4674)
self.failUnlessEqual(
cf.GetOutputDataObject(0).GetNumberOfCells(), 8076)
# cf ComputeNormalsOff
cfMapper = vtk.vtkPolyDataMapper()
cfMapper.SetInputConnection(cf.GetOutputPort())
cfMapper.SetScalarRange(
pl3d_output.GetPointData().GetScalars().GetRange())
cfActor = vtk.vtkActor()
cfActor.SetMapper(cfMapper)
# outline
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3d_output)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(0, 0, 0)
# # Graphics stuff
# Create the RenderWindow, Renderer and both Actors
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
#
ren1.AddActor(outlineActor)
ren1.AddActor(cfActor)
ren1.SetBackground(1, 1, 1)
renWin.SetSize(400, 400)
cam1 = ren1.GetActiveCamera()
cam1.SetClippingRange(3.95297, 50)
cam1.SetFocalPoint(9.71821, 0.458166, 29.3999)
cam1.SetPosition(2.7439, -37.3196, 38.7167)
cam1.SetViewUp(-0.16123, 0.264271, 0.950876)
iren.Initialize()
# render the image
#
# loop over surfaces
i = 0
while i < 17:
cf.SetValue(0, min + (i / 16.0) * (max - min))
renWin.Render()
cf.SetValue(0, min + (0.2) * (max - min))
renWin.Render()
i += 1
#!/usr/bin/env python import os import vtk from vtk.util.misc import vtkGetDataRoot from vtk.util.misc import vtkGetTempDir VTK_DATA_ROOT = vtkGetDataRoot() VTK_TEMP_DIR = vtkGetTempDir() file0 = VTK_TEMP_DIR + '/sgFile0.vts' file1 = VTK_TEMP_DIR + '/sgFile1.vts' file2 = VTK_TEMP_DIR + '/sgFile2.vts' # Create a reader and write out the field combReader = vtk.vtkMultiBlockPLOT3DReader() combReader.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin") combReader.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin") combReader.SetScalarFunctionNumber(100) combReader.Update() output = combReader.GetOutput().GetBlock(0) # extract to reduce extents of grid extract = vtk.vtkExtractGrid() extract.SetInputData(output) extract.SetVOI(0, 28, 0, 32, 0, 24) extract.Update() # write just a piece (extracted piece) as well as the whole thing gridWriter = vtk.vtkXMLStructuredGridWriter() gridWriter.SetFileName(file0)
def __init__(self, data_dir):
# Read the data
xyx_file = os.path.join(data_dir, "combxyz.bin")
q_file = os.path.join(data_dir, "combq.bin")
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(xyx_file)
pl3d.SetQFileName(q_file)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
blocks = pl3d.GetOutput()
b0 = blocks.GetBlock(0)
# Setup VTK environment
renderer = vtk.vtkRenderer()
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
render_window.SetInteractor(interactor)
renderer.SetBackground(0.2, 0.2, 0.2)
interactor.Initialize()
# Draw Outline
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(b0)
outline_mapper = vtk.vtkPolyDataMapper()
outline_mapper.SetInputConnection(outline.GetOutputPort())
outline_actor = vtk.vtkActor()
outline_actor.SetMapper(outline_mapper)
outline_actor.GetProperty().SetColor(1, 1, 1)
renderer.AddActor(outline_actor)
renderer.ResetCamera()
# Draw Outline
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(b0)
outline_mapper = vtk.vtkPolyDataMapper()
outline_mapper.SetInputConnection(outline.GetOutputPort())
outline_actor = vtk.vtkActor()
outline_actor.SetMapper(outline_mapper)
outline_actor.GetProperty().SetColor(1, 1, 1)
renderer.AddActor(outline_actor)
renderer.ResetCamera()
# Threshold points
threshold = vtk.vtkThresholdPoints()
threshold.SetInputData(b0)
threshold.ThresholdByUpper(0.5)
# Draw arrows
arrow = vtk.vtkArrowSource()
glyphs = vtk.vtkGlyph3D()
glyphs.SetInputData(b0)
glyphs.SetSourceConnection(arrow.GetOutputPort())
glyphs.SetInputConnection(threshold.GetOutputPort())
glyphs.SetVectorModeToUseVector()
glyphs.SetScaleModeToScaleByVector()
glyphs.SetScaleFactor(0.005)
glyphs.SetColorModeToColorByVector()
# Mapper
glyph_mapper = vtk.vtkPolyDataMapper()
glyph_mapper.SetInputConnection(glyphs.GetOutputPort())
glyph_actor = vtk.vtkActor()
glyph_actor.SetMapper(glyph_mapper)
glyph_mapper.UseLookupTableScalarRangeOn()
renderer.AddActor(glyph_actor)
# Set color lookuptable
glyphs.Update()
s0, sf = glyphs.GetOutput().GetScalarRange()
lut = vtk.vtkColorTransferFunction()
lut.AddRGBPoint(s0, 1, 0, 0)
lut.AddRGBPoint(sf, 0, 1, 0)
glyph_mapper.SetLookupTable(lut)
self.b0 = b0
self.renderer = renderer
self.interactor = interactor
self.threshold = threshold
def main():
colors = vtk.vtkNamedColors()
# colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0])
xyz_file, q_file = get_program_parameters()
# Read the data.
#
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(xyz_file)
pl3d.SetQFileName(q_file)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
seeds = vtk.vtkPlaneSource()
seeds.SetXResolution(4)
seeds.SetYResolution(4)
seeds.SetOrigin(2, -2, 26)
seeds.SetPoint1(2, 2, 26)
seeds.SetPoint2(2, -2, 32)
streamline = vtk.vtkStreamTracer()
streamline.SetInputData(pl3d.GetOutput().GetBlock(0))
streamline.SetSourceConnection(seeds.GetOutputPort())
streamline.SetMaximumPropagation(200)
streamline.SetInitialIntegrationStep(.2)
streamline.SetIntegrationDirectionToForward()
streamline_mapper = vtk.vtkPolyDataMapper()
streamline_mapper.SetInputConnection(streamline.GetOutputPort())
streamline_actor = vtk.vtkActor()
streamline_actor.SetMapper(streamline_mapper)
streamline_actor.VisibilityOn()
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3d.GetOutput().GetBlock(0))
outline_mapper = vtk.vtkPolyDataMapper()
outline_mapper.SetInputConnection(outline.GetOutputPort())
outline_actor = vtk.vtkActor()
outline_actor.SetMapper(outline_mapper)
outline_actor.GetProperty().SetColor(colors.GetColor3d('White'))
renderer = vtk.vtkRenderer()
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window.SetWindowName('StreamLines')
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
render_window.SetInteractor(interactor)
renderer.AddActor(streamline_actor)
renderer.AddActor(outline_actor)
renderer.SetBackground(colors.GetColor3d('MidnightBlue'))
interactor.Initialize()
render_window.Render()
renderer.GetActiveCamera().SetPosition(-32.8, -12.3, 46.3)
renderer.GetActiveCamera().SetFocalPoint(8.3, 0.03, 29.8)
renderer.GetActiveCamera().SetViewUp(0.2, 0.5, 0.9)
render_window.Render()
interactor.Start()
VTK_DATA_ROOT = vtkGetDataRoot() # we need to use composite data pipeline with multiblock datasets alg = vtk.vtkAlgorithm() pip = vtk.vtkCompositeDataPipeline() alg.SetDefaultExecutivePrototype(pip) #del pip Ren1 = vtk.vtkRenderer() Ren1.SetBackground(0.33, 0.35, 0.43) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(Ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) Plot3D0 = vtk.vtkMultiBlockPLOT3DReader() Plot3D0.SetFileName(VTK_DATA_ROOT + "/Data/combxyz.bin") Plot3D0.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin") Plot3D0.SetBinaryFile(1) Plot3D0.SetMultiGrid(0) Plot3D0.SetHasByteCount(0) Plot3D0.SetIBlanking(0) Plot3D0.SetTwoDimensionalGeometry(0) Plot3D0.SetForceRead(0) Plot3D0.SetByteOrder(0) Plot3D0.Update() output = Plot3D0.GetOutput().GetBlock(0) Geometry5 = vtk.vtkStructuredGridOutlineFilter() Geometry5.SetInputData(output)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
scalarLabels = "Density Pressure Temperature Enthalpy Internal_Energy Kinetic_Energy Velocity_Magnitude Stagnation_Energy Entropy Swirl"
scalarFunctions = "100 110 120 130 140 144 153 163 170 184"
camera = vtk.vtkCamera()
light = vtk.vtkLight()
math = vtk.vtkMath()
# All text actors will share the same text prop
textProp = vtk.vtkTextProperty()
textProp.SetFontSize(10)
textProp.SetFontFamilyToArial()
textProp.SetColor(0, 0, 0)
i = 0
for scalarFunction in scalarFunctions.split():
locals()[get_variable_name("pl3d", scalarFunction,
"")] = vtk.vtkMultiBlockPLOT3DReader()
locals()[get_variable_name("pl3d", scalarFunction,
"")].SetXYZFileName("" + str(VTK_DATA_ROOT) +
"/Data/bluntfinxyz.bin")
locals()[get_variable_name("pl3d", scalarFunction,
"")].SetQFileName("" + str(VTK_DATA_ROOT) +
"/Data/bluntfinq.bin")
locals()[get_variable_name(
"pl3d", scalarFunction, "")].SetScalarFunctionNumber(
expr.expr(globals(), locals(),
["int", "(", "scalarFunction", ")"]))
locals()[get_variable_name("pl3d", scalarFunction, "")].Update()
output = locals()[get_variable_name("pl3d", scalarFunction,
"")].GetOutput().GetBlock(0)
locals()[get_variable_name("plane", scalarFunction,
"")] = vtk.vtkStructuredGridGeometryFilter()
def __init__(self, parent, data_dir):
super(QGlyphViewer,self).__init__(parent)
# Make tha actual QtWidget a child so that it can be re parented
interactor = QVTKRenderWindowInteractor(self)
self.layout = QtGui.QHBoxLayout()
self.layout.addWidget(interactor)
self.layout.setContentsMargins(0,0,0,0)
self.setLayout(self.layout)
# Read the data
xyx_file = os.path.join(data_dir, "combxyz.bin")
q_file = os.path.join(data_dir, "combq.bin")
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(xyx_file)
pl3d.SetQFileName(q_file)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
blocks = pl3d.GetOutput()
b0 = blocks.GetBlock(0)
# Setup VTK environment
renderer = vtk.vtkRenderer()
render_window = interactor.GetRenderWindow()
render_window.AddRenderer(renderer)
interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
render_window.SetInteractor(interactor)
renderer.SetBackground(0.2,0.2,0.2)
# Draw Outline
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(b0)
outline_mapper = vtk.vtkPolyDataMapper()
outline_mapper.SetInputConnection(outline.GetOutputPort())
outline_actor = vtk.vtkActor()
outline_actor.SetMapper(outline_mapper)
outline_actor.GetProperty().SetColor(1,1,1)
renderer.AddActor(outline_actor)
renderer.ResetCamera()
# Draw Outline
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(b0)
outline_mapper = vtk.vtkPolyDataMapper()
outline_mapper.SetInputConnection(outline.GetOutputPort())
outline_actor = vtk.vtkActor()
outline_actor.SetMapper(outline_mapper)
outline_actor.GetProperty().SetColor(1,1,1)
renderer.AddActor(outline_actor)
renderer.ResetCamera()
# Threshold points
threshold = vtk.vtkThresholdPoints()
threshold.SetInputData(b0)
threshold.ThresholdByUpper(0.5)
# Draw arrows
arrow = vtk.vtkArrowSource()
glyphs = vtk.vtkGlyph3D()
glyphs.SetInputData(b0)
glyphs.SetSourceConnection(arrow.GetOutputPort())
glyphs.SetInputConnection(threshold.GetOutputPort())
glyphs.SetVectorModeToUseVector()
glyphs.SetScaleModeToScaleByVector()
glyphs.SetScaleFactor(0.005)
glyphs.SetColorModeToColorByVector()
# Mapper
glyph_mapper = vtk.vtkPolyDataMapper()
glyph_mapper.SetInputConnection(glyphs.GetOutputPort())
glyph_actor = vtk.vtkActor()
glyph_actor.SetMapper(glyph_mapper)
glyph_mapper.UseLookupTableScalarRangeOn()
renderer.AddActor(glyph_actor)
# Set color lookuptable
glyphs.Update()
s0,sf = glyphs.GetOutput().GetScalarRange()
lut = vtk.vtkColorTransferFunction()
lut.AddRGBPoint(s0, 1,0,0)
lut.AddRGBPoint(sf, 0,1,0)
glyph_mapper.SetLookupTable(lut)
self.b0 = b0
self.renderer = renderer
self.interactor = interactor
self.threshold = threshold
def main():
xyzFile, qFile = get_program_parameters()
colors = vtk.vtkNamedColors()
# Create the RenderWindow, Renderer and Interactor.
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Create the pipeline.
#
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(xyzFile)
pl3d.SetQFileName(qFile)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
iso = vtk.vtkContourFilter()
iso.SetInputData(pl3d.GetOutput().GetBlock(0))
iso.SetValue(0, 0.38)
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(iso.GetOutputPort())
normals.SetFeatureAngle(45)
isoMapper = vtk.vtkPolyDataMapper()
isoMapper.SetInputConnection(normals.GetOutputPort())
isoMapper.ScalarVisibilityOff()
isoActor = vtk.vtkActor()
isoActor.SetMapper(isoMapper)
isoActor.GetProperty().SetColor(colors.GetColor3d("bisque"))
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputConnection(pl3d.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
# Add the actors to the renderer, set the background and size.
#
ren1.AddActor(outlineActor)
ren1.AddActor(isoActor)
ren1.SetBackground(colors.GetColor3d("SlateGray"))
renWin.SetSize(640, 480)
ren1.GetActiveCamera().SetFocalPoint(9.71821, 0.458166, 29.3999)
ren1.GetActiveCamera().SetPosition(2.7439, -37.3196, 38.7167)
ren1.GetActiveCamera().SetViewUp(-0.16123, 0.264271, 0.950876)
ren1.ResetCameraClippingRange()
# Render the image.
#
renWin.Render()
iren.Start()
def main():
colors = vtk.vtkNamedColors()
fileName1, fileName2 = get_program_parameters()
# Here we read data from a annular combustor. A combustor burns fuel and air
# in a gas turbine (e.g., a jet engine) and the hot gas eventually makes its
# way to the turbine section.
#
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(fileName1)
pl3d.SetQFileName(fileName2)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
pl3dOutput = pl3d.GetOutput().GetBlock(0)
# Planes are specified using a imin,imax, jmin,jmax, kmin,kmax coordinate
# specification. Min and max i,j,k values are clamped to 0 and maximum value.
#
plane = vtk.vtkStructuredGridGeometryFilter()
plane.SetInputData(pl3dOutput)
plane.SetExtent(10, 10, 1, 100, 1, 100)
plane2 = vtk.vtkStructuredGridGeometryFilter()
plane2.SetInputData(pl3dOutput)
plane2.SetExtent(30, 30, 1, 100, 1, 100)
plane3 = vtk.vtkStructuredGridGeometryFilter()
plane3.SetInputData(pl3dOutput)
plane3.SetExtent(45, 45, 1, 100, 1, 100)
# We use an append filter because that way we can do the warping, etc. just
# using a single pipeline and actor.
#
appendF = vtk.vtkAppendPolyData()
appendF.AddInputConnection(plane.GetOutputPort())
appendF.AddInputConnection(plane2.GetOutputPort())
appendF.AddInputConnection(plane3.GetOutputPort())
warp = vtk.vtkWarpScalar()
warp.SetInputConnection(appendF.GetOutputPort())
warp.UseNormalOn()
warp.SetNormal(1.0, 0.0, 0.0)
warp.SetScaleFactor(2.5)
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(warp.GetOutputPort())
normals.SetFeatureAngle(60)
planeMapper = vtk.vtkPolyDataMapper()
planeMapper.SetInputConnection(normals.GetOutputPort())
planeMapper.SetScalarRange(pl3dOutput.GetScalarRange())
planeActor = vtk.vtkActor()
planeActor.SetMapper(planeMapper)
# The outline provides context for the data and the planes.
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(pl3dOutput)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(colors.GetColor3d('Black'))
# Create the usual graphics stuff.
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
ren1.AddActor(outlineActor)
ren1.AddActor(planeActor)
ren1.SetBackground(colors.GetColor3d('Silver'))
renWin.SetSize(640, 480)
renWin.SetWindowName('WarpCombustor')
# Create an initial view.
ren1.GetActiveCamera().SetClippingRange(3.95297, 50)
ren1.GetActiveCamera().SetFocalPoint(8.88908, 0.595038, 29.3342)
ren1.GetActiveCamera().SetPosition(-12.3332, 31.7479, 41.2387)
ren1.GetActiveCamera().SetViewUp(0.060772, -0.319905, 0.945498)
iren.Initialize()
# Render the image.
#
renWin.Render()
iren.Start()
def main():
xyzFilename, qFilename = get_program_parameters()
colors = vtk.vtkNamedColors()
aren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(aren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
scalarRange = [0.0] * 2
c = [0.0] * 3
maxTime = 0.0
reader = vtk.vtkMultiBlockPLOT3DReader()
reader.SetXYZFileName(xyzFilename)
reader.SetQFileName(qFilename)
reader.Update() # Force a read to occur.
pd = reader.GetOutput().GetBlock(0)
pd.GetCenter(c)
if pd.GetPointData().GetScalars():
pd.GetPointData().GetScalars().GetRange(scalarRange)
if pd.GetPointData().GetVectors():
maxVelocity = pd.GetPointData().GetVectors().GetMaxNorm()
maxTime = 20.0 * pd.GetLength() / maxVelocity
outlineF = vtk.vtkStructuredGridOutlineFilter()
outlineF.SetInputData(pd)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outlineF.GetOutputPort())
outline = vtk.vtkActor()
outline.SetMapper(outlineMapper)
outline.GetProperty().SetColor(colors.GetColor3d('Moccasin'))
outline.GetProperty().SetLineWidth(2.0)
#
# Some geometry for context
#
wall = vtk.vtkStructuredGridGeometryFilter()
wall.SetInputData(pd)
wall.SetExtent(0, 100, 0, 100, 0, 0)
wallMap = vtk.vtkPolyDataMapper()
wallMap.SetInputConnection(wall.GetOutputPort())
wallMap.ScalarVisibilityOff()
wallActor = vtk.vtkActor()
wallActor.SetMapper(wallMap)
wallActor.GetProperty().SetColor(colors.GetColor3d('Silver'))
fin = vtk.vtkStructuredGridGeometryFilter()
fin.SetInputData(pd)
fin.SetExtent(0, 100, 0, 0, 0, 100)
finMap = vtk.vtkPolyDataMapper()
finMap.SetInputConnection(fin.GetOutputPort())
finMap.ScalarVisibilityOff()
finActor = vtk.vtkActor()
finActor.SetMapper(finMap)
finActor.GetProperty().SetColor(colors.GetColor3d('Silver'))
#
# regular streamlines
#
line1 = vtk.vtkLineSource()
line1.SetResolution(25)
line1.SetPoint1(-6.36, 0.25, 0.06)
line1.SetPoint2(-6.36, 0.25, 5.37)
rakeMapper = vtk.vtkPolyDataMapper()
rakeMapper.SetInputConnection(line1.GetOutputPort())
rake1 = vtk.vtkActor()
rake1.SetMapper(rakeMapper)
rake1.GetProperty().SetColor(colors.GetColor3d('Black'))
rake1.GetProperty().SetLineWidth(5)
streamers = vtk.vtkStreamTracer()
# streamers.DebugOn()
streamers.SetInputConnection(reader.GetOutputPort())
streamers.SetSourceConnection(line1.GetOutputPort())
streamers.SetMaximumPropagation(maxTime)
streamers.SetInitialIntegrationStep(0.2)
streamers.SetMinimumIntegrationStep(0.01)
streamers.SetIntegratorType(2)
streamers.Update()
streamersMapper = vtk.vtkPolyDataMapper()
streamersMapper.SetInputConnection(streamers.GetOutputPort())
streamersMapper.SetScalarRange(scalarRange)
lines = vtk.vtkActor()
lines.SetMapper(streamersMapper)
aren.AddActor(outline)
aren.AddActor(wallActor)
aren.AddActor(finActor)
aren.AddActor(rake1)
aren.AddActor(lines)
aren.SetBackground(colors.GetColor3d('Gray'))
aren.ResetCamera()
aren.GetActiveCamera().Elevation(30.0)
aren.GetActiveCamera().Azimuth(30.0)
aren.GetActiveCamera().Dolly(1.2)
aren.ResetCameraClippingRange()
renWin.SetSize(640, 480)
renWin.SetWindowName('BluntStreamlines')
renWin.Render()
# Interact with the data.
iren.Start()
