def main(): # The sphere and spikes are appended into a single polydata. # This just makes things simpler to manage. # apd = vtk.vtkUnstructuredGridReader() data_source = vtk.vtkRectilinearGridReader() data_source.SetFileName("/home/saito/paraview/solution_40.vtk") data_source.SetScalarsName("Pressure") # Create the RenderWindow, Renderer and both Actors ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) implicit_plane_widget, selected_plane_actor = new_implicit_plane_widget( data_source) implicit_plane_widget.SetInteractor(iren) ren.AddActor(new_geometry_actor(data_source)) ren.AddActor(selected_plane_actor) ren.AddActor(new_outline_actor(data_source)) ren.AddActor(new_axes_actor(ren, data_source)) # Add the actors to the renderer, set the background and size ren.SetBackground(1, 1, 1) renWin.SetSize(300, 300) ren.SetBackground(0.1, 0.2, 0.4) # Start interaction. iren.Initialize() renWin.Render() iren.Start()
def read_vtk(self, to_polydata=False): # Read the source file. reader = vtk.vtkDataReader() reader.SetFileName('.'.join([self.filename, self.input_type])) reader.Update() print('Case ID : {}, input type: {}'.format(self.filename, self.input_type)) if reader.IsFileUnstructuredGrid(): print('Reading Unstructured Grid...') reader = vtk.vtkUnstructuredGridReader() elif reader.IsFilePolyData(): print('Reading Polygonal Mesh...') reader = vtk.vtkPolyDataReader() elif reader.IsFileStructuredGrid(): print('Reading Structured Grid...') reader = vtk.vtkStructuredGridReader() elif reader.IsFileStructuredPoints(): print('Reading Structured Points...') reader = vtk.vtkStructuredPointsReader() elif reader.IsFileRectilinearGrid(): print('Reading Rectilinear Grid...') reader = vtk.vtkRectilinearGridReader() else: print('Data format unknown...') reader.SetFileName(self.filename + '.' + self.input_type) reader.Update() # Needed because of GetScalarRange scalar_range = reader.GetOutput().GetScalarRange() if to_polydata and not reader.IsFilePolyData(): print('Transform to Polygonal Mesh') reader = self.unstructured_grid_to_poly_data(reader) print('Scalar range: \n{}'.format(scalar_range)) return reader, scalar_range
def my_vtk(fdir, fname, varname): """ Get vtk-reader from filename and varname Parameters ---------- fdir : string Path to the file. Without '/' at end. fname : string Name of the file. varname: string Name of the variable Returns ---------- vtk_reader: vtk Reader instance vtk Reader containing information about a vtk-file. """ # Check if scalar variable is in vtk-file is_var_in_file(fdir, fname, varname) # Prepare vtk-Reader vtk_reader = vtk.vtkRectilinearGridReader() # Reader vtk_reader.SetFileName(fdir + '/' + fname) # Filename vtk_reader.SetScalarsName(varname) # Variable name vtk_reader.Update() # Refresh return vtk_reader
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkRectilinearGridReader(), 'Reading vtkRectilinearGrid.', (), ('vtkRectilinearGrid',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def loadRectilinearGrid(filename): # not tested '''Load a vtkRectilinearGrid object from file and return a vtkActor.''' reader = vtk.vtkRectilinearGridReader() reader.SetFileName(filename) reader.Update() gf = vtk.vtkRectilinearGridGeometryFilter() gf.SetInputConnection(reader.GetOutputPort()) gf.Update() return Actor(gf.GetOutput())
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__(self, module_manager, vtk.vtkRectilinearGridReader(), 'Reading vtkRectilinearGrid.', (), ('vtkRectilinearGrid', ), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def create_reader (self): "Create the corresponding reader." debug ("In VtkDataReader::create_reader ()") # set up the reader if self.file_name == "": raise IOError, "No filename specifed for the data handler!" self.grid_type = find_data_type (self.file_name) if self.grid_type == "STRUCTURED_GRID": self.reader = vtk.vtkStructuredGridReader () elif self.grid_type == "STRUCTURED_POINTS": self.reader = vtk.vtkStructuredPointsReader () elif self.grid_type == "RECTILINEAR_GRID": self.reader = vtk.vtkRectilinearGridReader () elif self.grid_type == "POLYDATA": self.reader = vtk.vtkPolyDataReader () elif self.grid_type == "UNSTRUCTURED_GRID": self.reader = vtk.vtkUnstructuredGridReader ()
def pluto_vtk_to_numpy(filename, quantity_names, ordering): '''pluto_vtk_to_numpy(filename, quantity_names, ordering): \ loads a vtk as built by pluto \ (only for scalar output of quantities)\ and converts it to numpy array.\ "ordering may be either "C" or "F"''' if (os.path.isfile(filename)): reader = vtkRectilinearGridReader() reader.SetFileName(filename) reader.ReadAllVectorsOn() reader.ReadAllScalarsOn() reader.Update() else: raise ValueError("File '" + filename + "' does not exist") data = reader.GetOutput() dim = [] for ii in data.GetDimensions(): if ii > 1: dim.append(ii) x = VN.vtk_to_numpy(data.GetXCoordinates()) y = VN.vtk_to_numpy(data.GetYCoordinates()) z = VN.vtk_to_numpy(data.GetZCoordinates()) u = [] for qn in quantity_names: # I transform to numpy array the scalar/vector field (and reshape) u.append(VN.vtk_to_numpy(data.GetCellData().GetArray(qn))) # Number of cells per each dimension dim_cells = list(np.array(dim) - 1) dim_quantity = dim_cells.copy() for ii in range(len(u)): try: dim_quantity.append(u[ii].shape[1]) except IndexError: pass u[ii] = u[ii].reshape(dim_quantity, order=ordering).transpose() return u, x, y, z
def load_object_3d(self, path, viewer_3d): generic_reader = vtkDataReader() generic_reader.SetFileName(path) if generic_reader.OpenVTKFile() and generic_reader.ReadHeader(): if generic_reader.IsFileStructuredPoints(): raise Exception("Cannot read VTK structured points") elif generic_reader.IsFilePolyData(): reader = vtkPolyDataReader() reader.SetFileName(path) object_3d = Object3D(reader.GetOutput(), path) elif generic_reader.IsFileStructuredGrid(): reader = vtkStructuredGridReader() reader.SetFileName(path) object_3d = Object3D(reader.GetOutput(), path) elif generic_reader.IsFileUnstructuredGrid(): reader = vtkUnstructuredGridReader() reader.SetFileName(path) object_3d = Object3D(reader.GetOutput(), path) elif generic_reader.IsFileRectilinearGrid(): reader = vtkRectilinearGridReader() reader.SetFileName(path) object_3d = Object3D(reader.GetOutput(), path) else: raise Exception("Cannot read VTK file containing type %i" % generic_reader.GetFileType()) viewer_3d.objects_3d.append(object_3d) else: importer = vtkVRMLImporter() importer.SetFileName(path) importer.Update() actors = importer.GetRenderer().GetActors() number_of_actors = actors.GetNumberOfItems() actors.InitTraversal() for i in range(number_of_actors): actor = actors.GetNextItem() object_3d = Object3D(path + ", %i" % i) object_3d.actor.SetProperty(actor.GetProperty()) object_3d.actor.SetMapper(actor.GetMapper()) viewer_3d.objects_3d.append(object_3d)
def _load_file(self, filename): """ Load a rectilinear grid from a file. The file extension will select the type of reader to use. A .vtk extension will use the legacy reader, while .vtr will select the VTK XML reader. Parameters ---------- filename : str Filename of grid to be loaded. """ filename = os.path.abspath(os.path.expanduser(filename)) # check file exists if not os.path.isfile(filename): raise Exception('{} does not exist'.format(filename)) # Check file extension if '.vtr' in filename: legacy_writer = False elif '.vtk' in filename: legacy_writer = True else: raise Exception( 'Extension should be either ".vtr" (xml) or ".vtk" (legacy)') # Create reader if legacy_writer: reader = vtk.vtkRectilinearGridReader() else: reader = vtk.vtkXMLRectilinearGridReader() # load file to self reader.SetFileName(filename) reader.Update() grid = reader.GetOutput() self.shallow_copy(grid)
import vtk #help(vtk.vtkRectilinearGridReader()) rectGridReader = vtk.vtkRectilinearGridReader() rectGridReader.SetFileName("data/jet4_0.500.vtk") # do not forget to call "Update()" at the end of the reader rectGridReader.Update() rectGridOutline = vtk.vtkRectilinearGridOutlineFilter() rectGridOutline.SetInputData(rectGridReader.GetOutput()) # New vtkRectilinearGridGeometryFilter() goes here: # # # # plane = vtk.vtkRectilinearGridGeometryFilter() plane.SetInputData(rectGridReader.GetOutput()) rectGridOutlineMapper = vtk.vtkPolyDataMapper() rectGridOutlineMapper.SetInputConnection(rectGridOutline.GetOutputPort()) rectGridGeomMapper = vtk.vtkPolyDataMapper() rectGridGeomMapper.SetInputConnection(plane.GetOutputPort()) # outlineActor = vtk.vtkActor() outlineActor.SetMapper(rectGridOutlineMapper) outlineActor.GetProperty().SetColor(0, 0, 0) gridGeomActor = vtk.vtkActor()
def loadRectilinearGrid(filename): """Load a ``vtkRectilinearGrid`` object from file.""" reader = vtk.vtkRectilinearGridReader() reader.SetFileName(filename) reader.Update() return reader.GetOutput()
extents = (1, 3, 1, 3, 1, 3) rg.SetExtent(extents) pts = vtk.vtkFloatArray() pts.InsertNextTuple1(0) pts.InsertNextTuple1(1) pts.InsertNextTuple1(2) rg.SetXCoordinates(pts) rg.SetYCoordinates(pts) rg.SetZCoordinates(pts) w = vtk.vtkRectilinearGridWriter() w.SetInputData(rg) w.SetFileName("test-dim.vtk") w.Write() r = vtk.vtkRectilinearGridReader() r.SetFileName("test-dim.vtk") r.Update() os.remove("test-dim.vtk") assert(r.GetOutput().GetExtent() == (0,2,0,2,0,2)) w.SetInputData(rg) w.SetFileName("test-dim.vtk") w.SetWriteExtent(True) w.Write() r.Modified() r.Update()
def read_polydata(filename, datatype=None): """ Load the given file, and return a vtkPolyData object for it. Args: filename (str): Path to input file. datatype (str): Additional parameter for vtkIdList objects. Returns: polyData (vtkSTL/vtkPolyData/vtkXMLStructured/ vtkXMLRectilinear/vtkXMLPolydata/vtkXMLUnstructured/ vtkXMLImage/Tecplot): Output data. """ # Check if file exists if not path.exists(filename): raise RuntimeError("Could not find file: %s" % filename) # Check filename format fileType = filename.split(".")[-1] if fileType == '': raise RuntimeError('The file does not have an extension') # Get reader if fileType == 'stl': reader = vtk.vtkSTLReader() reader.MergingOn() elif fileType == 'vtk': # Read header with open(filename, "rb") as f: head = list(islice(f, 10)) head = "".join([l.decode('utf-8', 'backslashreplace') for l in head]).lower() # Set reader based on header if "unstructured_grid" in head: reader = vtk.vtkUnstructuredGridReader() elif "structured_grid" in head: reader = vtk.vtkStructuredGridReader() elif "rectilinear_grid" in head: reader = vtk.vtkRectilinearGridReader() elif "structured_points" in head: reader = vtk.vtkStructuredPointsReader() elif "polydata" in head: reader = vtk.vtkPolyDataReader() elif fileType == 'vtp': reader = vtk.vtkXMLPolyDataReader() elif fileType == 'vts': reader = vtk.vtkXMLStructuredGridReader() elif fileType == 'vtr': reader = vtk.vtkXMLRectilinearGridReader() elif fileType == 'vtu': reader = vtk.vtkXMLUnstructuredGridReader() elif fileType == "vti": reader = vtk.vtkXMLImageDataReader() elif fileType == "np" and datatype == "vtkIdList": result = np.load(filename).astype(np.int) id_list = vtk.vtkIdList() id_list.SetNumberOfIds(result.shape[0]) for i in range(result.shape[0]): id_list.SetId(i, result[i]) return id_list else: raise RuntimeError('Unknown file type %s' % fileType) # Read reader.SetFileName(filename) reader.Update() polydata = reader.GetOutput() return polydata
F = np.squeeze( np.reshape(F, (int(FTLE_Res[1]), int(FTLE_Res[0]), int( FTLE_Res[2:]), int(LCS_NumFields), int(Output_TRes)))) X = np.linspace(ftlemin[0], ftlemax[0], FTLE_Res[0]) Y = np.linspace(ftlemin[1], ftlemax[1], FTLE_Res[1]) Z = np.linspace(ftlemin[2], ftlemax[2], FTLE_Res[2]) # first time step nwF = F[:, :, :, :] FTLE = nwF[:, :, :, 0] # .T.swapaxes(1, 2) Omega = nwF[:, :, :, 1] # .T.swapaxes(1, 2) Eval = nwF[:, :, :, 2] # .T.swapaxes(1, 2) smFTLE = nwF[:, :, :, 3] # .T.swapaxes(1, 2) reader = vtkRectilinearGridReader() reader.SetFileName(fname) reader.ReadAllScalarsOn() reader.ReadAllVectorsOn() reader.Update() data = reader.GetOutput() dim = data.GetDimensions() bounds = data.GetBounds() arrowGlyph = data.GetPointData().GetArray('U') vectU = VN.vtk_to_numpy(arrowGlyph) vectU[vectU < -99] = -1 vectXYZ = vectU vectX = vectXYZ[:, 0] # msk = np.reshape(vectX, [dim[0], dim[1], dim[2]], order='F') # msk[msk > -1] = 1 # msk[msk < 1] = 0