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 __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 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.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 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 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)
