def vtk_bin_to_ascii(fin, fout, origin, spacing): """Convert VTK file to ascii format. Intended for VTK files with 3D voxel data. Also adjusts origin and spacing. Args: fin (str): input filename fout (str): output filename origin (list): origin of coordinate system spacing (list): distance between the nodes in structured mesh """ reader = vtk.vtkDataSetReader() reader.SetFileName(fin) reader.Update() data = vtk.vtkImageData() data.ShallowCopy(reader.GetOutput()) data.SetOrigin(origin) data.SetSpacing(spacing) writer = vtk.vtkStructuredPointsWriter() if vtk.VTK_MAJOR_VERSION <= 5: writer.SetInputConnection(data.GetProducerPort()) else: writer.SetInputData(data) writer.SetFileName(fout) writer.Write()
def writePicture(filename,image): #image reshape imageLength=image.shape[0] imageWidth=image.shape[1] image=image.reshape(imageLength*imageWidth,1) #create a data array to stock these values data_array=vtk.vtkFloatArray() data_array.SetNumberOfValues(len(image)) for i in range(0,len(image)): data_array.SetValue(i,image[i][0]) #create an ImageData called vtkStructuredPoints which stocks the pixel/voxel value of the image strPts=vtk.vtkStructuredPoints() strPts.SetDimensions(imageWidth,imageLength,1) strPts.SetOrigin(0.,0.,0.) strPts.SetExtent(0,imageWidth-1,0,imageLength-1,0,0) strPts.SetNumberOfScalarComponents(1) strPts.SetScalarTypeToFloat() strPts.AllocateScalars() strPts.GetPointData().SetScalars(data_array) strPts.Update() #print the image to an output file writer=vtk.vtkStructuredPointsWriter() writer.SetFileName(filename) writer.SetInput(strPts) writer.Update() writer.Write()
def __init__(self, module_manager): # call parent constructor ModuleBase.__init__(self, module_manager) self._writer = vtk.vtkStructuredPointsWriter() module_utils.setup_vtk_object_progress( self, self._writer, 'Writing vtk structured points data') # we do this to save space - if you're going to be transporting files # to other architectures, change this to ASCII # we've set this back to ASCII. Seems the binary mode is screwed # for some files and manages to produce corrupt files that segfault # VTK on Windows. self._writer.SetFileTypeToASCII() # ctor for this specific mixin FilenameViewModuleMixin.__init__( self, 'Select a filename', 'VTK data (*.vtk)|*.vtk|All files (*)|*', {'vtkStructuredPointsWriter': self._writer}, fileOpen=False) # set up some defaults self._config.filename = '' self.sync_module_logic_with_config()
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkStructuredPointsWriter(), 'Writing vtkStructuredPoints.', ('vtkStructuredPoints',), (), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def write_vtk_image(vtkIm, fn, M=None): """ This function writes a vtk image to disk Args: vtkIm: the vtk image to write fn: file name Returns: None """ print("Writing vti with name: ", fn) if M is not None: M.Invert() reslice = vtk.vtkImageReslice() reslice.SetInputData(vtkIm) reslice.SetResliceAxes(M) reslice.SetInterpolationModeToNearestNeighbor() reslice.Update() vtkIm = reslice.GetOutput() _, extension = os.path.splitext(fn) if extension == '.vti': writer = vtk.vtkXMLImageDataWriter() elif extension == '.vtk': writer = vtk.vtkStructuredPointsWriter() elif extension == '.mhd': writer = vtk.vtkMetaImageWriter() else: raise ValueError("Incorrect extension " + extension) writer.SetInputData(vtkIm) writer.SetFileName(fn) writer.Update() writer.Write() return
def writePicture(filename, image): #image reshape imageLength = image.shape[0] imageWidth = image.shape[1] image = image.reshape(imageLength * imageWidth, 1) #create a data array to stock these values data_array = vtk.vtkFloatArray() data_array.SetNumberOfValues(len(image)) for i in range(0, len(image)): data_array.SetValue(i, image[i][0]) #create an ImageData called vtkStructuredPoints which stocks the pixel/voxel value of the image strPts = vtk.vtkStructuredPoints() strPts.SetDimensions(imageWidth, imageLength, 1) strPts.SetOrigin(0., 0., 0.) strPts.SetExtent(0, imageWidth - 1, 0, imageLength - 1, 0, 0) strPts.SetNumberOfScalarComponents(1) strPts.SetScalarTypeToFloat() strPts.AllocateScalars() strPts.GetPointData().SetScalars(data_array) strPts.Update() #print the image to an output file writer = vtk.vtkStructuredPointsWriter() writer.SetFileName(filename) writer.SetInput(strPts) writer.Update() writer.Write()
def BinaryToAscii(PathBinary): """ Conversion of a BINARY vtk format to an ASCII vtk format, it saves the Ascii file into the same path. Input: :PathBinary (string): path of the files folders to convert """ for id in os.listdir(PathBinary): print(id) for mask in os.listdir(os.path.join(PathBinary, id)): if mask.endswith(".vtk"): mask_path = os.path.join(os.path.join(PathBinary, id), mask) print(mask_path) # Read vtk BINARY mask file reader = vtkStructuredPointsReader() reader.SetFileName(mask_path) reader.ReadAllVectorsOn() reader.ReadAllScalarsOn() reader.Update() # Write vtk ASCII mask file #train_path = "/Users/jreventos/Desktop/TFM/Data/Train/masks" mask_path_ascii = os.path.join(os.path.join(PathBinary, id), 'ENDO_LA_ascii') writer = vtkStructuredPointsWriter() writer.SetFileName(mask_path_ascii) writer.SetInputConnection(reader.GetOutputPort()) writer.Write()
def WriteVTKImageFile(self): if (self.OutputFileName == ''): self.PrintError('Error: no OutputFileName.') self.PrintLog('Writing VTK image file.') writer = vtk.vtkStructuredPointsWriter() writer.SetInputData(self.Image) writer.SetFileName(self.OutputFileName) writer.Write()
def WriteVTKImageFile(self): if self.OutputFileName == "": self.PrintError("Error: no OutputFileName.") self.PrintLog("Writing VTK image file.") writer = vtk.vtkStructuredPointsWriter() writer.SetInput(self.Image) writer.SetFileName(self.OutputFileName) writer.Write()
def exportToVolume(self, filename): """ Export the reconstructed volume to a VTKstructGrid file. @param filename: the name of the file @type filename: str """ self.__exportToVtkDataExporter(vtk.vtkStructuredPointsWriter(), self.vtkVolume.GetOutput(), filename)
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__(self, module_manager, vtk.vtkStructuredPointsWriter(), 'Writing vtkStructuredPoints.', ('vtkStructuredPoints', ), (), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def saveVtkImage(name, image, asciiorbin='binary'): """ save a VTK Image (.vtk) from a vtkImageData (binary) """ writer = vtk.vtkStructuredPointsWriter() writer.SetHeader("# cree par RoBo") if asciiorbin == 'binary': writer.SetFileTypeToBinary() else: writer.SetFileTypeToASCII() writer.SetInput(image) writer.SetFileName(name) writer.Write() # really slow if ASCII!!!
def main(filenameIn,filenameOut,origin,spacing): r = vtk.vtkDataSetReader() r.SetFileName(filenameIn) r.Update() data = vtk.vtkImageData() data.ShallowCopy(r.GetOutput()) data.SetOrigin(origin) data.SetSpacing(spacing) data.Update() w = vtk.vtkStructuredPointsWriter() w.SetInput(data) w.SetFileName(filenameOut) w.Write()
def main(filenameIn, filenameOut, origin, spacing): r = vtk.vtkDataSetReader() r.SetFileName(filenameIn) r.Update() data = vtk.vtkImageData() data.ShallowCopy(r.GetOutput()) data.SetOrigin(origin) data.SetSpacing(spacing) data.Update() w = vtk.vtkStructuredPointsWriter() w.SetInput(data) w.SetFileName(filenameOut) w.Write()
def main(filenameIn,filenameOut,dx,dy,dz,vx,vy,vz): r = vtk.vtkDataSetReader() r.SetFileName(filenameIn) r.Update() data = vtk.vtkImageData() data.ShallowCopy(r.GetOutput()) data.SetOrigin(dx,dy,dz) data.SetSpacing(dx/vx,dy/vy,dz/vz) data.Update() #w = vtk.vtkDataSetWriter() w = vtk.vtkStructuredPointsWriter() # w.SetInputConnection(data.GetProducerPort()) w.SetInput(data) w.SetFileName(filenameOut) w.Write()
def saveVtkImage(name, image, asciiorbin='binary', coding='double'): """ save a VTK Image (.vtk) from a vtkImageData (binary) ! "uchar image"+ascii => "float image" (cfr. vtkDataWriter) "uchar image"+binary => "uchar image" """ name = os.path.splitext(name)[0] + '.vtk' imgCast = castImage(image, coding) writer = vtk.vtkStructuredPointsWriter() if asciiorbin == 'binary': writer.SetFileTypeToBinary() else: writer.SetFileTypeToASCII() writer.SetInput(imgCast) writer.SetFileName(name) writer.Write() # really slow if ASCII!!!
def write(matrix, filename): dims = matrix.shape flat = matrix.reshape(dims[0] * dims[1] * dims[2], 3, order='F') vtkarray = numpy_support.numpy_to_vtk(flat, False, vtk.VTK_FLOAT) vtkarray.SetNumberOfComponents(3) vtkarray.SetName("tangents") imagedata = vtk.vtkImageData() imagedata.SetDimensions((dims[0], dims[1], dims[2])) imagedata.GetPointData().SetVectors(vtkarray) writer = vtk.vtkStructuredPointsWriter() writer.SetFileName(filename) writer.SetInputData(imagedata) writer.SetFileTypeToBinary() writer.Write()
def save_npy_as_vtk_data(filename: str, origin: [np.ndarray, Tuple, List], spacing: [np.ndarray, Tuple, List], npy_img: np.ndarray, vti_mode: bool = False): """ save numpy data with vtk format :param filename: filename :param origin: image origin coordinate [x, y, z] :param spacing: image spacing [x, y, z] :param npy_img: numpy data :param vti_mode: if True, save with vti format :return: """ vtk_img = vtk.vtkImageData() vtk_img.SetSpacing(spacing) vtk_img.SetOrigin(origin) vtk_img.SetDimensions(np.array(npy_img.shape)[[2, 1, 0]]) vtk_img.GetPointData().SetScalars( numpy_support.numpy_to_vtk( npy_img.flatten(), deep=True, array_type=npy_dtype_to_vtk_dtype[npy_img.dtype])) vtk_img.SetExtent([ 0, npy_img.shape[2] - 1, 0, npy_img.shape[1] - 1, 0, npy_img.shape[0] - 1, ]) if vti_mode: writer = vtk.vtkXMLImageDataWriter() writer.SetInputData(vtk_img) writer.SetFileName(filename) writer.Update() writer.Write() else: writer = vtk.vtkStructuredPointsWriter() writer.SetInputData(vtk_img) writer.SetFileName(filename) writer.Write()
def SaveVTKFile(self): """ 保存为.vtk文件 """ # 读数据source lineData = self.dataMatrix.reshape(np.size(self.dataMatrix), order='F') # vtkdataArray = numpy2vtk(num_array=data.dataMatrix.flatten(), array_type=vtk.VTK_FLOAT) vtkdataArray = numpy2vtk(num_array=lineData, array_type=vtk.VTK_FLOAT) # 定义一种source,vtkImageData vtkImageData = vtk.vtkImageData() # 定义vtkImageData的各种属性 vtkImageData.SetDimensions(np.shape(self.dataMatrix)) vtkImageData.SetSpacing(1, 1, 1) vtkImageData.GetPointData().SetScalars(vtkdataArray) # 保存为没有拓扑结构的点数据集(imagedata类型) writer = vtk.vtkStructuredPointsWriter() writer.SetInputData(vtkImageData) writer.SetFileName(self.fileName.split(".")[0] + ".vtk") writer.Write()
def write(matrix, filename): dims = matrix.shape flat = matrix.ravel(order='F') vtkarray = numpy_support.numpy_to_vtk(flat, deep=True, array_type=vtk.VTK_FLOAT) vtkarray.SetName("curvatures") points = vtk.vtkStructuredPoints() points.SetDimensions(dims) points.GetPointData().AddArray(vtkarray) writer = vtk.vtkStructuredPointsWriter() writer.SetFileTypeToBinary() writer.SetFileName(filename) writer.SetInputData(points) writer.Write()
def transformVolume(self, inputVolume, outputVolume, transformationMatrix): # Normalize matrix so it preserve its scaling (diagonal elements are # equal to 1) M = self.__normalizeMatrix(transformationMatrix) reader = vtk.vtkStructuredPointsReader() reader.SetFileName(inputVolume) reader.Update() reader.GetOutput().UpdateInformation() matrix = vtk.vtkMatrix4x4() matrix.DeepCopy(( M[0,0], M[0,1], M[0,2], M[0,3], M[1,0], M[1,1], M[1,2], M[1,3], M[2,0], M[2,1], M[2,2], M[2,3], M[3,0], M[3,1], M[3,2], M[3,3] )) # Extract a slice in the desired orientation reslice = vtk.vtkImageReslice() reslice.SetInputConnection(reader.GetOutputPort()) reslice.SetResliceAxes(matrix) reslice.AutoCropOutputOff() reslice.SetInterpolationModeToNearestNeighbor() #reslice.SetInterpolationModeToLinear() print >>sys.stderr,'M=\n',M ch = vtk.vtkImageChangeInformation() ch.SetInput(reslice.GetOutput()) ch.SetOutputOrigin(*OUTPUT_VOLUME_ORIGIN) ch.SetOutputSpacing(*OUTPUT_VOLUME_SPACING) ch.Update() writer = vtk.vtkStructuredPointsWriter() writer.SetFileTypeToBinary() writer.SetInput(ch.GetOutput()) writer.SetFileName(outputVolume) writer.Update()
def save(self, image): data = dti6to33(self._to_axis_aligned_lps_space(image)) spacing = image.spacing origin = image.origin # Convert numpy -> VTK table vtk_array = vtkFloatArray() vtk_array.SetNumberOfComponents(9) vtk_array.SetVoidArray(data, len(data.ravel()), 1) # Create VTK dataset structured_points = vtkStructuredPoints() structured_points.SetDimensions(data.shape[2], data.shape[1], data.shape[0]) structured_points.SetSpacing(spacing[2], spacing[1], spacing[0]) structured_points.SetOrigin(origin[2], origin[1], origin[0]) structured_points.GetPointData().SetTensors(vtk_array) # Write VTK file writer = vtkStructuredPointsWriter() writer.SetFileName(self._filename) writer.SetFileTypeToBinary() writer.SetInput(structured_points) writer.Update()
def main(filenameIn,filenameOut,origin,spacing): """Main function for the conversion. Intended for VTK files with 3D voxel data. Adjusts origin and spacing. @param[in] filenameIn binary VTK file name @param[in] filenameOut ASCII VTK file name @param[in] origin of coordinate system @param[in] distance between the points """ r = vtk.vtkDataSetReader() r.SetFileName(filenameIn) r.Update() data = vtk.vtkImageData() data.ShallowCopy(r.GetOutput()) data.SetOrigin(origin) data.SetSpacing(spacing) w = vtk.vtkStructuredPointsWriter() if vtk.VTK_MAJOR_VERSION <= 5: w.SetInputConnection(data.GetProducerPort()) else: w.SetInputData(data) w.SetFileName(filenameOut) w.Write()
def main(filenameIn, filenameOut, origin, spacing): """Main function for the conversion. Intended for VTK files with 3D voxel data. Adjusts origin and spacing. @param[in] filenameIn binary VTK file name @param[in] filenameOut ASCII VTK file name @param[in] origin of coordinate system @param[in] distance between the points """ r = vtk.vtkDataSetReader() r.SetFileName(filenameIn) r.Update() data = vtk.vtkImageData() data.ShallowCopy(r.GetOutput()) data.SetOrigin(origin) data.SetSpacing(spacing) w = vtk.vtkStructuredPointsWriter() if vtk.VTK_MAJOR_VERSION <= 5: w.SetInputConnection(data.GetProducerPort()) else: w.SetInputData(data) w.SetFileName(filenameOut) w.Write()
from __future__ import print_function import vtk import numpy as np import os writer = vtk.vtkStructuredPointsWriter() def numpyDataToVTKPointData(grid, numpy_data, dataname): if numpy_data.shape.__len__() == 1: new_shape = np.array([numpy_data.shape[0],1,1]) new_data = np.ones(new_shape) new_data[:,0,0] = numpy_data[:] numpy_data = new_data elif numpy_data != 3: print("cannot handle shape = %i" % (numpy_data.shape)) quit() # add point dataset vtk_array = vtk.vtkDoubleArray() vtk_array.SetNumberOfComponents(1) vtk_array.SetNumberOfTuples(grid.GetNumberOfPoints()) vtk_array.SetName(dataname) for z_id in range(grid.GetDimensions()[2]): for y_id in range(grid.GetDimensions()[1]): for x_id in range(grid.GetDimensions()[0]): id = grid.ComputePointId((x_id , y_id , z_id)) vtk_array.SetValue(id, numpy_data[x_id, y_id, z_id]) return vtk_array
# # If the current directory is writable, then test the witers # try: channel = open("test.tmp", "w") channel.close() os.remove("test.tmp") s = vtk.vtkRTAnalyticSource() s.SetWholeExtent(5, 10, 5, 10, 5, 10) s.Update() d = s.GetOutput() w = vtk.vtkStructuredPointsWriter() w.SetInputData(d) w.SetFileName("test-dim.vtk") w.Write() r = vtk.vtkStructuredPointsReader() r.SetFileName("test-dim.vtk") r.Update() os.remove("test-dim.vtk") assert (r.GetOutput().GetExtent() == (0, 5, 0, 5, 0, 5)) assert (r.GetOutput().GetOrigin() == (5, 5, 5)) w.SetInputData(d) w.SetFileName("test-dim.vtk")
for file in files: fullpath.InsertNextValue(file) r.SetFileNames(fullpath) assert fullpath.GetNumberOfValues() # Need at least one file ExecuteInformation(r, fullpath.GetValue(0), fullpath.GetNumberOfValues()) r.AddObserver("ProgressEvent", PrintProgress) r.Update() #print r.GetOutput() #print vtkMultiThreader.GetGlobalDefaultNumberOfThreads() #g = vtkImageGradient() #g.SetInput( r.GetOutput() ) #g.AddObserver("ProgressEvent", PrintProgress) #g.Update() # Write output writer = vtkStructuredPointsWriter() writer.SetInput(r.GetOutput()) writer.SetFileName("TestvtkGDCMThreadedImageReaderPython.vtk") writer.SetFileTypeToBinary() #writer.Write() else: # TODO r.SetFileName(filename) ExecuteInformation(r, filename) r.Update() print r.GetOutput() #sys.exit(1) # Test succeed ? #sys.exit(success != 1)
def array2vtk(self, array, final_filename, path, origin=[0, 0, 0], spacing=[1, 1, 1]): """ Convert array into .vtk file - Params: inherited class parameters (see description at beginning of the class) array: array to be converted into .vtk file flag: parameter specifying if what is saved is a contour image or a binary mask 'contour': contour is saved 'binary': binary mask is saved origin: origin of coordinate system, by default (0,0,0) spacing: spacing of coordinate system, by default (1,1,1) """ vtk_writer = vtk.vtkStructuredPointsWriter() # Check if destination folder exists #print('Checking if destination folder exists\n') isdir = os.path.isdir(path) if not isdir: os.makedirs(path) print('Non-existing destination path. Created\n') # Check if files already exist in destination folder overwrite = 'y' exist = final_filename in os.listdir(path) if exist: overwrite = input( "File is already in folder. Do you want to overwrite? [y/n]") if overwrite == 'y' or overwrite == 'Y': vtk_writer.SetFileName(path + final_filename) else: print('\nOperation aborted\n') vtk_im = vtk.vtkStructuredPoints() vtk_im.SetDimensions((array.shape[1], array.shape[0], array.shape[2])) vtk_im.SetOrigin(origin) vtk_im.SetSpacing(spacing) pdata = vtk_im.GetPointData() vtk_array = numpy_to_vtk(array.swapaxes(0, 1).ravel(order='F'), deep=1) pdata.SetScalars(vtk_array) #vtk_writer.SetFileType(VTK_BINARY) vtk_writer.SetInputData(vtk_im) vtk_writer.Update()
def writeSP(sp, fn): writer = vtk.vtkStructuredPointsWriter() writer.SetInputData(sp) writer.SetFileName(fn) writer.Write()
def save_vtk_stru_point(path, vtk_dict, verbose=True): """ A routine to save a structured point vtk file given by a dictionary. Parameters ---------- path : string Path for the file to be saved to. vtk_dict : dict Dictionary containing information of a structured point vtk file. The following keywords are allowed: * ``"dimensions"``: (int, int, int) * ``"origin"``: (float, float, float) * ``"spacing"``: (float, float, float) * ``"header"``: string * ``"field_data"``: dict of {"name": array} * ``"point_data"``: dict of {"name": array} * ``"cell_data"``: dict of {"name": array} verbose : bool, optional Print information of the writing process. Default: True Notes ----- All data is assumed to be scalar. """ from numpy import ascontiguousarray as ascont from vtk import ( vtkStructuredPoints, vtkStructuredPointsWriter, vtkFieldData, ) from vtk.util.numpy_support import numpy_to_vtk as np2vtk out = vtkStructuredPoints() if verbose: print("Set 'dimensions', 'origin', 'spacing'") out.SetDimensions(vtk_dict["dimensions"]) out.SetOrigin(vtk_dict["origin"]) out.SetSpacing(vtk_dict["spacing"]) if vtk_dict["field_data"]: if verbose: print("Set 'field_data'") data = vtkFieldData() for sgl_data in vtk_dict["field_data"]: if verbose: print(" Set '" + sgl_data + "'") arr = np2vtk( ascont(vtk_dict["field_data"][sgl_data].reshape(-1, order="F"))) arr.SetName(sgl_data) data.AddArray(arr) out.SetFieldData(data) if vtk_dict["point_data"]: if verbose: print("Set 'point_data'") data = out.GetPointData() for sgl_data in vtk_dict["point_data"]: if verbose: print(" Set '" + sgl_data + "'") arr = np2vtk( ascont(vtk_dict["point_data"][sgl_data].reshape(-1, order="F"))) arr.SetName(sgl_data) data.AddArray(arr) if vtk_dict["cell_data"]: if verbose: print("Set 'cell_data'") data = out.GetCellData() for sgl_data in vtk_dict["cell_data"]: if verbose: print(" Set '" + sgl_data + "'") arr = np2vtk( ascont(vtk_dict["cell_data"][sgl_data].reshape(-1, order="F"))) arr.SetName(sgl_data) data.AddArray(arr) writer = vtkStructuredPointsWriter() writer.SetFileName(path) writer.SetInputData(out) if "header" in vtk_dict: writer.SetHeader(vtk_dict["header"]) writer.Write()
def imageDataFromNumpy(npArr, spacing, origin, shape, dims=1, outputFilename = None): ds, o, p = shape, origin, spacing print >>sys.stderr, "\timageDataFrom3dRGBNumpyArr\tinitializing volume..." d = vtk.vtkImageData() d.SetDimensions(*ds) d.SetOrigin(o[2],o[1],o[0]) d.SetSpacing(p[2],p[1],p[0]) d.SetNumberOfScalarComponents(dims) if dims==3: d.SetScalarTypeToUnsignedChar() else: d.SetScalarTypeToUnsignedInt() d.AllocateScalars() print >>sys.stderr, "\timageDataFrom3dRGBNumpyArr: origin: " + str(d.GetOrigin()) print >>sys.stderr, "\timageDataFrom3dRGBNumpyArr: spacing: " + str(d.GetSpacing()) print >>sys.stderr, "\timageDataFrom3dRGBNumpyArr: data type: " + str(d.GetScalarTypeAsString()) print >>sys.stderr, "\timageDataFrom3dRGBNumpyArr: components no.: " + str(d.GetNumberOfScalarComponents()) print >>sys.stderr, "\timageDataFrom3dRGBNumpyArr: points no.: " + str(d.GetNumberOfPoints()) print >>sys.stderr, "\timageDataFrom3dRGBNumpyArr: setting image data..." print >>sys.stderr, "\timageDataFrom3dRGBNumpyArr: iteration sequence: %d %d %d" % (ds[2], ds[1], ds[0]) dScalars = d.GetPointData().GetScalars() dComputePointId = d.ComputePointId if dims==3: for i in range(ds[2]): for j in range(ds[1]): for k in range(ds[0]): id = d.ComputePointId((k,j,i)) dScalars.SetTuple3(id, *map(float,npArr[k,j,i])) if dims==1: for i in range(ds[2]): for j in range(ds[1]): for k in range(ds[0]): id = d.ComputePointId((k,j,i)) dScalars.SetTuple1(id, int(npArr[k,j,i])) print >>sys.stderr, "\timageDataFrom3dRGBNumpyArr: applying vtkImagePermute()" permute = vtk.vtkImagePermute() permute.SetFilteredAxes(2,1,0) permute.SetInput(d) print >>sys.stderr, "\timageDataFrom3dRGBNumpyArr: applying vtk.vtkImageCast()" cast = vtk.vtkImageCast() cast.SetInput(permute.GetOutput()) cast.SetOutputScalarTypeToFloat() cast.Update() print >>sys.stderr, "\timageDataFrom3dRGBNumpyArr: applying vtk.vtkImageCast()" cast2 = vtk.vtkImageCast() cast2.SetInput(cast.GetOutput()) cast2.SetOutputScalarTypeToUnsignedInt() cast2.Update() print >>sys.stderr, cast2.GetOutput() if outputFilename: print >>sys.stderr, "\timageDataFrom3dRGBNumpyArr: writing to: %s" % outputFilename w = vtk.vtkStructuredPointsWriter() w.SetInput(cast2.GetOutput()) w.SetFileName(outputFilename) w.Update() print >>sys.stderr, "\timageDataFrom3dRGBNumpyArr: done." return cast2.GetOutput()
def array2vtk(self, array, filename, path, origin=[0, 0, 0], spacing=[1, 1, 1]): """ Convert array into .vtk file - Params: inherited class parameters (see description at beginning of the class) array: array to be converted into .vtk file (array) filename: filename with which to save array as VTK file (str) path: path where to save VTK file (str) origin: origin of coordinate system, by default [0,0,0] (list of 3) spacing: spacing of coordinate system, by default [1,1,1] (list of 3) """ vtk_writer = vtk.vtkStructuredPointsWriter() # Check if destination folder exists #print('Checking if destination folder exists\n') isdir = os.path.isdir(path) if not isdir: os.makedirs(path) print('Non-existing destination path. Created\n') # Check if files already exist in destination folder exist = filename in os.listdir(path) overwrite = 'y' if exist: overwrite = input( "File is already in folder. Do you want to overwrite? [y/n]\n") if overwrite == 'y' or overwrite == 'Y': vtk_writer.SetFileName(path + filename) vtk_im = vtk.vtkStructuredPoints() vtk_im.SetDimensions( (array.shape[1], array.shape[0], array.shape[2])) vtk_im.SetOrigin(origin) vtk_im.SetSpacing(spacing) pdata = vtk_im.GetPointData() vtk_array = numpy_to_vtk(array.swapaxes(0, 1).ravel(order='F'), deep=1) pdata.SetScalars(vtk_array) vtk_writer.SetFileType(vtk.VTK_BINARY) vtk_writer.SetInputData(vtk_im) vtk_writer.Update() #print('VTK file saved successfully!\n') else: print('\nOperation aborted\n')
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()
x = dzy - dyz y = dxz - dzx z = dyx - dxy div.SetTuple1(index, (dxx + dyy + dzz)) curl.SetTuple3(index, x, y, z) # Calculate curl magnitude curlmag.SetTuple1(index, math.sqrt(x * x + y * y + z * z)) print "JUST DID VOXEL: %d %d %d %d" % (k, j, i, index) divData.GetPointData().SetScalars(div) curlData.GetPointData().SetVectors(curl) curlmagData.GetPointData().SetScalars(curlmag) # create a writer, to save information to a file writeDiv = vtk.vtkStructuredPointsWriter() writeDiv.SetFileName("./ChalDMag0.vtk") writeDiv.SetFileTypeToBinary() writeDiv.SetInputData(divData) writeDiv.Write() writeCurl = vtk.vtkStructuredPointsWriter() writeCurl.SetFileName("./ChalCur0.vtk") writeCurl.SetFileTypeToBinary() writeCurl.SetInputData(curlData) writeCurl.Write() writeCurlMag = vtk.vtkStructuredPointsWriter() writeCurlMag.SetFileName("./ChalCMag0.vtk") writeCurlMag.SetFileTypeToBinary() writeCurlMag.SetInputData(curlmagData)