def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkXMLRectilinearGridWriter(), 'Writing vtkXMLRectilinearGrid.', ('vtkXMLRectilinearGrid',), (), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def write(self, fname): """ Write to file. Parameters ---------- fname : str Filename for writing. """ if isinstance(self.geom, vtk.vtkRectilinearGrid): writer = vtk.vtkXMLRectilinearGridWriter() elif isinstance(self.geom, vtk.vtkUnstructuredGrid): writer = vtk.vtkXMLUnstructuredGridWriter() elif isinstance(self.geom, vtk.vtkPolyData): writer = vtk.vtkXMLPolyDataWriter() default_ext = writer.GetDefaultFileExtension() name, ext = os.path.splitext(fname) if ext and ext != '.' + default_ext: raise ValueError('Given extension {} is not .{}'.format( ext, default_ext)) writer.SetFileName('{}.{}'.format(name, default_ext)) writer.SetCompressorTypeToZLib() writer.SetDataModeToBinary() writer.SetInputData(self.geom) writer.Write()
def _save_rectilinear_grid(filename, vtkRectGrid, directory=''): """Saves a VTK rectilinear file (vtr) ffor an already generated :class:`pyvista.RectilinearGrid` object. Parameters ---------- filename : str path to the output vtk file or just its name if directory is specified directory : str directory where the UBC GIF file lives """ if not isinstance(vtkRectGrid, vtk.vtkRectilinearGrid): raise RuntimeError( '`_save_rectilinear_grid` can only handle `vtkRectilinearGrid` objects. `{}` is not supported.' .format(vtkRectGrid.__class__)) # Check the extension of the filename fname = os.path.join(directory, filename) ext = os.path.splitext(fname)[1] if ext is '': fname = fname + '.vtr' elif ext not in '.vtr': raise IOError( '{:s} is an incorrect extension, has to be .vtr'.format(ext)) # Write the file. vtrWriteFilter = vtkXMLRectilinearGridWriter() if float(VTK_VERSION.split('.')[0]) >= 6: vtrWriteFilter.SetInputDataObject(vtkRectGrid) else: vtuWriteFilter.SetInput(vtuObj) vtrWriteFilter.SetFileName(fname) vtrWriteFilter.Update()
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__(self, module_manager, vtk.vtkXMLRectilinearGridWriter(), 'Writing vtkXMLRectilinearGrid.', ('vtkXMLRectilinearGrid', ), (), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def writeVTRFile(fileName,vtkRectilinearGrid): '''Function to write vtk rectilinear grid (vtr).''' Writer = vtk.vtkXMLRectilinearGridWriter() if float(vtk.VTK_VERSION.split('.')[0]) >=6: Writer.SetInputData(vtkRectilinearGrid) else: Writer.SetInput(vtkRectilinearGrid) Writer.SetFileName(fileName) Writer.Update()
def writeVTRFile(fileName, vtkRectilinearGrid): '''Function to write vtk rectilinear grid (vtr).''' Writer = vtk.vtkXMLRectilinearGridWriter() if float(vtk.VTK_VERSION.split('.')[0]) >= 6: Writer.SetInputData(vtkRectilinearGrid) else: Writer.SetInput(vtkRectilinearGrid) Writer.SetFileName(fileName) Writer.Update()
def writeVTR(vtr_name, scalar_fields, vector_fields, vtkX, vtkY, vtkZ, localZrange): """Writes a single VTR file per Python processor/variable Parameters: vtr_name - name of the VTR file scalar_fields - dictionary with scalar field arrays ordered [x, y, z], e.g. {'p': array[nx,ny,nz], 'rho0': array[nx,ny,nz]} vector_fields - dictionary with vector fields ordered [3, x, y, z], e.g. {'J': array[3,nx,ny,nz], 'B': array[3,nx,ny,nz]} vtkX, vtkY, vtkZ - VTR coordinates, see createVtrCoordinates() localZrange - local range for Z indices """ Nx = vtkX.GetNumberOfTuples() - 1 Ny = vtkY.GetNumberOfTuples() - 1 Nz = vtkZ.GetNumberOfTuples() - 1 numpoints = (Nx + 1) * (Ny + 1) * (Nz + 1) rtg = vtk.vtkRectilinearGrid() rtg.SetExtent(0, Nx, 0, Ny, localZrange[0], localZrange[1]) rtg.SetXCoordinates(vtkX) rtg.SetYCoordinates(vtkY) rtg.SetZCoordinates(vtkZ) vtk_data = [] array_list = [] for f in scalar_fields: vtk_data.append(vtk.vtkFloatArray()) vtk_data[-1].SetNumberOfTuples(numpoints) vtk_data[-1].SetNumberOfComponents(1) array_list.append(scalar_fields[f].swapaxes( 0, 2).flatten().astype("float32")) vtk_data[-1].SetVoidArray(array_list[-1], numpoints, 1) vtk_data[-1].SetName(f) if f == scalar_fields.keys()[0]: rtg.GetPointData().SetScalars(vtk_data[-1]) else: rtg.GetPointData().AddArray(vtk_data[-1]) #end for for f in vector_fields: vtk_data.append(vtk.vtkFloatArray()) vtk_data[-1].SetNumberOfTuples(numpoints * 3) vtk_data[-1].SetNumberOfComponents(3) array_list.append(vector_fields[f].swapaxes(0, 3).swapaxes( 1, 2).flatten().astype("float32")) vtk_data[-1].SetVoidArray(array_list[-1], numpoints * 3, 1) vtk_data[-1].SetName(f) if f == vector_fields.keys()[0]: rtg.GetPointData().SetVectors(vtk_data[-1]) else: rtg.GetPointData().AddArray(vtk_data[-1]) #end for try: writer = vtk.vtkXMLRectilinearGridWriter() writer.SetFileName(vtr_name) writer.SetInput(rtg) writer.Write() except: print 'Error writing VTR file: ', vtr_name
def writeVTR(vtr_name, scalar_fields, vector_fields, vtkX, vtkY, vtkZ, localZrange): """Writes a single VTR file per Python processor/variable Parameters: vtr_name - name of the VTR file scalar_fields - dictionary with scalar field arrays ordered [x, y, z], e.g. {'p': array[nx,ny,nz], 'rho0': array[nx,ny,nz]} vector_fields - dictionary with vector fields ordered [3, x, y, z], e.g. {'J': array[3,nx,ny,nz], 'B': array[3,nx,ny,nz]} vtkX, vtkY, vtkZ - VTR coordinates, see createVtrCoordinates() localZrange - local range for Z indices """ Nx = vtkX.GetNumberOfTuples() - 1 Ny = vtkY.GetNumberOfTuples() - 1 Nz=0 #2D numpoints = (Nx+1)*(Ny+1)*(Nz+1) rtg = vtk.vtkRectilinearGrid() rtg.SetExtent(0, Nx, 0, Ny, localZrange[0], localZrange[1]) rtg.SetXCoordinates(vtkX) rtg.SetYCoordinates(vtkY) vtk_data = [] array_list = [] for f in scalar_fields: vtk_data.append(vtk.vtkFloatArray()) vtk_data[-1].SetNumberOfTuples(numpoints) vtk_data[-1].SetNumberOfComponents(1) array_list.append(scalar_fields[f].swapaxes(0,2).flatten().astype("float32")) vtk_data[-1].SetVoidArray(array_list[-1], numpoints, 1) vtk_data[-1].SetName(f) if f == scalar_fields.keys()[0]: rtg.GetPointData().SetScalars(vtk_data[-1]) else: rtg.GetPointData().AddArray(vtk_data[-1]) #end for for f in vector_fields: vtk_data.append(vtk.vtkFloatArray()) vtk_data[-1].SetNumberOfTuples(numpoints*3) vtk_data[-1].SetNumberOfComponents(3) array_list.append(vector_fields[f].swapaxes(0,3).swapaxes(1,2).flatten().astype("float32")) vtk_data[-1].SetVoidArray(array_list[-1], numpoints*3, 1) vtk_data[-1].SetName(f) if f == vector_fields.keys()[0]: rtg.GetPointData().SetVectors(vtk_data[-1]) else: rtg.GetPointData().AddArray(vtk_data[-1]) #end for try: writer = vtk.vtkXMLRectilinearGridWriter() writer.SetFileName(vtr_name) writer.SetInput(rtg) writer.Write() except: print 'Error writing VTR file: ', vtr_name
def writeVTKrg(self, ofn): # Escritura en disco off = vtk.vtkXMLRectilinearGridWriter() off.SetFileName(ofn) off.SetDataModeToAscii() # Esto cambia con la version de VTK t = self.getVTKrg() self.meshtal.setVTKparams(t) if vtk.vtkVersion().GetVTKMajorVersion() >= 6: off.SetInputData(t) else: off.SetInput(t) off.Write() return
def WriteVtkFile(grid, filename, time=None, xml=False, binary=False): """Writes a vtk Grid object to a file. Parameters: grid -- vtk Grid Object filename -- the filename for the vtk file xml -- write the vtk in xml format binary -- writes in binary format; xml should be True """ if binary: xml=True if not xml: #write to .vtk file writer = vtkRectilinearGridWriter(); writer.SetFileName(filename) if binary: print writer.SetInputData(grid) writer.Write() if time: #manually add the time data vtk_file = open(filename, 'r+').read().split('\n') line_index = 0 line = '' _pos = [] while 'CELL_DATA' not in line: line = vtk_file[line_index] line_index += 1 vtk_file.insert(line_index-1,'FIELD FieldData 1\nTime 1 1 double\n' + str(time)) with open(filename, 'w+') as fo: fo.writelines('\n'.join(vtk_file)) else: if time: #insert time data; this has a bug on the vtk legacy writer, manually insert time field instead for vtk legacy files. timeArray = vtkDoubleArray() timeArray.SetName('Time') # print time, type(time) timeArray.InsertNextValue(time) grid.GetFieldData().AddArray(timeArray) writer = vtkXMLRectilinearGridWriter(); if binary: writer.SetDataModeToBinary() else: writer.SetDataModeToAscii() print filename writer.SetFileName(filename) writer.SetInputData(grid) writer.Write()
def writeVTR(vtr_name, scalar_fields, vector_fields, Nxc, Nyc, Nzlocal, vtkXcoordinates, vtkYcoordinates, vtkZcoordinates, rankproc, numproc): """Writes a single VTR file per Python processor/variable """ rtg = vtk.vtkRectilinearGrid() rtg.SetDimensions(Nxc + 1, Nyc + 1, Nzlocal) rtg.SetExtent(0, Nxc, 0, Nyc, rankproc * Nzc / numproc, (rankproc + 1) * Nzc / numproc) rtg.SetXCoordinates(vtkXcoordinates) rtg.SetYCoordinates(vtkYcoordinates) rtg.SetZCoordinates(vtkZcoordinates) vtk_data = [] array_list = [] for f in scalar_fields: vtk_data.append(vtk.vtkFloatArray()) vtk_data[-1].SetNumberOfTuples(numpoints) vtk_data[-1].SetNumberOfComponents(1) array_list.append(scalar_fields[f].swapaxes( 0, 2).flatten().astype("float32")) vtk_data[-1].SetVoidArray(array_list[-1], numpoints, 1) vtk_data[-1].SetName(f) if f == scalar_fields.keys()[0]: rtg.GetPointData().SetScalars(vtk_data[-1]) else: rtg.GetPointData().AddArray(vtk_data[-1]) #end for for f in vector_fields: vtk_data.append(vtk.vtkFloatArray()) vtk_data[-1].SetNumberOfTuples(numpoints * 3) vtk_data[-1].SetNumberOfComponents(3) array_list.append(vector_fields[f].swapaxes(0, 3).swapaxes( 1, 2).flatten().astype("float32")) vtk_data[-1].SetVoidArray(array_list[-1], numpoints * 3, 1) vtk_data[-1].SetName(f) if f == vector_fields.keys()[0]: rtg.GetPointData().SetVectors(vtk_data[-1]) else: rtg.GetPointData().AddArray(vtk_data[-1]) #end for try: writer = vtk.vtkXMLRectilinearGridWriter() writer.SetFileName(vtr_name) writer.SetInput(rtg) writer.Write() except: print 'Error writing VTR file: ', vtr_name
def save(self, fname: Union[str, Path], parallel: bool = True, compress: bool = True): """ Save as VTK file. Parameters ---------- fname : str or pathlib.Path Filename for writing. parallel : bool, optional Write data in parallel background process. Defaults to True. compress : bool, optional Compress with zlib algorithm. Defaults to True. """ if isinstance(self.vtk_data, vtk.vtkImageData): writer = vtk.vtkXMLImageDataWriter() elif isinstance(self.vtk_data, vtk.vtkRectilinearGrid): writer = vtk.vtkXMLRectilinearGridWriter() elif isinstance(self.vtk_data, vtk.vtkUnstructuredGrid): writer = vtk.vtkXMLUnstructuredGridWriter() elif isinstance(self.vtk_data, vtk.vtkPolyData): writer = vtk.vtkXMLPolyDataWriter() default_ext = '.' + writer.GetDefaultFileExtension() ext = Path(fname).suffix writer.SetFileName( str(fname) + (default_ext if default_ext != ext else '')) if compress: writer.SetCompressorTypeToZLib() else: writer.SetCompressorTypeToNone() writer.SetDataModeToBinary() writer.SetInputData(self.vtk_data) if parallel: try: mp_writer = mp.Process(target=self._write, args=(writer, )) mp_writer.start() except TypeError: writer.Write() else: writer.Write()
def write_polydata(input_data, filename, datatype=None): """ Write the given input data based on the file name extension. Args: input_data (vtkSTL/vtkPolyData/vtkXMLStructured/ vtkXMLRectilinear/vtkXMLPolydata/vtkXMLUnstructured/ vtkXMLImage/Tecplot): Input data. filename (str): Save path location. datatype (str): Additional parameter for vtkIdList objects. """ # Check filename format fileType = filename.split(".")[-1] if fileType == '': raise RuntimeError('The file does not have an extension') # Get writer if fileType == 'stl': writer = vtk.vtkSTLWriter() elif fileType == 'vtk': writer = vtk.vtkPolyDataWriter() elif fileType == 'vts': writer = vtk.vtkXMLStructuredGridWriter() elif fileType == 'vtr': writer = vtk.vtkXMLRectilinearGridWriter() elif fileType == 'vtp': writer = vtk.vtkXMLPolyDataWriter() elif fileType == 'vtu': writer = vtk.vtkXMLUnstructuredGridWriter() elif fileType == "vti": writer = vtk.vtkXMLImageDataWriter() elif fileType == "np" and datatype == "vtkIdList": output_data = np.zeros(input_data.GetNumberOfIds()) for i in range(input_data.GetNumberOfIds()): output_data[i] = input_data.GetId(i) output_data.dump(filename) return else: raise RuntimeError('Unknown file type %s' % fileType) # Set filename and input writer.SetFileName(filename) writer.SetInputData(input_data) writer.Update() # Write writer.Write()
def writeVTR(vtr_name, scalar_fields, vector_fields, Nxc, Nyc, Nzlocal, vtkXcoordinates, vtkYcoordinates, vtkZcoordinates, rankproc, numproc): """Writes a single VTR file per Python processor/variable """ rtg = vtk.vtkRectilinearGrid() rtg.SetDimensions(Nxc+1, Nyc+1, Nzlocal) rtg.SetExtent(0, Nxc, 0, Nyc, rankproc*Nzc/numproc, (rankproc+1)*Nzc/numproc) rtg.SetXCoordinates(vtkXcoordinates) rtg.SetYCoordinates(vtkYcoordinates) rtg.SetZCoordinates(vtkZcoordinates) vtk_data = [] array_list = [] for f in scalar_fields: vtk_data.append(vtk.vtkFloatArray()) vtk_data[-1].SetNumberOfTuples(numpoints) vtk_data[-1].SetNumberOfComponents(1) array_list.append(scalar_fields[f].swapaxes(0,2).flatten().astype("float32")) vtk_data[-1].SetVoidArray(array_list[-1], numpoints, 1) vtk_data[-1].SetName(f) if f == scalar_fields.keys()[0]: rtg.GetPointData().SetScalars(vtk_data[-1]) else: rtg.GetPointData().AddArray(vtk_data[-1]) #end for for f in vector_fields: vtk_data.append(vtk.vtkFloatArray()) vtk_data[-1].SetNumberOfTuples(numpoints*3) vtk_data[-1].SetNumberOfComponents(3) array_list.append(vector_fields[f].swapaxes(0,3).swapaxes(1,2).flatten().astype("float32")) vtk_data[-1].SetVoidArray(array_list[-1], numpoints*3, 1) vtk_data[-1].SetName(f) if f == vector_fields.keys()[0]: rtg.GetPointData().SetVectors(vtk_data[-1]) else: rtg.GetPointData().AddArray(vtk_data[-1]) #end for try: writer = vtk.vtkXMLRectilinearGridWriter() writer.SetFileName(vtr_name) writer.SetInput(rtg) writer.Write() except: print 'Error writing VTR file: ', vtr_name
def savePolydata(polydata, file_name, binary=False, color_array_name=None): """ Save a vtk polydata to a supported format file Parameters ---------- polydata : vtkPolyData file_name : string """ # get file extension (type) file_extension = file_name.split(".")[-1].lower() if file_extension == "vtk": writer = vtk.vtkPolyDataWriter() elif file_extension == "fib": writer = vtk.vtkPolyDataWriter() elif file_extension == "ply": writer = vtk.vtkPLYWriter() elif file_extension == "stl": writer = vtk.vtkSTLWriter() elif file_extension == "xml": writer = vtk.vtkXMLPolyDataWriter() elif file_extension == "vtp": writer = vtk.vtkXMLPolyDataWriter() elif file_extension == "vti": writer = vtk.vtkXMLImageDataWriter() elif file_extension == "vts": writer = vtk.vtkXMLStructuredGridWriter() elif file_extension == "vtu": writer = vtk.vtkXMLUnstructuredGridWriter() elif file_extension == "vtr": writer = vtk.vtkXMLRectilinearGridWriter() elif file_extension == "obj": raise Exception("mni obj or Wavefront obj ?") writer.SetFileName(file_name) writer.SetInputData(polydata) if color_array_name is not None: writer.SetArrayName(color_array_name) if binary: writer.SetFileTypeToBinary() writer.Update() writer.Write()
def save(self, filename, binary=True): """ Writes a rectilinear grid to disk. Parameters ---------- filename : str Filename of grid to be written. The file extension will select the type of writer to use. ".vtk" will use the legacy writer, while ".vtr" will select the VTK XML writer. binary : bool, optional Writes as a binary file by default. Set to False to write ASCII. Notes ----- Binary files write much faster than ASCII, but binary files written on one system may not be readable on other systems. Binary can be used only with the legacy writer. """ filename = os.path.abspath(os.path.expanduser(filename)) # Use legacy writer if vtk is in filename if '.vtk' in filename: writer = vtk.vtkRectilinearGridWriter() legacy = True elif '.vtr' in filename: writer = vtk.vtkXMLRectilinearGridWriter() legacy = False else: raise Exception('Extension should be either ".vtr" (xml) or' + '".vtk" (legacy)') # Write writer.SetFileName(filename) writer.SetInputData(self) if binary and legacy: writer.SetFileTypeToBinary() writer.Write()
def writeVTRFile(fileName,vtkRectilinearGrid): '''Function to write vtk rectilinear grid (vtr).''' Writer = vtk.vtkXMLRectilinearGridWriter() Writer.SetInput(vtkRectilinearGrid) Writer.SetFileName(fileName) Writer.Update()
vtk.vtkDoubleArray(), ] rGrid.SetDimensions(*grid) for i, points in enumerate(coords): for point in points: coordArray[i].InsertNextValue(point) rGrid.SetXCoordinates(coordArray[0]) rGrid.SetYCoordinates(coordArray[1]) rGrid.SetZCoordinates(coordArray[2]) # ------------------------------------------ output result --------------------------------------- if name: writer = vtk.vtkXMLRectilinearGridWriter() writer.SetCompressorTypeToZLib() writer.SetDataModeToBinary() writer.SetFileName( os.path.join( os.path.split(name)[0], os.path.splitext(os.path.split(name)[1])[0] + '_{}({})'.format(options.pos, options.mode) + '.' + writer.GetDefaultFileExtension())) else: writer = vtk.vtkDataSetWriter() writer.SetHeader('# powered by ' + scriptID) writer.WriteToOutputStringOn() if vtk.VTK_MAJOR_VERSION <= 5: writer.SetInput(rGrid) else: writer.SetInputData(rGrid)
def getcutout(request, webargs): params = "parameters=%s" % webargs w = webargs.split("/") ts = int(w[3].split(',')[0]) te = int(w[3].split(',')[1]) #o = odbccutout.OdbcCutout() if ((len(w) >= 8) and (w[7] == 'vtk')): #Setup temporary file (would prefer an in-memory buffer, but this will have to do for now) if (len(w) >= 10): tspacing = int(w[8].split(",")[0]) else: tspacing = 1 cfieldlist = w[2].split(",") firstval = cfieldlist[0] if ((firstval == 'cvo') or (firstval == 'qcc')): #we may need to return a vtp file tmp = NamedTemporaryFile(suffix='.vtp') suffix = 'vtp' writer = vtk.vtkXMLPolyDataWriter() outfile = w[7] + '-contour' elif (w[1] == "channel"): tmp = NamedTemporaryFile(suffix='.vtr') suffix = 'vtr' writer = vtk.vtkXMLRectilinearGridWriter() outfile = 'cutout' + w[7] else: tmp = NamedTemporaryFile(suffix='.vti') suffix = 'vti' writer = vtk.vtkXMLImageDataWriter() outfile = 'cutout' + w[7] writer.SetFileName(tmp.name) writer.SetCompressorTypeToZLib() writer.SetDataModeToBinary() #if multiple timesteps, zip the file. if ((te-ts) > 1): #Write each timestep to file and read it back in. Seems to be the only way I know how to put all timesteps in one file for now #Create a timestep for each file and then send the user a zip file ziptmp = NamedTemporaryFile(suffix='.zip') z = zipfile.ZipFile(ziptmp.name, 'w') for timestep in range (ts,te, tspacing ): image = odbccutout.OdbcCutout().getvtkimage(webargs, timestep) writer.SetInputData(image) writer.SetFileName(tmp.name) writer.Write() #Now add this file to the zipfile z.write(tmp.name, 'cutout' + str(timestep) + '.' + suffix) z.close() ct = 'application/zip' suffix = 'zip' response = HttpResponse(ziptmp, content_type=ct) else: image = odbccutout.OdbcCutout().getvtkimage(webargs, ts) writer.SetInputData(image) writer.SetFileName(tmp.name) writer.Write() ct = 'data/vtk' response = HttpResponse(tmp, content_type=ct) response['Content-Disposition'] = 'attachment;filename=' + outfile +'.' + suffix else: #for backward compatibility, we serve hdf5 if not specified #Create an HDF5 file here h5file = odbccutout.OdbcCutout().gethdf(webargs) response = HttpResponse(h5file, content_type='data/hdf5') attach = 'attachment;filename=' + w[1] + '.h5' response['Content-Disposition'] = attach return response
def write_vtr(data, fname='tmp/data.vtr', down_sampling=(5, 5, 5)): """ Write the reconstructed data (img stackes) to vtr file (retangular grid) Parameters ---------- data : np.3darray reconstructed 3D image stacks with axis=0 as the omega fname : str file name of the output vtr file down_sampling : tuple down sampling steps along three axes Returns ------- None """ # vtk is only used here, therefore doing an in module import import vtk from vtk.util import numpy_support # convert to unit8 can significantly reduce the output vtr file # size, or just do a severe down-sampling data = _normalize_imgstacks(data[::down_sampling[0], ::down_sampling[1], ::down_sampling[2],]) * 255 # --init rectangular grid rGrid = vtk.vtkRectilinearGrid() coordArray = [vtk.vtkDoubleArray(), vtk.vtkDoubleArray(), vtk.vtkDoubleArray(), ] coords = np.array([np.arange(data.shape[i]) for i in range(3)]) coords = [0.5 * np.array([3.0 * coords[i][0] - coords[i][0 + int(len(coords[i]) > 1)]] + \ [coords[i][j-1] + coords[i][j] for j in range(1,len(coords[i]))] + \ [3.0 * coords[i][-1] - coords[i][-1 - int(len(coords[i]) > 1)]] ) for i in range(3) ] grid = np.array(list(map(len,coords)),'i') rGrid.SetDimensions(*grid) for i,points in enumerate(coords): for point in points: coordArray[i].InsertNextValue(point) rGrid.SetXCoordinates(coordArray[0]) rGrid.SetYCoordinates(coordArray[1]) rGrid.SetZCoordinates(coordArray[2]) # vtk requires x to be the fast axis # NOTE: # Proper coordinate transformation is required to connect the # tomography data with other down-stream analysis (such as FF-HEDM # and NF-HEDM). imgstacks = np.swapaxes(data, 0, 2) VTKarray = numpy_support.numpy_to_vtk(num_array=imgstacks.flatten().astype(np.uint8), deep=True, array_type=vtk.VTK_UNSIGNED_CHAR, ) VTKarray.SetName('img') rGrid.GetCellData().AddArray(VTKarray) rGrid.Modified() if vtk.VTK_MAJOR_VERSION <= 5: rGrid.Update() # output to file writer = vtk.vtkXMLRectilinearGridWriter() writer.SetFileName(fname) writer.SetDataModeToBinary() writer.SetCompressorTypeToZLib() if vtk.VTK_MAJOR_VERSION <= 5: writer.SetInput(rGrid) else: writer.SetInputData(rGrid) writer.Write()
def write_polydata(input_data, filename, datatype=None, file_type="ascii"): """ Write the given input data based on the file name extension. Args: file_type (string): Filetype of output input_data (vtkSTL/vtkPolyData/vtkXMLStructured/ vtkXMLRectilinear/vtkXMLPolydata/vtkXMLUnstructured/ vtkXMLImage/Tecplot): Input data. filename (str): Save path location. datatype (str): Additional parameter for vtkIdList objects. """ # Check filename format fileType = filename.split(".")[-1] if fileType == '': raise RuntimeError('The file does not have an extension') # Get writer if fileType == 'stl': writer = vtk.vtkSTLWriter() elif fileType == 'vtk': # Set reader based on data type if isinstance(input_data, vtk.vtkUnstructuredGrid): writer = vtk.vtkUnstructuredGridWriter() elif isinstance(input_data, vtk.vtkStructuredGrid): writer = vtk.vtkStructuredGridWriter() elif isinstance(input_data, vtk.vtkRectilinearGrid): writer = vtk.vtkRectilinearGridWriter() elif isinstance(input_data, vtk.vtkStructuredPoints) or \ isinstance(input_data, vtk.vtkImageData): writer = vtk.vtkStructuredPointsWriter() elif isinstance(input_data, vtk.vtkPolyData): writer = vtk.vtkPolyDataWriter() if file_type.lower() == "ascii": writer.SetFileType(1) elif file_type.lower() == "binary": writer.SetFileType(0) else: raise ValueError("Invalid file type, can only be ascii or binary") elif fileType == 'vts': writer = vtk.vtkXMLStructuredGridWriter() elif fileType == 'vtr': writer = vtk.vtkXMLRectilinearGridWriter() elif fileType == 'vtp': writer = vtk.vtkXMLPolyDataWriter() elif fileType == 'vtu': writer = vtk.vtkXMLUnstructuredGridWriter() elif fileType == "vti": writer = vtk.vtkXMLImageDataWriter() elif fileType == "np" and datatype == "vtkIdList": output_data = np.zeros(input_data.GetNumberOfIds()) for i in range(input_data.GetNumberOfIds()): output_data[i] = input_data.GetId(i) output_data.dump(filename) return else: raise RuntimeError('Unknown file type %s' % fileType) # Set filename and input writer.SetFileName(filename) writer.SetInputData(input_data) writer.Update() # Write writer.Write()
def BFDTD_h5_to_vts(h5file, basepath, total_lattice_size=None, requested_dataset=[], verbosity=0, x_relative_range=[0,1], y_relative_range=[0,1], z_relative_range=[0,1], real_units=False, dry_run=False): ''' Converts BFDTD h5 files to VTS files. .. todo:: need py2-compatible bfdtd-parser for direct creation .. todo:: when selecting a smaller mesh region for speed, we also need to change the size of the VTS grid (but keep coords correct)... ''' requested_arrays = ['material', 'E', 'electric_energy_density'] #requested_arrays = [] #x_relative_range = [1/3, 2/3] #y_relative_range = [1/3, 2/3] #z_relative_range = [1/3, 2/3] print('x_relative_range: {}'.format(x_relative_range)) print('y_relative_range: {}'.format(y_relative_range)) print('z_relative_range: {}'.format(z_relative_range)) print('{} -> {}.vts'.format(h5file, basepath)) # read in .h5 file with h5py.File(h5file, "r") as HDF5_file_object: print('Reading from ' + h5file) (mylattice, complete_dataset_list) = h5_setupLattice(HDF5_file_object, total_lattice_size, requested_dataset) (Nx, Ny, Nz) = mylattice.getResolution() (a1, a2, a3) = mylattice.getLatticeVectors() (xmesh, ymesh, zmesh) = mylattice.getMesh() Npoints = Nx*Ny*Nz # create the vtkPoints structure for the coordinates #points = vtk.vtkPoints() #points.SetNumberOfPoints(Npoints) if requested_dataset: dataset_list = requested_dataset else: dataset_list = complete_dataset_list material_data = None for dataset_name in dataset_list: current_data = HDF5_file_object[dataset_name] if 'material' in current_data.dtype.names: material_data = current_data break if material_data: print('Found material data in: {}'.format(material_data.name)) else: print('Warning: No material data found. No electric energy density data can be calculated.') for dataset_name in dataset_list: data = HDF5_file_object[dataset_name] # create VTK data arrays print('Creating VTK data arrays...') available_arrays = [] if data.dtype.names == ('E', 'H', 'Pow', 'material'): print('time snapshot mode') if 'E' in requested_arrays: E_array = createvtkArray('E', Npoints, ('x', 'y', 'z')) available_arrays.append(E_array) if 'H' in requested_arrays: H_array = createvtkArray('H', Npoints, ('x', 'y', 'z')) available_arrays.append(H_array) if 'Pow' in requested_arrays: Pow_array = createvtkArray('Pow', Npoints, ('Pow',)) available_arrays.append(Pow_array) if 'material' in requested_arrays: material_array = createvtkArray('material', Npoints, ('material',)) available_arrays.append(material_array) #available_arrays = (E_array, H_array, Pow_array, material_array) elif data.dtype.names == ('E', 'H'): print('frequency snapshot mode') if 'E' in requested_arrays: (E_re_array, E_im_array, E_mod_array, E_phase_array) = createComplexArrays('E', Npoints) available_arrays.extend([E_re_array, E_im_array, E_mod_array, E_phase_array]) if 'H' in requested_arrays: (H_re_array, H_im_array, H_mod_array, H_phase_array) = createComplexArrays('H', Npoints) available_arrays.extend([H_re_array, H_im_array, H_mod_array, H_phase_array]) if 'S' in requested_arrays: (S_re_array, S_im_array, S_mod_array, S_phase_array) = createComplexArrays('S', Npoints) available_arrays.extend([S_re_array, S_im_array, S_mod_array, S_phase_array]) #available_arrays = [E_re_array, E_im_array, E_mod_array, E_phase_array, #H_re_array, H_im_array, H_mod_array, H_phase_array, #S_re_array, S_im_array, S_mod_array, S_phase_array] if material_data: if 'electric_energy_density' in requested_arrays: electric_energy_density_array = createvtkArray('electric_energy_density', Npoints, ('electric_energy_density',)) available_arrays.append(electric_energy_density_array) if 'magnetic_energy_density' in requested_arrays: magnetic_energy_density_array = createvtkArray('magnetic_energy_density', Npoints, ('magnetic_energy_density',)) available_arrays.append(magnetic_energy_density_array) else: raise Exception('Unsupported data type.') print('...done') last_info_time = time.time() x_range = range( int(round(x_relative_range[0]*Nx)), int(round(x_relative_range[1]*Nx)) ) y_range = range( int(round(y_relative_range[0]*Ny)), int(round(y_relative_range[1]*Ny)) ) z_range = range( int(round(z_relative_range[0]*Nz)), int(round(z_relative_range[1]*Nz)) ) Nx_partial = len(x_range) Ny_partial = len(y_range) Nz_partial = len(z_range) Npoints_partial = Nx_partial*Ny_partial*Nz_partial print( 'Range to fill:' ) print( 'x: {} -> size={}/{}'.format((x_range[0], x_range[-1]), Nx_partial, Nx) ) print( 'y: {} -> size={}/{}'.format((y_range[0], y_range[-1]), Ny_partial, Ny) ) print( 'z: {} -> size={}/{}'.format((z_range[0], z_range[-1]), Nz_partial, Nz) ) print( 'total points to fill: {}/{}'.format(Npoints_partial, Npoints) ) if dry_run: return print('Starting loops') # fill the vtkPoints and vtkScalarArray for k in z_range: #range(Nz): for j in y_range: #range(Ny): for i in x_range: #range(Nx): #for k in range(Nz): #for j in range(Ny): #for i in range(Nx): offset = i + j*Nx + k*Nx*Ny #coord = xmesh[i]*a1 + ymesh[j]*a2 + zmesh[k]*a3 #points.SetPoint(offset, coord) if 'E' in data.dtype.names: E = data[i, j, k]['E'] if 'H' in data.dtype.names: H = data[i, j, k]['H'] if 'Pow' in data.dtype.names: if 'Pow' in requested_arrays: Pow_array.SetTuple1(offset, data[i, j, k]['Pow']) if 'material' in data.dtype.names: if 'material' in requested_arrays: material_array.SetTuple1(offset, data[i, j, k]['material']) if data.dtype.names == ('E', 'H', 'Pow', 'material'): if 'E' in requested_arrays: E_array.SetTuple3(offset, *E) if 'H' in requested_arrays: H_array.SetTuple3(offset, *H) elif data.dtype.names == ('E', 'H'): S = numpy.cross(E, numpy.conj(H)) if 'E' in requested_arrays: E_mod = setTupleComplex(offset, E, E_re_array, E_im_array, E_mod_array, E_phase_array) if 'H' in requested_arrays: H_mod = setTupleComplex(offset, H, H_re_array, H_im_array, H_mod_array, H_phase_array) if 'S' in requested_arrays: S_mod = setTupleComplex(offset, S, S_re_array, S_im_array, S_mod_array, S_phase_array) if material_data: # We could use numpy.vdot(a,a) for the conjugate dot product with real/absolute, but since we use absolute() before anyway, we may as well use the resulting |Ei| values. if 'electric_energy_density' in requested_arrays: if real_units: epsilon = material_data[i, j, k]['material']*constants.physcon.value('elec-const') else: epsilon = material_data[i, j, k]['material'] electric_energy_density = epsilon*numpy.dot(E_mod, E_mod) electric_energy_density_array.SetTuple1(offset, electric_energy_density) if 'magnetic_energy_density' in requested_arrays: if real_units: mu = constants.physcon.value('magn-const') else: mu = 1 magnetic_energy_density = mu*numpy.dot(H_mod, H_mod) magnetic_energy_density_array.SetTuple1(offset, magnetic_energy_density) else: raise Exception('Unsupported data type.') if time.time() - last_info_time > 5 or verbosity > 1: #print('Progress: {}/{} = {} %'.format(offset+1, Npoints, 100*(offset+1)/Npoints)) offset_partial = (i-x_range[0]) + (j-y_range[0])*Nx_partial + (k-z_range[0])*Nx_partial*Ny_partial print('Progress: {}/{} = {} %'.format(offset_partial+1, Npoints_partial, 100*(offset_partial+1)/Npoints_partial)) last_info_time = time.time() print('Loops done.') # create structured grid #dataset_vts = vtk.vtkStructuredGrid() #dataset_vts.SetDimensions(Nx, Ny, Nz) #dataset_vts.SetPoints(points) # create rectilinear grid xCoords = vtkScalarArray() for i in range(len(xmesh)): xCoords.InsertNextValue(xmesh[i]) yCoords = vtkScalarArray() for i in range(len(ymesh)): yCoords.InsertNextValue(ymesh[i]) zCoords = vtkScalarArray() for i in range(len(zmesh)): zCoords.InsertNextValue(zmesh[i]) dataset_vtr = vtk.vtkRectilinearGrid() dataset_vtr.SetDimensions(len(xmesh),len(ymesh),len(zmesh)) dataset_vtr.SetXCoordinates(xCoords) dataset_vtr.SetYCoordinates(yCoords) dataset_vtr.SetZCoordinates(zCoords) for A in available_arrays: dataset_vtr.GetPointData().AddArray(A) # write out VTK file(s) basepath_snapshot = basepath + data.name.replace('/','_') #writer_vts = vtk.vtkXMLStructuredGridWriter() #writer_vts.SetFileName(basepath_snapshot + '.' + writer_vts.GetDefaultFileExtension()) #writer_vts.SetInputData(dataset_vts) #writer_vts.Write() writer_vtr = vtk.vtkXMLRectilinearGridWriter() writer_vtr.SetFileName(basepath_snapshot + '.' + writer_vtr.GetDefaultFileExtension()) writer_vtr.SetInputData(dataset_vtr) writer_vtr.Write() print('{} -> {}'.format(data.name, writer_vtr.GetFileName())) return
def main(): if len(argv) == 1: print help_note return else: mfiles = argv[1:] # normalize to 400 W # c1 = 3.1567674e6 # W/MeV c1 = ( 400e6 # Kinetic neutron power, W * (40.0 / 360.0) # 40 grad sector / 14.0791) # mean neutron energy, MeV c2 = c1 / 1.60218e-13 # Conversion factor, J/MeV print normalization_note.format(c1, c2) # mb = vtk.vtkMultiBlockDataSet() # af = vtk.vtkAppendFilter() # # nblocks = 0 for meshtal in mfiles: print 'Reading ', meshtal, title, nps, td = read_meshtal(meshtal, use_uncertainties=False) print 'complete' for tn, t in td.items(): if t.geom.lower() not in ('xyz', 'rect'): continue vals = array(t.values) errs = array(t.errors) # reshape arrays, to account for energy bins: sh = (len(t.emesh), len(t.imesh), len(t.jmesh), len(t.kmesh)) if sh[0] > 1: print 'Meshtally {} contains {} energy bins. Only "total" is written to vtk file'.format( tn, sh[0]) rvals = reshape(vals, sh) rerrs = reshape(errs, sh) # prepare grid boundaries x = vtk.vtkDoubleArray() y = vtk.vtkDoubleArray() z = vtk.vtkDoubleArray() x.SetName('x') y.SetName('y') z.SetName('z') for a, i0, l in ((x, t.origin.x, t.imesh), (y, t.origin.y, t.jmesh), (z, t.origin.z, t.kmesh)): for v in [i0] + l: a.InsertNextValue(v) # put boundaries and data into VTK rectilinear grid grid = vtk.vtkRectilinearGrid() grid.SetDimensions(x.GetNumberOfTuples(), y.GetNumberOfTuples(), z.GetNumberOfTuples()) grid.SetXCoordinates(x) grid.SetYCoordinates(y) grid.SetZCoordinates(z) # prepare array for tally values and errors # Value and error will be rwitten as separate scalar arrays. In this form the threshold # filter can be applied in paraview. This filter cannot be applied to an array of vectors. val = vtk.vtkDoubleArray() # Data arrays containing values and errors should heve the same name # for all datasets. In this case it is more simple to replace one data # set with another one in the paraview state. WHen datasets have # different names, one needs to change data arrays to be displayed # manually for all views. # val.SetName('{} t{} val'.format(meshtal, tn)) # val.SetName('t{} val'.format(tn)) val.SetName('val') val.SetNumberOfComponents(1) val.SetNumberOfTuples(grid.GetNumberOfCells()) err = vtk.vtkDoubleArray() # err.SetName('{} t{} err'.format(meshtal, tn)) # err.SetName('t{} err'.format(tn)) err.SetName('err') err.SetNumberOfComponents(1) # value and rel.err. err.SetNumberOfTuples(grid.GetNumberOfCells()) # Put tally results to values array in particular order xlen = x.GetNumberOfTuples() - 1 ylen = y.GetNumberOfTuples() - 1 zlen = z.GetNumberOfTuples() - 1 ival = 0 # index for meshtal vmax = max(t.values) vmin = vmax for i in range(xlen): for j in range(ylen): for k in range(zlen): idx = grid.ComputeCellId((i, j, k)) # hn = t.values[ival] # en = t.errors[ival] hn = rvals[-1, i, j, k] en = rerrs[-1, i, j, k] # Replace zero values and zero errors with NaN: if en > 0: # compute non-negative min if hn < vmin: vmin = hn # else: # # Replace zero values # hn = -1.0 # en = -1.0 val.SetTuple(idx, (hn, )) err.SetTuple(idx, (en, )) ival += 1 # Field data to store meshtal metadata df = vtk.vtkStringArray() df.SetName('Meshtal description') df.SetNumberOfTuples(4) df.SetValue(0, 'Meshtal file {}, tally {}'.format(meshtal, tn)) df.SetValue(1, title) df.SetValue(2, str(nps)) df.SetValue(3, 'min: {}, max: {}'.format(vmin, vmax)) # Attach values to the grid grid.GetCellData().AddArray(val) grid.GetCellData().AddArray(err) grid.GetFieldData().AddArray(df) # # Attach current grid to multigrid # mb.SetBlock(nblocks, grid) # af.AddInputData(grid) # nblocks += 1 # write to file: writer = vtk.vtkXMLRectilinearGridWriter() if _vtkVersion[0] == '6': writer.SetInputData(grid) else: # _vtkVersion[0] == '5': writer.SetInput(grid) writer.SetFileName('{}_t{}.vtr'.format(meshtal, tn)) ws = writer.Write() if ws == 1: print 'Tally {} from {}: non-negative range from {:12.5e} to {:12.5e}'.format( tn, writer.GetFileName(), vmin, vmax) else: print 'Failed to write meshtally {} from {}'.format( tn, writer.GetFileName())
def rectangular(fname, xbounds, ybounds, zbounds, vals, errs=None, descr=[]): """ Write rectangular data to file `fname`. Arrays xbounds, ybounds and zbounds are boundary coordinates. Array `vals` is a 3-dimentional array of the shape (len(x)-1, len(y)-1, len(z)-1). Put strings from `descr` as description of the data. """ # prepare grid boundaries x = vtk.vtkDoubleArray() y = vtk.vtkDoubleArray() z = vtk.vtkDoubleArray() x.SetName('x') y.SetName('y') z.SetName('z') for v in xbounds: x.InsertNextValue(v) for v in ybounds: y.InsertNextValue(v) for v in zbounds: z.InsertNextValue(v) # put boundaries and data into VTK rectilinear grid grid = vtk.vtkRectilinearGrid() grid.SetDimensions(x.GetNumberOfTuples(), y.GetNumberOfTuples(), z.GetNumberOfTuples()) grid.SetXCoordinates(x) grid.SetYCoordinates(y) grid.SetZCoordinates(z) # prepare array for tally values and errors # Value and error will be rwitten as separate scalar arrays. In this form # the threshold filter can be applied in paraview. This filter cannot be # applied to an array of vectors. val = vtk.vtkDoubleArray() # Data arrays containing values and errors should heve the same name # for all datasets. In this case it is more simple to replace one data # set with another one in the paraview state. WHen datasets have # different names, one needs to change data arrays to be displayed # manually for all views. val.SetName('val') val.SetNumberOfComponents(1) val.SetNumberOfTuples(grid.GetNumberOfCells()) if errs is not None: err = vtk.vtkDoubleArray() err.SetName('err') err.SetNumberOfComponents(1) err.SetNumberOfTuples(grid.GetNumberOfCells()) # Put tally results to values array in particular order xlen = x.GetNumberOfTuples() - 1 ylen = y.GetNumberOfTuples() - 1 zlen = z.GetNumberOfTuples() - 1 vmax = amax(vals[vals > 0.0]) vmin = amin(vals[vals > 0.0]) for i in range(xlen): for j in range(ylen): for k in range(zlen): idx = grid.ComputeCellId((i, j, k)) hn = vals[i, j, k] if errs is not None: en = errs[i, j, k] val.SetTuple(idx, (hn, )) if errs is not None: err.SetTuple(idx, (en, )) # Field data to store metadata df = vtk.vtkStringArray() df.SetName('Description') df.SetNumberOfTuples(len(descr) + 2) df.SetValue(0, 'positive min: {}'.format(vmin)) df.SetValue(1, 'positive max: {}'.format(vmax)) for i, s in enumerate(descr): df.SetValue(i + 2, s) # Attach values to the grid grid.GetCellData().AddArray(val) if errs is not None: grid.GetCellData().AddArray(err) grid.GetFieldData().AddArray(df) # write to file: writer = vtk.vtkXMLRectilinearGridWriter() if _vtkVersion[0] in '68': writer.SetInputData(grid) else: # _vtkVersion[0] == '5': writer.SetInput(grid) writer.SetFileName(fname) ws = writer.Write() return ws
f_vals = vtk.vtkDoubleArray() f_vals.SetName("function_vals") f_vals.SetNumberOfValues(grid.GetNumberOfPoints()) # prepare the grid_time FieldData grid_time = vtk.vtkDoubleArray() grid_time.SetName("grid_time") grid_time.InsertNextValue(0) for i in range(len(t)): fname = vtr_base + str(i).zfill(int(math.log10(len(t)+1))) + ".vtr" if opts.verbose: sys.stdout.write("Outputting to " + fname + "\n"); writer = vtk.vtkXMLRectilinearGridWriter() writer.SetFileName(fname) # insert the grid_time field data grid_time.InsertValue(0, t[i]) grid.GetFieldData().AddArray(grid_time) # construct the function_vals and insert it for ptid in range(grid.GetNumberOfPoints()): xyz = grid.GetPoint(ptid) f_vals.InsertValue(ptid, fcn[grid_index[xyz] + i*nx*ny*nz]) grid.GetPointData().AddArray(f_vals) # update and write the file grid.Update() writer.SetInputConnection(grid.GetProducerPort())
def getvtk(self, ci): contour = False firstval = ci.datafields.split(',')[0] if ((firstval == 'cvo') or (firstval == 'qcc') or (firstval == 'pcvo')): #we may need to return a vtp file tmp = NamedTemporaryFile(suffix='.vtp') suffix = 'vtp' writer = vtk.vtkXMLPolyDataWriter() outfile = ci.dataset + '-contour' contour = True elif (ci.dataset == "channel"): tmp = NamedTemporaryFile(suffix='.vtr') suffix = 'vtr' writer = vtk.vtkXMLRectilinearGridWriter() outfile = ci.dataset else: tmp = NamedTemporaryFile(suffix='.vti') suffix = 'vti' writer = vtk.vtkXMLImageDataWriter() outfile = ci.dataset writer.SetFileName(tmp.name) writer.SetCompressorTypeToZLib() writer.SetDataModeToBinary() #If a preview, change the writer to write an ascii oldschool vtk format if (firstval == 'pcvo'): suffix = 'vtk' writer = vtk.vtkPolyDataWriter() writer.SetFileTypeToASCII() #if multiple timesteps, zip the file. if (ci.tlen > 1): #Write each timestep to file and read it back in. Seems to be the only way I know how to put all timesteps in one file for now #Create a timestep for each file and then send the user a zip file ziptmp = NamedTemporaryFile(suffix='.zip') z = zipfile.ZipFile(ziptmp.name, 'w') #, 'allowZip64' this should be added to get zipfiles > 2gb. Should we allow this? for timestep in range (ci.tstart,ci.tstart+ci.tlen, ci.tstep ): if (contour == True): #If we have a contour, call the cache version. image = self.getcachedcontour(ci, timestep) else: image = self.getvtkdata(ci, timestep) writer.SetInputData(image) writer.SetFileName(tmp.name) writer.Write() #Now add this file to the zipfile z.write(tmp.name, 'cutout' + str(timestep) + '.' + suffix) image = None z.close() #Try to clean up here writer = None ct = 'application/zip' suffix = 'zip' response = HttpResponse(ziptmp, content_type=ct) else: #print("Single Timestep") if (contour == True): #If we have a contour, call the cache version. image = self.getcachedcontour(ci, ci.tstart) else: image = self.getvtkdata(ci, ci.tstart) writer.SetInputData(image) writer.SetFileName(tmp.name) writer.EncodeAppendedDataOff() writer.Write() ct = 'applicaton/' + suffix response = HttpResponse(tmp, content_type=ct) response['Content-Disposition'] = 'attachment;filename=' + outfile +'.' + suffix return response