def __ensight_reader__(filename, reader):
filename, fileExtension = os.path.splitext(filename)
print "[ensight_reader] <- \'%s\'" % (filename)
cdp = vtk.vtkCompositeDataPipeline()
eg = vtk.vtkGenericEnSightReader() # vtk.vtkEnSightGoldReader()
eg.SetDefaultExecutivePrototype(cdp)
eg.SetCaseFileName(filename)
eg.ReadAllVariablesOn()
eg.Update()
reader = eg
def init(self, filename=""):
self.filename, self.fileExtension = os.path.splitext(filename)
print "[Vtk_ensight_reader] <- \'%s\'" % (filename)
cdp = vtk.vtkCompositeDataPipeline()
self.eg = self.reader
self.eg.SetDefaultExecutivePrototype(cdp)
self.eg.SetCaseFileName(filename)
self.eg.ReadAllVariablesOn()
self.eg.Update()
self.Obj = self.eg.GetOutput()
__times__(self.eg)
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# read data
#
reader = vtk.vtkGenericEnSightReader()
# Make sure all algorithms use the composite data pipeline
cdp = vtk.vtkCompositeDataPipeline()
reader.SetDefaultExecutivePrototype(cdp)
reader.SetCaseFileName("" + str(VTK_DATA_ROOT) +
"/Data/EnSight/office_bin.case")
reader.Update()
# to add coverage for vtkOnePieceExtentTranslator
translator = vtk.vtkOnePieceExtentTranslator()
#[reader GetOutput] SetExtentTranslator translator
OutInfo = reader.GetOutputInformation(0)
sddp = vtk.vtkStreamingDemandDrivenPipeline()
sddp.SetExtentTranslator(OutInfo, translator)
outline = vtk.vtkStructuredGridOutlineFilter()
# outline SetInputConnection [reader GetOutputPort]
outline.SetInputData(reader.GetOutput().GetBlock(0))
mapOutline = vtk.vtkPolyDataMapper()
mapOutline.SetInputConnection(outline.GetOutputPort())
#!/usr/bin/env python
import vtk
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# create a rendering window and renderer
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
renWin.StereoCapableWindowOn()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
reader = vtk.vtkGenericEnSightReader()
# Make sure all algorithms use the composite data pipeline
cdp = vtk.vtkCompositeDataPipeline()
reader.SetDefaultExecutivePrototype(cdp)
reader.SetCaseFileName("" + str(VTK_DATA_ROOT) + "/Data/EnSight/blow2_bin.case")
reader.SetTimeValue(1)
geom = vtk.vtkGeometryFilter()
geom.SetInputConnection(reader.GetOutputPort())
mapper = vtk.vtkHierarchicalPolyDataMapper()
mapper.SetInputConnection(geom.GetOutputPort())
mapper.SetColorModeToMapScalars()
mapper.SetScalarModeToUsePointFieldData()
mapper.ColorByArrayComponent("displacement",0)
mapper.SetScalarRange(0,2.08)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# assign our actor to the renderer
ren1.AddActor(actor)
# enable user interface interactor
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 TestTemporalCacheTemporalExecuteCallback(obj, ev):
# count the number of timesteps requested
info = obj.GetExecutive().GetOutputInformation(0)
Length = {
True: 1,
False: 0
}[info.Has(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_TIME_STEP())]
TestTemporalCacheTemporalExecuteCallback.Count += Length
TestTemporalCacheTemporalExecuteCallback.Count = 0
# Use a composite pipeline
prototype = vtk.vtkCompositeDataPipeline()
vtk.vtkAlgorithm.SetDefaultExecutivePrototype(prototype)
fractal = vtk.vtkTemporalFractal()
fractal.SetMaximumLevel(2)
fractal.DiscreteTimeStepsOn()
fractal.GenerateRectilinearGridsOn()
fractal.SetAdaptiveSubdivision(0)
fractal.AddObserver(vtk.vtkCommand.StartEvent,
TestTemporalCacheTemporalExecuteCallback)
# cache the data to prevent regenerating some of it
cache = vtk.vtkTemporalDataSetCache()
cache.SetInputConnection(fractal.GetOutputPort())
cache.SetCacheSize(2)
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 __init__(self):
cdp = vtk.vtkCompositeDataPipeline()
#self.eg = vtk.vtkEnSightGoldReader()
self.eg = vtk.vtkGenericEnSightReader()
self.eg.SetDefaultExecutivePrototype(cdp)
def getMeshPicture(
meshFile,
pictureFile,
cameraArgs={
"camPosition": None,
"viewAngle": 30,
"scale": 1.0,
"targetPosition": None,
"viewUp": [0, 0, 1],
"fitView": True
},
timeList=[0],
startInteractive=False,
mag=4,
parallel="auto",
fsArgs={
"scale": (1, 1, 1),
"fsRange": None
},
y0Args={
"scalarField": "alpha.water",
"scalarRange": [0, 1]
},
structArgs={
"scalarField": "p_rgh",
},
sliceArgsList=[],
hullPatch="ship",
):
"""
Function to generate picture out of openFoam results
meshFile : mesh file or case directory
"""
from tqdm import tqdm
#c = Chrono(start=True)
baseFile, ext = os.path.splitext(pictureFile)[0:2]
Writer = writerFromExt(ext)
pathPic = os.path.abspath(os.path.dirname(pictureFile))
if not os.path.exists(pathPic):
os.makedirs(pathPic)
# Add a file name to the path. "p.foam" does not need to be created
if os.path.isdir(meshFile):
caseDir = meshFile
meshFile = os.path.join(caseDir, "p.foam")
else:
caseDir = os.path.dirname(meshFile)
# Automatically choose "SetCaseType" ( parallel vs (serial/notRun))
if parallel == "auto":
if os.path.exists(os.path.join(caseDir, "processor0")):
parallel = True
else:
parallel = False
if type(timeList) == str:
if timeList == "all":
timeList = getAvailableTimeData(caseDir, parallel)
elif timeList == "latest":
timeList = [getAvailableTimeData(caseDir, parallel)[-1]]
elif timeList == "latest-1":
timeList = [getAvailableTimeData(caseDir, parallel)[-2]]
else:
raise (Exception(
"time should be 'latest', 'all', or a float iterable"))
print("Generating picture for : ", ["{:.2f}".format(i) for i in timeList])
#--- Read the openFoam file
vtk_r = vtk.vtkPOpenFOAMReader()
vtk_r.SetFileName(meshFile)
if parallel:
vtk_r.SetCaseType(0)
print("Using decomposed case")
else:
vtk_r.SetCaseType(1) # 0 = decomposed case, 1 = reconstructed case
print("Using reconstructed case")
#vtk_r.ReadZonesOn()
cdp = vtk.vtkCompositeDataPipeline()
vtk_r.SetDefaultExecutivePrototype(cdp)
vtk_r.SetDecomposePolyhedra(0)
vtk_r.CreateCellToPointOn()
vtk_r.DisableAllPatchArrays()
vtk_r.SetPatchArrayStatus("internalMesh", 1)
vtk_r.SetPatchArrayStatus(hullPatch, 1)
vtk_r.SetPatchArrayStatus("domainY0", 1)
vtk_r.SetTimeValue(timeList[0])
print("Read first")
vtk_r.Update() # not mandatory, but just postpone the waiting time
print("Read done")
iter = vtk_r.GetOutput().NewIterator()
blockDict = {}
while not iter.IsDoneWithTraversal():
blockDict[iter.GetCurrentMetaData().Get(
vtk.vtkCompositeDataSet.NAME())] = iter.GetCurrentFlatIndex()
iter.GoToNextItem()
print(blockDict)
#--- Renderer
renderer = vtk.vtkRenderer()
#--------------------------------- Free-surface (ISO alpha = 0.5)
if fsArgs is not None:
fsActor, scalarBar = getFreeSurfaceActor(vtk_r, **fsArgs)
renderer.AddActor(fsActor) # Add the mesh to the view
renderer.AddActor(scalarBar)
#--------------------------------- Ship surface
if structArgs is not None:
structureActor = getStuctureActor(vtk_r,
blockIndex=blockDict[hullPatch],
**structArgs)
renderer.AddActor(structureActor) # Add the mesh to the view
#------------------------------ Symmetry plane
if y0Args is not None:
symActor = getSymPlaneVtkActor(vtk_r,
blockIndex=blockDict["domainY0"],
**y0Args)
renderer.AddActor(symActor) # Add the mesh to the view
#------------------------------ Slices
for cutArgs in sliceArgsList:
sActor = getCutActor(vtk_r, **cutArgs)
renderer.AddActor(sActor) # Add the mesh to the view
renderer.SetBackground(1, 1, 1) # White background
#--- Rendering windows
renWin = vtk.vtkRenderWindow()
# Avoid displaying interactive window
if not startInteractive:
renWin.SetOffScreenRendering(1)
renWin.AddRenderer(renderer)
renWin.SetSize(1650, 1050)
# Set view point
setCamera(renderer, **cameraArgs)
# To get interactive windows
if startInteractive:
vtk_r.UpdateTimeStep(timeList[0])
vtk_r.Modified()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
iren.Start()
else:
for itime, time in tqdm(enumerate(timeList)):
#exe.SetUpdateTimeStep( 0, time )
#vtk_r.SetTimeValue( time )
# vtk_r.Update()
vtk_r.UpdateTimeStep(time)
vtk_r.Modified() # Require to update the time step data
renWin.Render()
w2if = vtk.vtkRenderLargeImage()
w2if.SetMagnification(mag) # => Resoulition of the picture
w2if.SetInput(renderer)
w2if.Update()
pictureFile = "{:}_{:03}{:}".format(baseFile, itime, ext)
writer = Writer()
writer.SetFileName(pictureFile)
writer.SetInputConnection(w2if.GetOutputPort())
writer.Write()
