def Creating_z(Plane,Slope,Sediment,Start_time,End_time,Time_step):
vtuObject = vtktools.vtu(Plane)
vtuObject.GetFieldNames()
gradient = vtuObject.GetScalarField('u')
ugrid = vtk.vtkUnstructuredGrid()
gridreader=vtk.vtkXMLUnstructuredGridReader()
gridreader.SetFileName(Plane)
gridreader.Update()
ugrid = gridreader.GetOutput()
points = ugrid.GetPoints()
nPoints = ugrid.GetNumberOfPoints()
for p in range(0,nPoints):
x = (points.GetPoint(p)[:2] + (gradient[p],))
points.SetPoint(p,x)
ugrid.Update()
###################################################################################################################
t = Start_time
dt = Time_step
et = End_time
while t <= et:
Import = Sediment + str(t) +'000000.vtu'
NewSave = Sediment + str(t) + '_sed_slope.pvd'
vtuObjectSed = vtktools.vtu(Import)
vtuObjectSed.GetFieldNames()
gradientSed = vtuObjectSed.GetScalarField('u')
sedgrid = vtk.vtkUnstructuredGrid()
sedgridreader=vtk.vtkXMLUnstructuredGridReader()
sedgridreader.SetFileName(Import)
sedgridreader.Update()
sedgrid = sedgridreader.GetOutput()
s = sedgrid.GetPoints()
for p in range(0,nPoints):
x = ((s.GetPoint(p)[0],) + (s.GetPoint(p)[1],) + ((gradientSed[p]+gradient[p]),))
s.SetPoint(p,x)
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileName(NewSave)
writer.SetInput(sedgrid)
writer.Update()
writer.Write()
t += dt
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileName(Slope)
writer.SetInput(ugrid)
writer.Update()
writer.Write()
def _get_writer(filetype, filename):
import vtk
if filetype in "vtk-ascii":
logging.warning("VTK ASCII files are only meant for debugging.")
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToASCII()
elif filetype == "vtk-binary":
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToBinary()
elif filetype == "vtu-ascii":
logging.warning("VTU ASCII files are only meant for debugging.")
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetDataModeToAscii()
elif filetype == "vtu-binary":
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetDataModeToBinary()
elif filetype == "xdmf2":
writer = vtk.vtkXdmfWriter()
elif filetype == "xdmf3":
writer = vtk.vtkXdmf3Writer()
else:
assert filetype == "exodus", "Unknown file type '{}'.".format(filename)
writer = vtk.vtkExodusIIWriter()
# if the mesh contains vtkmodeldata information, make use of it
# and write out all time steps.
writer.WriteAllTimeStepsOn()
return writer
def WriteVTKMeshFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing VTK mesh file.')
writer = vtk.vtkUnstructuredGridWriter()
writer.SetInput(self.Mesh)
writer.SetFileName(self.OutputFileName)
writer.Write()
def write_to_vtk(self):
"""
Write the grid data into vtk files.
call signature:
write_to_vtk(self)
"""
import vtk
if (self.ti >= 0) and (self.tf >= 0):
for tidx in range(self.ti, self.tf):
destination = '{0}{1}.vtk'.format(self.destination, tidx)
writer = vtk.vtkUnstructuredGridWriter()
if self.binary:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
writer.SetFileName(destination)
# Insure compatability between vtk 5 and 6.
try:
writer.SetInputData(self.vtk_grid_data[tidx-self.ti])
except:
writer.SetInput(self.vtk_grid_data[tidx-self.ti])
writer.Write()
else:
writer = vtk.vtkUnstructuredGridWriter()
if self.binary:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
writer.SetFileName(self.destination)
# Insure compatability between vtk 5 and 6.
try:
writer.SetInputData(self.vtk_grid_data[0])
except:
writer.SetInput(self.vtk_grid_data[0])
writer.Write()
def write_field(num_points,num_components,grid,field,filename):
u_temp = np.array(np.zeros((num_points,3), dtype=np.float64))
for k in range(0,num_components):
u_temp[:,k] = field[k*num_points:(k+1)*num_points]
u_vtk = VN.numpy_to_vtk(u_temp)
u_vtk.SetName('u')
grid.GetPointData().AddArray(u_vtk)
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToBinary()
writer.SetInput(grid)
writer.SetFileName(filename)
writer.Write()
def WriteVTKMeshFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing VTK mesh file.')
writer = vtk.vtkUnstructuredGridWriter()
writer.SetInput(self.Mesh)
writer.SetFileName(self.OutputFileName)
if self.Mode == "binary":
writer.SetFileTypeToBinary()
elif self.Mode == "ascii":
writer.SetFileTypeToASCII()
writer.Write()
def write_vtk(self, data_dir='./data', file_name='separatrices.vtk',
binary=False):
"""
Write the separatrices into a vtk file.
call signature:
write_vtk(data_dir='./data', file_name='separatrices.vtk',
binary=False)
Arguments:
*data_dir*:
Target data directory.
*file_name*:
Target file name.
*binary*:
Write file in binary or ASCII format.
"""
writer = vtk.vtkUnstructuredGridWriter()
if binary:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
writer.SetFileName(os.path.join(data_dir, file_name))
grid_data = vtk.vtkUnstructuredGrid()
points = vtk.vtkPoints()
cell_array = vtk.vtkCellArray()
# for idx in range(len(self.separatrices)):
for point_idx in range(len(self.separatrices)):
points.InsertNextPoint(self.separatrices[point_idx, :])
for cell_idx in range(len(self.connectivity)):
cell_array.InsertNextCell(2)
cell_array.InsertCellPoint(self.connectivity[cell_idx, 0])
cell_array.InsertCellPoint(self.connectivity[cell_idx, 1])
grid_data.SetPoints(points)
grid_data.SetCells(vtk.VTK_LINE, cell_array)
# Insure compatability between vtk 5 and 6.
try:
writer.SetInputData(grid_data)
except:
writer.SetInput(grid_data)
writer.Write()
def chooseWriter(self, file_format, vtk_dataset_type):
"""
Return a writer based on file_format and possibly vtk_dataset_type.
@param vtk_dataset_type, None or one of the VTK_DATASET_TYPES
"""
if file_format == 'ply':
return vtk.vtkPLYWriter()
# For now we'll just return the POLYDATA writer since methods work
# only with that vtk_dataset_type.
return vtk.vtkPolyDataWriter()
if vtk_dataset_type == 'STRUCTURED_GRID':
return vtk.vtkStructuredGridWriter()
elif vtk_dataset_type == 'POLYDATA':
return vtk.vtkPolyDataWriter()
elif vtk_dataset_type == 'UNSTRUCTURED_GRID':
return vtk.vtkUnstructuredGridWriter()
def write_spatial_DMD_modes(num_modes_to_write,num_points,num_components,grid,spatial_modes_trunc,vr,vl,mode_index):
print ' Writing spatial DMD modes to'
spatial_modes_DMD = np.array(np.zeros((num_components*num_points), dtype=np.complex64))
spatial_modes_DMD_adjoint = np.array(np.zeros((num_components*num_points), dtype=np.complex64))
u_temp = np.array(np.zeros((num_points,3), dtype=np.float64))
u_temp_imag = np.array(np.zeros((num_points,3), dtype=np.float64))
u_temp_adjoint_real = np.array(np.zeros((num_points,3), dtype=np.float64))
u_temp_adjoint_imag = np.array(np.zeros((num_points,3), dtype=np.float64))
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToBinary()
for k in range(0,num_modes_to_write):
k_index = k+1
filename = './results/DMD.spatial_deterministic_mode_' + '%04d'%k_index + '.vtk'
print ' ', filename
spatial_modes_DMD = np.dot(spatial_modes_trunc, vr[:,mode_index[k]])
#spatial_modes_DMD_adjoint = np.dot(spatial_modes_trunc_w, vl[:,mode_index[k]])
spatial_modes_DMD_adjoint = np.dot(spatial_modes_trunc, vl[:,mode_index[k]])
for i in range(0,num_components):
u_temp[:,i] = spatial_modes_DMD[i*num_points:(i+1)*num_points].real
u_temp_imag[:,i] = spatial_modes_DMD[i*num_points:(i+1)*num_points].imag
u_temp_adjoint_real[:,i] = spatial_modes_DMD_adjoint[i*num_points:(i+1)*num_points].real
u_temp_adjoint_imag[:,i] = spatial_modes_DMD_adjoint[i*num_points:(i+1)*num_points].imag
u_vtk = VN.numpy_to_vtk(u_temp)
u_vtk.SetName('u')
grid.GetPointData().AddArray(u_vtk)
u_imag_vtk = VN.numpy_to_vtk(u_temp_imag)
u_imag_vtk.SetName('u_imag')
grid.GetPointData().AddArray(u_imag_vtk)
u_adjoint_real_vtk = VN.numpy_to_vtk(u_temp_adjoint_real)
u_adjoint_real_vtk.SetName('u_adjoint_real')
grid.GetPointData().AddArray(u_adjoint_real_vtk)
u_adjoint_imag_vtk = VN.numpy_to_vtk(u_temp_adjoint_imag)
u_adjoint_imag_vtk.SetName('u_adjoint_imag')
grid.GetPointData().AddArray(u_adjoint_imag_vtk)
writer.SetFileName(filename)
writer.SetInput(grid)
writer.Write()
def writeUGrid(
ugrid,
filename,
verbose=1):
myVTK.myPrint(verbose, "*** writeUGrid: " + filename + " ***")
if ('vtk' in filename):
ugrid_writer = vtk.vtkUnstructuredGridWriter()
elif ('vtu' in filename):
ugrid_writer = vtk.vtkXMLUnstructuredGridWriter()
else:
assert 0, "File must be .vtk or .vtu. Aborting."
ugrid_writer.SetFileName(filename)
ugrid_writer.SetInputData(ugrid)
ugrid_writer.Update()
ugrid_writer.Write()
def makeVTKWellsUsingModule(fname_base, welltracks_df, xml=False):
numpoints = welltracks_df.shape[0]
wells = welltracks_df['Well'].unique().tolist()
numwells = len(wells)
grid = vtkUnstructuredGrid()
points = vtkPoints()
for i in range(numpoints):
points.InsertNextPoint(welltracks_df.loc[i,'X'], welltracks_df.loc[i,'Y'], welltracks_df.loc[i,'Elev_mASL'])
cells = vtkCellArray()
wellname = vtkStringArray()
wellname.SetName('Well')
for well in wells:
print well
polyline = vtkPolyLine()
indices = welltracks_df[welltracks_df['Well']==well].index.tolist()
for i, j in enumerate(indices):
polyline.GetPointIds().SetNumberOfIds(len(indices))
polyline.GetPointIds().SetId(i,j)
cells.InsertNextCell(polyline)
wellname.InsertNextValue(well)
grid.SetPoints(points)
grid.SetCells(VTK_POLY_LINE, cells)
grid.GetCellData().AddArray(wellname)
if xml:
writer = vtkXMLUnstructuredGridWriter()
writer.SetFileName('{}.vtu'.format(fname_base))
writer.SetDataModeToAscii()
writer.SetInputData(grid)
writer.Write()
else:
writer = vtkUnstructuredGridWriter()
writer.SetFileName('{}.vtk'.format(fname_base))
writer.SetInputData(grid)
writer.Write()
def getWriter(self,polyData):
writer = None;
if self.destFormat == "vti":
writer = vtk.vtkXMLImageDataWriter();
writer.SetFileName(self.dest);
elif self.destFormat in ("mha","mhd","raw"):
writer = vtk.vtkMetaImageWriter();
writer.SetFilePrefix(self.dest);
writer.SetFileName(self.dest);
elif self.destFormat == "mnc":
writer = vtk.vtkMINCImageWriter();
writer.SetFileName(self.dest);
writer.StrictValidationOff();
elif self.destFormat == "vtk":
writer = vtk.vtkUnstructuredGridWriter();
writer.SetFileName(self.dest);
writer.SetInputData(polyData);
writer.Update();
return writer;
def WriteVtkFile(self, filename):
'''
@param filename: str
@rtype: None
'''
if not self.getDataSet():
raise ValueError, "No DataSet to write"
c_mesh = vtk.vtkUnstructuredGrid.SafeDownCast(self.getDataSet())
if not c_mesh:
raise ValueError, "DataSet is not a polydata object"
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileName(filename)
try:
writer.SetInput(c_mesh)
writer.Write()
# del writer
except Exception, e:
# del writer
print e
def writeUGrid(
ugrid,
filename,
verbose=0):
mypy.my_print(verbose, "*** writeUGrid: "+filename+" ***")
if ('vtk' in filename):
ugrid_writer = vtk.vtkUnstructuredGridWriter()
elif ('vtu' in filename):
ugrid_writer = vtk.vtkXMLUnstructuredGridWriter()
else:
assert 0, "File must be .vtk or .vtu. Aborting."
ugrid_writer.SetFileName(filename)
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
ugrid_writer.SetInputData(ugrid)
else:
ugrid_writer.SetInput(ugrid)
ugrid_writer.Update()
ugrid_writer.Write()
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 main(argv):
if len(argv) < 2:
print "usage: ",argv[0]," <file.pts> <file.data> <outfile.vtk> [flat]"
exit(1)
pts_fn = argv[1]
data_fn = argv[2]
out_fn = argv[3]
flat = False
if len(argv) > 4:
flat = True
pts = csv.reader(open(pts_fn,"r"), delimiter='\n')
data = csv.reader(open(data_fn,"r"), delimiter='\n')
points = vtk.vtkPoints()
values = vtk.vtkDoubleArray()
values.SetNumberOfComponents(1)
#grid = vtk.vtkUnstructuredGrid()
grid = vtk.vtkPolyData()
for p,d in zip(pts,data):
p = p[0]
data = float(d[0])
parts = p.split(' ')
point = []
for pp in parts:
if len(pp) > 0:
point.append(float(pp))
if flat:
point[2] = 0.0
else:
point[2] = data
points.InsertNextPoint( point )
values.InsertNextValue( data )
grid.SetPoints(points)
grid.GetPointData().SetScalars(values)
w = vtk.vtkUnstructuredGridWriter()
w = vtk.vtkPolyDataWriter()
w.SetFileName(out_fn)
w.SetInput(grid)
w.Update()
def write_spatial_stochastic_modes(num_modes_to_write,num_points,num_components,grid,spatial_modes_trunc,noise_evector):
print ' Writing spatial stochastic modes to'
spatial_modes = np.array(np.zeros((num_components*num_points), dtype=np.float64))
u_temp = np.array(np.zeros((num_points,3), dtype=np.float64))
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToBinary()
for k in range(0,num_modes_to_write):
k_index = k+1
filename = './results/DMD.spatial_stochastic_mode_' + '%04d'%k_index + '.vtk'
print ' ', filename
spatial_modes = np.dot(spatial_modes_trunc, noise_evector[:,k])
for i in range(0,num_components):
u_temp[:,i] = spatial_modes[i*num_points:(i+1)*num_points]
u_vtk = VN.numpy_to_vtk(u_temp)
u_vtk.SetName('u')
grid.GetPointData().AddArray(u_vtk)
writer.SetFileName(filename)
writer.SetInput(grid)
writer.Write()
print('-' * 80)
diags['srcBegPts'].append(srcPointBeg)
diags['srcEndPts'].append(srcPointEnd)
diags['srcXpts'].append(srcPointBeg + lams[1] *
(srcPointEnd - srcPointBeg))
diags['dstBegPts'].append(dstPointBeg)
diags['dstEndPts'].append(dstPointEnd)
diags['dstXpts'].append(dstPointBeg + lams[0] *
(dstPointEnd - dstPointBeg))
# create unstructured grid with not overlapping edges
fd = vtk.vtkDoubleArray()
pa = vtk.vtkDoubleArray()
pt = vtk.vtkPoints()
ug = vtk.vtkUnstructuredGrid()
wr = vtk.vtkUnstructuredGridWriter()
fd.SetNumberOfComponents(1)
fd.SetNumberOfTuples(numBadOverlaps * 2)
fd.SetName('index')
pa.SetNumberOfComponents(3)
pa.SetNumberOfTuples(numBadOverlaps * 4)
fd2 = vtk.vtkDoubleArray()
pa2 = vtk.vtkDoubleArray()
pt2 = vtk.vtkPoints()
ug2 = vtk.vtkUnstructuredGrid()
wr2 = vtk.vtkUnstructuredGridWriter()
fd2.SetNumberOfComponents(1)
fd2.SetNumberOfTuples(numBadOverlaps * 2)
def write_vtk(ugrid, filename):
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileName(filename)
writer.SetInputData(ugrid)
writer.Write()
dir = "."
if (info.commands(globals(), locals(), "rtTester") == "rtTester"):
dir = rtTester.GetTempDirectory()
pass
for cell in "aVoxel aHexahedron aWedge aPyramid aTetra aQuad aTriangle aTriangleStrip aLine aPolyLine aVertex aPolyVertex aPixel aPolygon aPenta aHexa".split():
locals()[get_variable_name("", cell, "derivs")] = vtk.vtkCellDerivatives()
locals()[get_variable_name("", cell, "derivs")].SetInputData(locals()[get_variable_name("", cell, "Grid")])
locals()[get_variable_name("", cell, "derivs")].SetVectorModeToComputeGradient()
FileName = dir
FileName += cell
FileName += ".vtk"
# make sure the directory is writeable first
if (catch.catch(globals(),"""channel = open("" + str(dir) + "/test.tmp", "w")""") == 0):
channel.close()
file.delete("-force", "" + str(dir) + "/test.tmp")
locals()[get_variable_name("", cell, "Writer")] = vtk.vtkUnstructuredGridWriter()
locals()[get_variable_name("", cell, "Writer")].SetInputConnection(locals()[get_variable_name("", cell, "derivs")].GetOutputPort())
locals()[get_variable_name("", cell, "Writer")].SetFileName(FileName)
locals()[get_variable_name("", cell, "Writer")].Write()
# delete the file
file.delete("-force", FileName)
pass
locals()[get_variable_name("", cell, "Centers")] = vtk.vtkCellCenters()
locals()[get_variable_name("", cell, "Centers")].SetInputConnection(locals()[get_variable_name("", cell, "derivs")].GetOutputPort())
locals()[get_variable_name("", cell, "Centers")].VertexCellsOn()
locals()[get_variable_name("", cell, "hog")] = vtk.vtkHedgeHog()
locals()[get_variable_name("", cell, "hog")].SetInputConnection(locals()[get_variable_name("", cell, "Centers")].GetOutputPort())
locals()[get_variable_name("", cell, "mapHog")] = vtk.vtkPolyDataMapper()
locals()[get_variable_name("", cell, "mapHog")].SetInputConnection(locals()[get_variable_name("", cell, "hog")].GetOutputPort())
locals()[get_variable_name("", cell, "mapHog")].SetScalarModeToUseCellData()
locals()[get_variable_name("", cell, "mapHog")].ScalarVisibilityOff()
locals()[get_variable_name("", cell, "derivs")] = vtk.vtkCellDerivatives()
locals()[get_variable_name("", cell, "derivs")].SetInputData(
locals()[get_variable_name("", cell, "Grid")])
locals()[get_variable_name("", cell,
"derivs")].SetVectorModeToComputeGradient()
FileName = dir
FileName += cell
FileName += ".vtk"
# make sure the directory is writeable first
if (catch.catch(
globals(),
"""channel = open("" + str(dir) + "/test.tmp", "w")""") == 0):
channel.close()
file.delete("-force", "" + str(dir) + "/test.tmp")
locals()[get_variable_name(
"", cell, "Writer")] = vtk.vtkUnstructuredGridWriter()
locals()[get_variable_name("", cell, "Writer")].SetInputConnection(
locals()[get_variable_name("", cell, "derivs")].GetOutputPort())
locals()[get_variable_name("", cell, "Writer")].SetFileName(FileName)
locals()[get_variable_name("", cell, "Writer")].Write()
# delete the file
file.delete("-force", FileName)
pass
locals()[get_variable_name("", cell, "Centers")] = vtk.vtkCellCenters()
locals()[get_variable_name("", cell, "Centers")].SetInputConnection(
locals()[get_variable_name("", cell, "derivs")].GetOutputPort())
locals()[get_variable_name("", cell, "Centers")].VertexCellsOn()
locals()[get_variable_name("", cell, "hog")] = vtk.vtkHedgeHog()
locals()[get_variable_name("", cell, "hog")].SetInputConnection(
locals()[get_variable_name("", cell, "Centers")].GetOutputPort())
locals()[get_variable_name("", cell, "mapHog")] = vtk.vtkPolyDataMapper()
def write(
filename,
vtk_mesh,
point_data = None,
cell_data = None,
field_data = None
):
'''Writes mesh together with data to a file.
:params filename: File to write to.
:type filename: str
:params point_data: Named additional point data to write to the file.
:type point_data: dict
'''
import os
extension = os.path.splitext(filename)[1]
# add point data
is_exodus_format = extension in [ '.ex2', '.exo', '.e' ]
if point_data:
for name, data in point_data.iteritems():
new_name = name
# There is a naming inconsistency in VTK when it comes to
# multivectors in Exodus files:
# If a vector 'v' has two components, they are called 'v_r',
# 'v_z' (note the underscore), if it has three, then they are
# called 'vx', 'vy', 'vz'.
# Make this consistent by appending an underscore if needed.
# Note that for VTK files, this problem does not occur since
# the label of a vector is always stored as a string.
is_3d_vector = len(data.shape) == 2 and data.shape[1] == 3
if is_exodus_format and is_3d_vector and name[-1] != '_':
new_name += '_'
vtk_mesh.GetPointData() \
.AddArray(_create_vtkarray(data, new_name))
# add cell data
if cell_data:
for key, value in cell_data.iteritems():
vtk_mesh.GetCellData() \
.AddArray(_create_vtkarray(value, key))
# add field data
if field_data:
for key, value in field_data.iteritems():
vtk_mesh.GetFieldData() \
.AddArray(_create_vtkarray(value, key))
import re
extension = os.path.splitext(filename)[1]
if extension == '.vtu': # VTK XML format
from vtk import vtkXMLUnstructuredGridWriter
writer = vtkXMLUnstructuredGridWriter()
elif extension == '.pvtu': # parallel VTK XML format
from vtk import vtkXMLPUnstructuredGridWriter
writer = vtkXMLPUnstructuredGridWriter()
elif extension == '.vtk': # classical VTK format
from vtk import vtkUnstructuredGridWriter
writer = vtkUnstructuredGridWriter()
writer.SetFileTypeToASCII()
elif extension == '.xmf': # XDMF format
from vtk import vtkXdmfWriter
writer = vtkXdmfWriter()
elif extension in [ '.ex2', '.exo', '.e' ]: # Exodus II format
from vtk import vtkExodusIIWriter
writer = vtkExodusIIWriter()
# If the mesh contains vtkModelData information, make use of it
# and write out all time steps.
writer.WriteAllTimeStepsOn()
elif re.match('[^\.]*\.e\.\d+\.\d+', filename):
# TODO handle parallel I/O with vtkPExodusIIWriter
from vtk import vtkExodusIIWriter
writer = vtkExodusIIWriter()
# If the mesh contains vtkModelData information, make use of it
# and write out all time steps.
writer.WriteAllTimeStepsOn()
else:
raise IOError( 'Unknown file type \'%s\'.' % filename )
writer.SetFileName( filename )
writer.SetInputData( vtk_mesh )
writer.Write()
return
def write(filetype,
filename,
points,
cells,
point_data=None,
cell_data=None,
field_data=None):
# pylint: disable=import-error
import vtk
def _create_vtkarray(X, name):
array = vtk.util.numpy_support.numpy_to_vtk(X, deep=1)
array.SetName(name)
return array
point_data = {} if point_data is None else point_data
cell_data = {} if cell_data is None else cell_data
field_data = {} if field_data is None else field_data
# assert data integrity
for key in point_data:
assert len(point_data[key]) == len(points), \
'Point data mismatch.'
for key in cell_data:
assert key in cells, 'Cell data without cell'
for key2 in cell_data[key]:
assert len(cell_data[key][key2]) == len(cells[key]), \
'Cell data mismatch.'
vtk_mesh = _generate_vtk_mesh(points, cells)
# add point data
pd = vtk_mesh.GetPointData()
for name, X in point_data.items():
# There is a naming inconsistency in VTK when it comes to multivectors
# in Exodus files:
# If a vector 'v' has two components, they are called 'v_x', 'v_y'
# (note the underscore), if it has three, then they are called 'vx',
# 'vy', 'vz'. See bug <http://www.vtk.org/Bug/view.php?id=15894>.
# For VT{K,U} files, no underscore is ever added.
pd.AddArray(_create_vtkarray(X, name))
# Add cell data.
# The cell_data is structured like
#
# cell_type ->
# key -> array
# key -> array
# [...]
# cell_type ->
# key -> array
# key -> array
# [...]
# [...]
#
# VTK expects one array for each `key`, so assemble the keys across all
# mesh_types. This requires each key to be present for each mesh_type, of
# course.
all_keys = []
for cell_type in cell_data:
all_keys += cell_data[cell_type].keys()
# create unified cell data
for key in all_keys:
for cell_type in cell_data:
assert key in cell_data[cell_type]
unified_cell_data = {
key: numpy.concatenate([
cell_data[cell_type][key]
for cell_type in cell_data
])
for key in all_keys
}
# add the array data to the mesh
cd = vtk_mesh.GetCellData()
for name, array in unified_cell_data.items():
cd.AddArray(_create_vtkarray(array, name))
# add field data
fd = vtk_mesh.GetFieldData()
for key, value in field_data.items():
fd.AddArray(_create_vtkarray(value, key))
if filetype in 'vtk-ascii':
logging.warning('VTK ASCII files are only meant for debugging.')
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToASCII()
elif filetype == 'vtk-binary':
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToBinary()
elif filetype == 'vtu-ascii':
logging.warning('VTU ASCII files are only meant for debugging.')
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetDataModeToAscii()
elif filetype == 'vtu-binary':
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetDataModeToBinary()
elif filetype == 'xdmf2':
writer = vtk.vtkXdmfWriter()
elif filetype == 'xdmf3':
writer = vtk.vtkXdmf3Writer()
else:
assert filetype == 'exodus', \
'Unknown file type \'{}\'.'.format(filename)
writer = vtk.vtkExodusIIWriter()
# if the mesh contains vtkmodeldata information, make use of it
# and write out all time steps.
writer.WriteAllTimeStepsOn()
writer.SetFileName(filename)
try:
writer.SetInput(vtk_mesh)
except AttributeError:
writer.SetInputData(vtk_mesh)
writer.Write()
return
def write(filetype,
filename,
points,
cells,
point_data=None,
cell_data=None,
field_data=None):
vtk_mesh = _generate_vtk_mesh(points, cells)
# add point data
if point_data is not None:
pd = vtk_mesh.GetPointData()
for name, X in point_data.iteritems():
# There is a naming inconsistency in VTK when it comes to
# multivectors in Exodus files:
# If a vector 'v' has two components, they are called 'v_r', 'v_z'
# (note the underscore), if it has three, then they are called
# 'vx', 'vy', 'vz'. Make this consistent by appending an
# underscore if needed. Note that for VTK files, this problem does
# not occur since the label of a vector is always stored as a
# string.
if filetype == 'exodus' and len(X.shape) == 2 \
and X.shape[1] == 3 and name[-1] != '_':
name += '_'
pd.AddArray(_create_vtkarray(X, name))
# add cell data
if cell_data:
cd = vtk_mesh.GetCellData()
for key, value in cell_data.iteritems():
cd.AddArray(_create_vtkarray(value, key))
# add field data
if field_data:
fd = vtk_mesh.GetFieldData()
for key, value in field_data.iteritems():
fd.AddArray(_create_vtkarray(value, key))
if filetype == 'vtk': # classical vtk format
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToASCII()
elif filetype == 'vtu': # vtk xml format
writer = vtk.vtk.vtkXMLUnstructuredGridWriter()
elif filetype == 'pvtu': # parallel vtk xml format
writer = vtk.vtkXMLUnstructuredGridWriter()
elif filetype == 'exodus': # exodus ii format
writer = vtk.vtkExodusIIWriter()
# if the mesh contains vtkmodeldata information, make use of it
# and write out all time steps.
writer.WriteAllTimeStepsOn()
else:
raise RuntimeError('unknown file type \'%s\'.' % filetype)
writer.SetFileName(filename)
try:
writer.SetInput(vtk_mesh)
except AttributeError:
writer.SetInputData(vtk_mesh)
writer.Write()
return
def rhombic_dodecahedron():
# http://www.vtk.org/pipermail/vtkusers/2014-September/085077.html
import vtk
# This is a Rhombic Dodecahedron.
# First, you need to store the vertex locations.
vertex_locations = vtk.vtkPoints()
vertex_locations.SetNumberOfPoints(14)
vertex_locations.SetPoint(0, (-0.816497, -0.816497, 0.00000))
vertex_locations.SetPoint(1, (-0.816497, 0.000000, -0.57735))
vertex_locations.SetPoint(2, (-0.816497, 0.000000, 0.57735))
vertex_locations.SetPoint(3, (-0.816497, 0.816497, 0.00000))
vertex_locations.SetPoint(4, (0.000000, -0.816497, -0.57735))
vertex_locations.SetPoint(5, (0.000000, -0.816497, 0.57735))
vertex_locations.SetPoint(6, (0.000000, 0.000000, -1.15470))
vertex_locations.SetPoint(7, (0.000000, 0.000000, 1.15470))
vertex_locations.SetPoint(8, (0.000000, 0.816497, -0.57735))
vertex_locations.SetPoint(9, (0.000000, 0.816497, 0.57735))
vertex_locations.SetPoint(10, (0.816497, -0.816497, 0.00000))
vertex_locations.SetPoint(11, (0.816497, 0.000000, -0.57735))
vertex_locations.SetPoint(12, (0.816497, 0.000000, 0.57735))
vertex_locations.SetPoint(13, (0.816497, 0.816497, 0.00000))
# Next, you describe the polygons that represent the faces using the vertex
# indices in the vtkPoints that stores the vertex locations. There are a
#number
# of ways to do this that you can find in examples on the Wiki.
polygon_faces = vtk.vtkCellArray()
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 7)
q.GetPointIds().SetId(1, 12)
q.GetPointIds().SetId(2, 10)
q.GetPointIds().SetId(3, 5)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 7)
q.GetPointIds().SetId(1, 12)
q.GetPointIds().SetId(2, 13)
q.GetPointIds().SetId(3, 9)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 7)
q.GetPointIds().SetId(1, 9)
q.GetPointIds().SetId(2, 3)
q.GetPointIds().SetId(3, 2)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 7)
q.GetPointIds().SetId(1, 2)
q.GetPointIds().SetId(2, 0)
q.GetPointIds().SetId(3, 5)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 6)
q.GetPointIds().SetId(1, 11)
q.GetPointIds().SetId(2, 10)
q.GetPointIds().SetId(3, 4)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 6)
q.GetPointIds().SetId(1, 4)
q.GetPointIds().SetId(2, 0)
q.GetPointIds().SetId(3, 1)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 6)
q.GetPointIds().SetId(1, 1)
q.GetPointIds().SetId(2, 3)
q.GetPointIds().SetId(3, 8)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 6)
q.GetPointIds().SetId(1, 8)
q.GetPointIds().SetId(2, 13)
q.GetPointIds().SetId(3, 11)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 10)
q.GetPointIds().SetId(1, 11)
q.GetPointIds().SetId(2, 13)
q.GetPointIds().SetId(3, 12)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 13)
q.GetPointIds().SetId(1, 8)
q.GetPointIds().SetId(2, 3)
q.GetPointIds().SetId(3, 9)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 3)
q.GetPointIds().SetId(1, 1)
q.GetPointIds().SetId(2, 0)
q.GetPointIds().SetId(3, 2)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 0)
q.GetPointIds().SetId(1, 4)
q.GetPointIds().SetId(2, 10)
q.GetPointIds().SetId(3, 5)
polygon_faces.InsertNextCell(q)
# Next you create a vtkPolyData to store your face and vertex information
#that
# represents your polyhedron.
pd = vtk.vtkPolyData()
pd.SetPoints(vertex_locations)
pd.SetPolys(polygon_faces)
# If you wanted to be able to load in the saved file and select the entire
# polyhedron, you would need to save it as a vtkUnstructuredGrid, and you
#would
# need to put the data into a vtkPolyhedron. This is a bit more involved
#than
# the vtkPolyData that I used above. For a more in-depth discussion, see:
# http://www.vtk.org/Wiki/VTK/Polyhedron_Support
# Based on the link above, I need to construct a face stream:
face_stream = vtk.vtkIdList()
face_stream.InsertNextId(polygon_faces.GetNumberOfCells())
vertex_list = vtk.vtkIdList()
polygon_faces.InitTraversal()
while polygon_faces.GetNextCell(vertex_list) == 1:
face_stream.InsertNextId(vertex_list.GetNumberOfIds())
for j in range(vertex_list.GetNumberOfIds()):
face_stream.InsertNextId(vertex_list.GetId(j))
ug = vtk.vtkUnstructuredGrid()
ug.SetPoints(vertex_locations)
ug.InsertNextCell(vtk.VTK_POLYHEDRON, face_stream)
#--------------#
# output stuff #
#--------------#
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileName("rhombic_dodecahedron.vtk")
#writer.SetInputData(ug)
writer.SetInput(ug)
writer.Write()
#---------------------#
# visualization stuff #
#---------------------#
# mapper = vtk.vtkPolyDataMapper()
# mapper.SetInputData(pd)
mapper = vtk.vtkDataSetMapper()
mapper.SetInput(ug)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
ren = vtk.vtkRenderer()
ren.AddActor(actor)
renw = vtk.vtkRenderWindow()
renw.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renw)
ren.ResetCamera()
renw.Render()
iren.Start()
def saveTrajectory(sols, outputFile):
"""
Save the trajectory to VTK file
@param sols list of return values of odeint
@param outputFile
"""
# number of contours
nContours = len(sols)
# number of points for each contour
nptsContour = [sol.shape[0] for sol in sols]
# total number of points
npts = functools.reduce(lambda x, y: x + y, nptsContour)
# total number of segments
nSegs = functools.reduce(lambda x, y: x + y,
[nps - 1 for nps in nptsContour])
# number of space dimensions
ndims = 3
pvals = numpy.zeros((npts, 3), numpy.float64)
tarr = vtk.vtkDoubleArray()
tpts = vtk.vtkPoints()
tgrid = vtk.vtkUnstructuredGrid()
tarr.SetNumberOfComponents(ndims)
tarr.SetNumberOfTuples(npts)
tpts.SetNumberOfPoints(npts)
ptIds = vtk.vtkIdList()
ptIds.SetNumberOfIds(2)
tgrid.Allocate(nSegs, 1)
# create the points and the unstructured grid that goes with it
offset1 = 0
offset2 = 0
for iContour in range(nContours):
ns = nptsContour[iContour]
# store points
for i in range(ns):
pvals[i + offset1, :] = sols[iContour][i]
pvals[i + offset1, 0] = max(0., min(360., pvals[i + offset1, 0]))
pvals[i + offset1, 1] = max(-90., min(90., pvals[i + offset1, 1]))
offset1 += ns
# create new cells/segments
for i in range(ns - 1):
ptIds.SetId(0, i + offset2)
ptIds.SetId(1, i + 1 + offset2)
tgrid.InsertNextCell(vtk.VTK_LINE, ptIds)
offset2 += ns
# connect
tpts.SetData(tarr)
tgrid.SetPoints(tpts)
tarr.SetVoidArray(pvals, npts * 3, 1)
# save
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileName(outputFile)
writer.SetInputData(tgrid)
writer.Update()
def rhombic_dodecahedron():
# http://www.vtk.org/pipermail/vtkusers/2014-September/085077.html
import vtk
# This is a Rhombic Dodecahedron.
# First, you need to store the vertex locations.
vertex_locations = vtk.vtkPoints()
vertex_locations.SetNumberOfPoints(14)
vertex_locations.SetPoint( 0, (-0.816497, -0.816497, 0.00000))
vertex_locations.SetPoint( 1, (-0.816497, 0.000000, -0.57735))
vertex_locations.SetPoint( 2, (-0.816497, 0.000000, 0.57735))
vertex_locations.SetPoint( 3, (-0.816497, 0.816497, 0.00000))
vertex_locations.SetPoint( 4, ( 0.000000, -0.816497, -0.57735))
vertex_locations.SetPoint( 5, ( 0.000000, -0.816497, 0.57735))
vertex_locations.SetPoint( 6, ( 0.000000, 0.000000, -1.15470))
vertex_locations.SetPoint( 7, ( 0.000000, 0.000000, 1.15470))
vertex_locations.SetPoint( 8, ( 0.000000, 0.816497, -0.57735))
vertex_locations.SetPoint( 9, ( 0.000000, 0.816497, 0.57735))
vertex_locations.SetPoint(10, ( 0.816497, -0.816497, 0.00000))
vertex_locations.SetPoint(11, ( 0.816497, 0.000000, -0.57735))
vertex_locations.SetPoint(12, ( 0.816497, 0.000000, 0.57735))
vertex_locations.SetPoint(13, ( 0.816497, 0.816497, 0.00000))
# Next, you describe the polygons that represent the faces using the vertex
# indices in the vtkPoints that stores the vertex locations. There are a
#number
# of ways to do this that you can find in examples on the Wiki.
polygon_faces = vtk.vtkCellArray()
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 7)
q.GetPointIds().SetId(1, 12)
q.GetPointIds().SetId(2, 10)
q.GetPointIds().SetId(3, 5)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 7)
q.GetPointIds().SetId(1, 12)
q.GetPointIds().SetId(2, 13)
q.GetPointIds().SetId(3, 9)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 7)
q.GetPointIds().SetId(1, 9)
q.GetPointIds().SetId(2, 3)
q.GetPointIds().SetId(3, 2)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 7)
q.GetPointIds().SetId(1, 2)
q.GetPointIds().SetId(2, 0)
q.GetPointIds().SetId(3, 5)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 6)
q.GetPointIds().SetId(1, 11)
q.GetPointIds().SetId(2, 10)
q.GetPointIds().SetId(3, 4)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 6)
q.GetPointIds().SetId(1, 4)
q.GetPointIds().SetId(2, 0)
q.GetPointIds().SetId(3, 1)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 6)
q.GetPointIds().SetId(1, 1)
q.GetPointIds().SetId(2, 3)
q.GetPointIds().SetId(3, 8)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 6)
q.GetPointIds().SetId(1, 8)
q.GetPointIds().SetId(2, 13)
q.GetPointIds().SetId(3, 11)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 10)
q.GetPointIds().SetId(1, 11)
q.GetPointIds().SetId(2, 13)
q.GetPointIds().SetId(3, 12)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 13)
q.GetPointIds().SetId(1, 8)
q.GetPointIds().SetId(2, 3)
q.GetPointIds().SetId(3, 9)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 3)
q.GetPointIds().SetId(1, 1)
q.GetPointIds().SetId(2, 0)
q.GetPointIds().SetId(3, 2)
polygon_faces.InsertNextCell(q)
q = vtk.vtkQuad()
q.GetPointIds().SetId(0, 0)
q.GetPointIds().SetId(1, 4)
q.GetPointIds().SetId(2, 10)
q.GetPointIds().SetId(3, 5)
polygon_faces.InsertNextCell(q)
# Next you create a vtkPolyData to store your face and vertex information
#that
# represents your polyhedron.
pd = vtk.vtkPolyData()
pd.SetPoints(vertex_locations)
pd.SetPolys(polygon_faces)
# If you wanted to be able to load in the saved file and select the entire
# polyhedron, you would need to save it as a vtkUnstructuredGrid, and you
#would
# need to put the data into a vtkPolyhedron. This is a bit more involved
#than
# the vtkPolyData that I used above. For a more in-depth discussion, see:
# http://www.vtk.org/Wiki/VTK/Polyhedron_Support
# Based on the link above, I need to construct a face stream:
face_stream = vtk.vtkIdList()
face_stream.InsertNextId(polygon_faces.GetNumberOfCells())
vertex_list = vtk.vtkIdList()
polygon_faces.InitTraversal()
while polygon_faces.GetNextCell(vertex_list) == 1:
face_stream.InsertNextId(vertex_list.GetNumberOfIds())
for j in range(vertex_list.GetNumberOfIds()):
face_stream.InsertNextId(vertex_list.GetId(j))
ug = vtk.vtkUnstructuredGrid()
ug.SetPoints(vertex_locations)
ug.InsertNextCell(vtk.VTK_POLYHEDRON, face_stream)
#--------------#
# output stuff #
#--------------#
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileName("rhombic_dodecahedron.vtk")
#writer.SetInputData(ug)
writer.SetInput(ug)
writer.Write()
#---------------------#
# visualization stuff #
#---------------------#
# mapper = vtk.vtkPolyDataMapper()
# mapper.SetInputData(pd)
mapper = vtk.vtkDataSetMapper()
mapper.SetInput(ug)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
ren = vtk.vtkRenderer()
ren.AddActor(actor)
renw = vtk.vtkRenderWindow()
renw.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renw)
ren.ResetCamera()
renw.Render()
iren.Start()
xy = numpy.array(eval('[' + args.p + ']'))
npts = xy.shape[0]
ncells = npts - 1
xyz = numpy.zeros((npts, 3), numpy.float64)
xyz[:, 0] = xy[:, 0]
xyz[:, 1] = xy[:, 1]
pointData = vtk.vtkDoubleArray()
pointData.SetNumberOfComponents(3)
pointData.SetNumberOfTuples(npts)
pointData.SetVoidArray(xyz, 3 * npts, 1)
points = vtk.vtkPoints()
points.SetNumberOfPoints(npts)
points.SetData(pointData)
grid = vtk.vtkUnstructuredGrid()
grid.SetPoints(points)
grid.Allocate(ncells, 1)
ptIds = vtk.vtkIdList()
ptIds.SetNumberOfIds(2)
for i in range(ncells):
ptIds.SetId(0, i)
ptIds.SetId(1, i + 1)
grid.InsertNextCell(vtk.VTK_LINE, ptIds)
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileName(args.o)
writer.SetInputData(grid)
writer.Update()
def write_vtk(self,
data_dir='./data',
file_name='nulls.vtk',
binary=False):
"""
Write the null point into a vtk file.
call signature:
write_vtk(data_dir='./data', file_name='nulls.vtk', binary=False)
Arguments:
*data_dir*:
Target data directory.
*file_name*:
Target file name.
*binary*:
Write file in binary or ASCII format.
"""
writer = vtk.vtkUnstructuredGridWriter()
if binary:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
writer.SetFileName(os.path.join(data_dir, file_name))
grid_data = vtk.vtkUnstructuredGrid()
points = vtk.vtkPoints()
# Write the null points.
for null in self.nulls:
points.InsertNextPoint(null)
if len(self.nulls) != 0:
eigen_values_vtk = []
eigen_values = []
eigen_vectors_vtk = []
eigen_vectors = []
fan_vectors_vtk = []
fan_vectors = []
for dim in range(self.eigen_values.shape[1]):
# Write out the eigen values.
eigen_values.append(self.eigen_values[:, dim].copy())
eigen_values_vtk.append(VN.numpy_to_vtk(eigen_values[-1]))
eigen_values_vtk[-1].SetName('eigen_value_{0}'.format(dim))
grid_data.GetPointData().AddArray(eigen_values_vtk[-1])
# Write out the eigen vectors.
eigen_vectors.append(self.eigen_vectors[:, dim, :].copy())
eigen_vectors_vtk.append(VN.numpy_to_vtk(eigen_vectors[-1]))
eigen_vectors_vtk[-1].SetName('eigen_vector_{0}'.format(dim))
grid_data.GetPointData().AddArray(eigen_vectors_vtk[-1])
# Write out the fan vectors..
if dim < self.eigen_values.shape[1] - 1:
fan_vectors.append(self.fan_vectors[:, dim, :].copy())
fan_vectors_vtk.append(VN.numpy_to_vtk(fan_vectors[-1]))
fan_vectors_vtk[-1].SetName('fan_vector_{0}'.format(dim))
grid_data.GetPointData().AddArray(fan_vectors_vtk[-1])
# Write out the sign for the vector field tracing.
sign_trace_vtk = VN.numpy_to_vtk(self.sign_trace)
sign_trace_vtk.SetName('sign_trace')
grid_data.GetPointData().AddArray(sign_trace_vtk)
# Write out the fan plane normal.
normals_vtk = VN.numpy_to_vtk(self.normals)
normals_vtk.SetName('normal')
grid_data.GetPointData().AddArray(normals_vtk)
grid_data.SetPoints(points)
# Insure compatability between vtk 5 and 6.
try:
writer.SetInputData(grid_data)
except:
writer.SetInput(grid_data)
writer.Write()
def write(filetype,
filename,
points,
cells,
point_data=None,
cell_data=None,
field_data=None
):
import vtk
from vtk.util import numpy_support
def _create_vtkarray(X, name):
array = vtk.util.numpy_support.numpy_to_vtk(X, deep=1)
array.SetName(name)
return array
if point_data is None:
point_data = {}
if cell_data is None:
cell_data = {}
if field_data is None:
field_data = {}
vtk_mesh = _generate_vtk_mesh(points, cells)
# add point data
pd = vtk_mesh.GetPointData()
for name, X in point_data.iteritems():
# There is a naming inconsistency in VTK when it comes to multivectors
# in Exodus files:
# If a vector 'v' has two components, they are called 'v_x', 'v_y'
# (note the underscore), if it has three, then they are called 'vx',
# 'vy', 'vz'. See bug <http://www.vtk.org/Bug/view.php?id=15894>.
# For VT{K,U} files, no underscore is ever added.
pd.AddArray(_create_vtkarray(X, name))
# add cell data
cd = vtk_mesh.GetCellData()
for key, value in cell_data.iteritems():
cd.AddArray(_create_vtkarray(value, key))
# add field data
fd = vtk_mesh.GetFieldData()
for key, value in field_data.iteritems():
fd.AddArray(_create_vtkarray(value, key))
if filetype in 'vtk-ascii':
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToASCII()
elif filetype == 'vtk-binary':
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToBinary()
elif filetype == 'vtu': # vtk xml format
writer = vtk.vtkXMLUnstructuredGridWriter()
elif filetype == 'xdmf':
writer = vtk.vtkXdmfWriter()
elif filetype == 'exodus': # exodus ii format
writer = vtk.vtkExodusIIWriter()
# if the mesh contains vtkmodeldata information, make use of it
# and write out all time steps.
writer.WriteAllTimeStepsOn()
else:
raise RuntimeError('unknown file type \'%s\'.' % filetype)
writer.SetFileName(filename)
try:
writer.SetInput(vtk_mesh)
except AttributeError:
writer.SetInputData(vtk_mesh)
writer.Write()
return
def write(filetype,
filename,
points,
cells,
point_data=None,
cell_data=None,
field_data=None):
import vtk
from vtk.util import numpy_support
def _create_vtkarray(X, name):
array = vtk.util.numpy_support.numpy_to_vtk(X, deep=1)
array.SetName(name)
return array
if point_data is None:
point_data = {}
if cell_data is None:
cell_data = {}
if field_data is None:
field_data = {}
vtk_mesh = _generate_vtk_mesh(points, cells)
# add point data
pd = vtk_mesh.GetPointData()
for name, X in point_data.iteritems():
# There is a naming inconsistency in VTK when it comes to multivectors
# in Exodus files:
# If a vector 'v' has two components, they are called 'v_x', 'v_y'
# (note the underscore), if it has three, then they are called 'vx',
# 'vy', 'vz'. See bug <http://www.vtk.org/Bug/view.php?id=15894>.
# For VT{K,U} files, no underscore is ever added.
pd.AddArray(_create_vtkarray(X, name))
# add cell data
cd = vtk_mesh.GetCellData()
for key, value in cell_data.iteritems():
cd.AddArray(_create_vtkarray(value, key))
# add field data
fd = vtk_mesh.GetFieldData()
for key, value in field_data.iteritems():
fd.AddArray(_create_vtkarray(value, key))
if filetype in 'vtk-ascii':
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToASCII()
elif filetype == 'vtk-binary':
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToBinary()
elif filetype == 'vtu': # vtk xml format
writer = vtk.vtkXMLUnstructuredGridWriter()
elif filetype == 'xdmf':
writer = vtk.vtkXdmfWriter()
elif filetype == 'exodus': # exodus ii format
writer = vtk.vtkExodusIIWriter()
# if the mesh contains vtkmodeldata information, make use of it
# and write out all time steps.
writer.WriteAllTimeStepsOn()
else:
raise RuntimeError('unknown file type \'%s\'.' % filetype)
writer.SetFileName(filename)
try:
writer.SetInput(vtk_mesh)
except AttributeError:
writer.SetInputData(vtk_mesh)
writer.Write()
return
def write_vtk(self, data_dir='./data', file_name='nulls.vtk',
binary=False):
"""
Write the null point into a vtk file.
call signature:
write_vtk(data_dir='./data', file_name='nulls.vtk', binary=False)
Arguments:
*data_dir*:
Target data directory.
*file_name*:
Target file name.
*binary*:
Write file in binary or ASCII format.
"""
writer = vtk.vtkUnstructuredGridWriter()
if binary:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
writer.SetFileName(os.path.join(data_dir, file_name))
grid_data = vtk.vtkUnstructuredGrid()
points = vtk.vtkPoints()
# Write the null points.
for null in self.nulls:
points.InsertNextPoint(null)
if len(self.nulls) != 0:
eigen_values_vtk = []
eigen_values = []
eigen_vectors_vtk = []
eigen_vectors = []
fan_vectors_vtk = []
fan_vectors = []
for dim in range(self.eigen_values.shape[1]):
# Write out the eigen values.
eigen_values.append(self.eigen_values[:, dim].copy())
eigen_values_vtk.append(VN.numpy_to_vtk(eigen_values[-1]))
eigen_values_vtk[-1].SetName('eigen_value_{0}'.format(dim))
grid_data.GetPointData().AddArray(eigen_values_vtk[-1])
# Write out the eigen vectors.
eigen_vectors.append(self.eigen_vectors[:, dim, :].copy())
eigen_vectors_vtk.append(VN.numpy_to_vtk(eigen_vectors[-1]))
eigen_vectors_vtk[-1].SetName('eigen_vector_{0}'.format(dim))
grid_data.GetPointData().AddArray(eigen_vectors_vtk[-1])
# Write out the fan vectors..
if dim < self.eigen_values.shape[1]-1:
fan_vectors.append(self.fan_vectors[:, dim, :].copy())
fan_vectors_vtk.append(VN.numpy_to_vtk(fan_vectors[-1]))
fan_vectors_vtk[-1].SetName('fan_vector_{0}'.format(dim))
grid_data.GetPointData().AddArray(fan_vectors_vtk[-1])
# Write out the sign for the vector field tracing.
sign_trace_vtk = VN.numpy_to_vtk(self.sign_trace)
sign_trace_vtk.SetName('sign_trace')
grid_data.GetPointData().AddArray(sign_trace_vtk)
# Write out the fan plane normal.
normals_vtk = VN.numpy_to_vtk(self.normals)
normals_vtk.SetName('normal')
grid_data.GetPointData().AddArray(normals_vtk)
grid_data.SetPoints(points)
# Insure compatability between vtk 5 and 6.
try:
writer.SetInputData(grid_data)
except:
writer.SetInput(grid_data)
writer.Write()
def return_mesh(self):
"""
Returns the Mesh or the file pointer
Returns
-------
Object
"""
if self._nodespreallocation is VtkPreallocation.PREALLOCATED:
x = self._nodes[:, 1]
y = self._nodes[:, 2]
z = self._nodes[:, 3]
no_of_nodes = self._nodes.shape[0]
self._nodes_df = pd.DataFrame(
{
'row': np.arange(no_of_nodes, dtype=int),
'x': x,
'y': y,
'z': z
},
index=np.array(self._nodes[:, 0], dtype=int))
self._vtknodes.SetNumberOfPoints(no_of_nodes)
if not self._el_df.isnull().values.any():
# Function change connectivity ids to row ids in nodes array:
def change_connectivity(arr):
return np.array(
[self._nodes_df.loc[node, 'row'] for node in arr],
ndmin=2,
dtype=int)
def write_vtk_element(idx, etype, nodes):
cell = self.amfe2vtk[etype]()
for i, node in enumerate(nodes):
cell.GetPointIds().SetId(i, node)
self._eleid2cell.update({idx: cell})
if self._elementspreallocation is VtkPreallocation.UNKNOWN:
self._vtkelements.Allocate(1, 1)
self._elementspreallocation = VtkPreallocation.NOTPREALLOCATED
cellid = self._vtkelements.InsertNextCell(
cell.GetCellType(), cell.GetPointIds())
self._eleid2cell.update({idx: cellid})
self._el_df = self._el_df.astype(dtype={
'id': 'int',
'type': 'object',
'connectivity': 'object'
})
self._el_df['connectivity'] = self._el_df['connectivity'].apply(
change_connectivity)
for element in self._el_df.itertuples():
write_vtk_element(element.Index, element.type,
element.connectivity[0])
for node in self._nodes_df.itertuples():
self._vtknodes.InsertPoint(node.row, node.x, node.y, node.z)
self._vtkelements.SetPoints(self._vtknodes)
for tagname, tag_dict in self._tags.items():
vtkarray = vtk.vtkIntArray()
vtkarray.SetNumberOfComponents(1)
vtkarray.SetNumberOfTuples(
self._vtkelements.GetNumberOfCells())
vtkarray.FillComponent(0, 0)
vtkarray.SetName(tagname)
for tagvalue, eleids in tag_dict.items():
vtkids = [self._eleid2cell[eleid] for eleid in eleids]
for vtkid in vtkids:
vtkarray.SetTuple1(vtkid, int(tagvalue))
self._vtkelements.GetCellData().AddArray(vtkarray)
for groupname, groupdict in self._groups.items():
nodeids = groupdict['nodes']
elementids = groupdict['elements']
elementidxs = []
for eleid in elementids:
elementidxs += self._el_df.index[self._el_df['id'] ==
eleid].tolist()
elementids = [
self._eleid2cell[eleidx] for eleidx in elementidxs
]
if len(elementids) > 0:
# Allocate vtk elements array
vtkelements = vtk.vtkIntArray()
vtkelements.SetNumberOfComponents(1)
vtkelements.SetNumberOfTuples(
self._vtkelements.GetNumberOfCells())
vtkelements.SetName(groupname + '_elements')
vtkelements.FillComponent(0, 0)
for elementid in elementids:
vtkelements.SetTuple1(elementid, 1)
self._vtkelements.GetCellData().AddArray(vtkelements)
if len(nodeids) > 0:
vtknodes = vtk.vtkIntArray()
vtknodes.SetNumberOfComponents(1)
vtknodes.SetNumberOfTuples(
self._vtknodes.GetNumberOfPoints())
vtknodes.SetName(groupname + '_nodes')
vtknodes.FillComponent(0, 0)
for nodeid in nodeids:
nodeidx = int(self._nodes_df.loc[nodeid, 'row'])
vtknodes.SetTuple1(nodeidx, 1)
self._vtkelements.GetPointData().AddArray(vtknodes)
filename, file_extension = splitext(self._filename)
if file_extension == '.vtu':
vtkwriter = vtk.vtkXMLUnstructuredGridWriter()
elif file_extension == '.vtk':
vtkwriter = vtk.vtkUnstructuredGridWriter()
else:
self.logger.warning(
'No file extension given, choose \'vtk\' format')
self._filename = self._filename + '.vtk'
vtkwriter = vtk.vtkUnstructuredGridWriter()
vtkwriter.SetInputData(self._vtkelements)
vtkwriter.SetFileName(self._filename)
vtkwriter.Write()
return 0
f = open(out_table,'w')
for ptid in activation_ptids:
f.write(f'{ptid} {CURDENSITY} 0 {LAPSE}\n')
f.close()
# In[37]:
#save the points with the oriinal mesh for validation
if save_mesh:
a = vtk.vtkShortArray()
a.SetName('activation_points')
a.SetNumberOfComponents(1)
a.SetNumberOfTuples(mesh.GetNumberOfPoints())
a.Fill(0);
for ptid in activation_ptids:
a.SetTuple1(ptid-1,1)
mesh.GetPointData().AddArray(a)
wr = vtk.vtkUnstructuredGridWriter()
wr.SetFileName(outmesh_filename)
wr.SetInputData(mesh)
wr.Write()
def save(self, filename):
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileName(filename)
writer.SetInputData(self.grid)
writer.Update()
