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()