def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkGenericEnSightReader(), 'Reading vtkGenericEnSight.',
(), ('vtkGenericEnSight',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def create_reader (self):
"Create the corresponding reader."
debug ("In VtkEnSightReader::create_reader ()")
# set up the reader
if self.file_name == "":
raise IOError, "No filename specifed for the data handler!"
self.reader = vtk.vtkGenericEnSightReader()
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 readData(self, ntime = -1.):
"""
Return the mesh vtkDataSet with the associated scalars for a single time step.
"""
p = os.path.abspath(self.opt.f_name)
path, case = os.path.dirname(p), os.path.basename(p)
ens = vtk.vtkGenericEnSightReader()
ens.SetByteOrderToLittleEndian()
ens.SetFilePath(path)
ens.SetCaseFileName(case)
ens.ReadAllVariablesOn()
ens.Update()
times = ens.GetTimeSets().GetItem(0)
# last result by default
if ntime == -1.:
ntime = times.GetSize() - 1
ens.SetTimeValue(times.GetTuple1(ntime))
ens.Update()
return ens.GetOutput().GetBlock(0) # Now multiblock objet with 0 for volume, 1 for bord !
def readEnsightFile(self, fileName):
"""
Read Ensight file. Writes a VTK file with fileName+'.vtk'.
:param str filename: Input filename
"""
#read the ensight file
reader = vtk.vtkGenericEnSightReader()
reader.SetCaseFileName(fileName)
reader.Update()
output = reader.GetOutput()
num_blocks = output.GetNumberOfBlocks()
#blocks_unstructured is a list of objects of vtkUnstructuredGrid
blocks_unstructured = []
for i in range(num_blocks):
blocks_unstructured.append(output.GetBlock(i))
appendFilter = vtk.vtkAppendFilter()
i = 0
while i < len(blocks_unstructured):
if(vtk.VTK_MAJOR_VERSION <= 5):
appendFilter.AddInput(blocks_unstructured[i])
else:
appendFilter.AddInputData(blocks_unstructured[i])
i=i+1
appendFilter.Update();
unstructuredGrid=vtk.vtkUnstructuredGrid()
unstructuredGrid.ShallowCopy(appendFilter.GetOutput());
w = vtk.vtkUnstructuredGridWriter()
if(vtk.VTK_MAJOR_VERSION <= 5):
w.SetInput(unstructuredGrid)
else:
w.SetInputData(unstructuredGrid)
w.SetFileName(fileName+'.vtk')
w.Write()
self.readVtkFile(fileName+'.vtk')
def readEnsightFile(self, fileName):
"""
Read Ensight file. Writes a VTK file with fileName+'.vtk'.
:param str filename: Input filename
"""
#read the ensight file
reader = vtk.vtkGenericEnSightReader()
reader.SetCaseFileName(fileName)
reader.Update()
output = reader.GetOutput()
num_blocks = output.GetNumberOfBlocks()
#blocks_unstructured is a list of objects of vtkUnstructuredGrid
blocks_unstructured = []
for i in range(num_blocks):
blocks_unstructured.append(output.GetBlock(i))
appendFilter = vtk.vtkAppendFilter()
i = 0
while i < len(blocks_unstructured):
if (vtk.VTK_MAJOR_VERSION <= 5):
appendFilter.AddInput(blocks_unstructured[i])
else:
appendFilter.AddInputData(blocks_unstructured[i])
i = i + 1
appendFilter.Update()
unstructuredGrid = vtk.vtkUnstructuredGrid()
unstructuredGrid.ShallowCopy(appendFilter.GetOutput())
w = vtk.vtkUnstructuredGridWriter()
if (vtk.VTK_MAJOR_VERSION <= 5):
w.SetInput(unstructuredGrid)
else:
w.SetInputData(unstructuredGrid)
w.SetFileName(fileName + '.vtk')
w.Write()
self.readVtkFile(fileName + '.vtk')
#!/usr/bin/env python
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()
#!/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 load_loop_integrate(params, writer, itestep):
# Test if file is present
assert (os.path.exists(params.path))
print('read file %s' % params.path)
headwrite = True
# Load info with vtk
reader = vtk.vtkGenericEnSightReader()
reader.SetCaseFileName(params.path)
reader.Update()
timeset = reader.GetTimeSets()
time = timeset.GetItem(0)
if time is not None:
timesteps = time.GetSize()
else:
timesteps = 1
print 'Number of Time steps found: ', timesteps
# Flow block data is stored as an unstructured grid
# Convert block data to structured grid by querying at regular points
points = vtk.vtkPoints()
polydata = vtk.vtkPolyData()
create_case_grid(points)
polydata.SetPoints(points)
snapList = {}
for tstep in range(0, timesteps, itestep):
if time is not None:
curTime = time.GetTuple(tstep)[0]
print 'Processing time: ', curTime
else:
curTime = 0
# Setting time to current value
reader.SetTimeValue(curTime)
reader.Update()
#Get cell data
vtk_data = reader.GetOutput()
#Block 0 is flow, block 1 is particles
block_data_flow = vtk_data.GetBlock(0)
block_data_part = vtk_data.GetBlock(1)
point_data_flow = block_data_flow.GetCellData()
point_data_part = block_data_part.GetPointData()
# Set probe
probe = vtk.vtkProbeFilter()
probe.SetInputData(polydata)
probe.SetSourceData(block_data_flow)
probe.Update()
result = probe.GetOutput()
arr_data = {}
# Get all scalars by probing
for array_idx in range(point_data_flow.GetNumberOfArrays()):
array_name = point_data_flow.GetArrayName(array_idx)
arr_data[array_name] = numpy_support.vtk_to_numpy(
result.GetPointData().GetArray(array_name))
# Reshape data
if (array_name == "V"):
arr_data[array_name] = arr_data[array_name].reshape(
[48, 96, 32, 3])
else:
arr_data[array_name] = arr_data[array_name].reshape(
[48, 96, 32])
print "Read gas!"
# Loop over all arrays to find the variables of interest
# For particles, get directly from Ensight
for array_idx in range(point_data_part.GetNumberOfArrays()):
array_name = point_data_part.GetArrayName(array_idx)
arr_data[array_name] = \
numpy_support.vtk_to_numpy(point_data_part.GetArray(array_idx))
print "Read particles!"
if (params.statistics_type == 'integrals'):
# Need to pass return as argument, because it is appended in each pass
integrals = compute_integrals(arr_data)
write_data(curTime, integrals, writer, tstep == 0)
elif (params.statistics_type == 'wall_normal'):
snapList[tstep] = compute_wall_normal_stats(arr_data)
np.save("snapList.npy", snapList)
print "Saved statistics"
def __init__(self):
cdp = vtk.vtkCompositeDataPipeline()
#self.eg = vtk.vtkEnSightGoldReader()
self.eg = vtk.vtkGenericEnSightReader()
self.eg.SetDefaultExecutivePrototype(cdp)
def __init__(self):
self.reader = vtk.vtkGenericEnSightReader(
) # vtk.vtkEnSightGoldReader()
