def save_polydata(polydata, file_name, binary=False, color_array_name=None):
# get file extension (type)
file_extension = file_name.split(".")[-1].lower()
# todo better generic load
# todo test all
if file_extension == "vtk":
writer = vtk.vtkPolyDataWriter()
elif file_extension == "vtp":
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 == "obj":
raise "mni obj or Wavefront obj ?"
# writer = set_input(vtk.vtkMNIObjectWriter(), polydata)
writer.SetFileName(file_name)
writer = set_input(writer, polydata)
if color_array_name is not None:
writer.SetArrayName(color_array_name);
if binary :
writer.SetFileTypeToBinary()
writer.Update()
writer.Write()
def save_polydata(polydata, file_name, binary=False, color_array_name=None):
# get file extension (type)
file_extension = file_name.split(".")[-1].lower()
if file_extension == "vtk":
writer = vtk.vtkPolyDataWriter()
elif file_extension == "vtp":
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 == "obj":
raise "mni obj or Wavefront obj ?"
# writer = set_input(vtk.vtkMNIObjectWriter(), polydata)
writer.SetFileName(file_name)
writer = set_input(writer, polydata)
if color_array_name is not None:
writer.SetArrayName(color_array_name)
if binary:
writer.SetFileTypeToBinary()
writer.Update()
writer.Write()
def save_polydata(polydata,
file_name,
binary=False,
color_array_name=None,
is_mni_obj=False):
"""Save a vtk polydata to a supported format file.
Save formats can be VTK, FIB, PLY, STL and XML.
Parameters
----------
polydata : vtkPolyData
file_name : string
binary : bool
color_array_name: ndarray
is_mni_obj : bool
"""
# 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 == "obj":
if is_mni_obj:
writer = vtk.vtkMNIObjectWriter()
else:
# vtkObjWriter not available on python
# vtk.vtkOBJWriter()
raise IOError("OBJ Writer not available. MNI obj is the only"
" available writer so set mni_tag option to True")
else:
raise IOError("Unknown extension ({})".format(file_extension))
writer.SetFileName(file_name)
writer = set_input(writer, polydata)
if color_array_name is not None and file_extension == "ply":
writer.SetArrayName(color_array_name)
if binary:
writer.SetFileTypeToBinary()
writer.Update()
writer.Write()
def trim_vtp(fn = "c.vtp", fnout = "t.vtk", s = (1.0,1.0,1.0)):
if not os.path.exists(fn):
print "%s does not exists, skip" % (fn,)
return
# Read vtp
rd = vtk.vtkXMLPolyDataReader()
rd.SetFileName(fn)
rd.Update()
# the poly data
pd = vtk.vtkPolyData()
pd = rd.GetOutput()
# times by 10.0 (CM -> MM)
MM = [10.0 for each in range(0,len(s))]
pd = scale_vtkPolyData(pd, MM)
# then divides the spacing
ss = [1/each for each in s]
pd = scale_vtkPolyData(pd, ss)
# Write vtk
wt = vtk.vtkPolyDataWriter()
wt.SetInputData(pd)
wt.SetFileName(fnout)
wt.Write()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkPolyDataWriter(), 'Writing vtkPolyData.',
('vtkPolyData',), (),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def __init__(self, module_manager):
# call parent constructor
ModuleBase.__init__(self, module_manager)
self._writer = vtk.vtkPolyDataWriter()
# sorry about this, but the files get REALLY big if we write them
# in ASCII - I'll make this a gui option later.
self._writer.SetFileTypeToBinary()
module_utils.setup_vtk_object_progress(
self, self._writer,
'Writing VTK Polygonal data')
# ctor for this specific mixin
FilenameViewModuleMixin.__init__(
self,
'Select a filename',
'VTK data (*.vtk)|*.vtk|All files (*)|*',
{'vtkPolyDataWriter': self._writer},
fileOpen=False)
# set up some defaults
self._config.filename = ''
self.sync_module_logic_with_config()
def write_vtk_points(points: np.ndarray, filename: str) -> None:
r""" Write a set of points to a VTK PolyData file.
The points are given as a numpy bidimensional array, with a
row for each point, and three columns, one per component.
Parameters
----------
points : np.ndarray
A `n × m` array containing `n` points with `m` components.
filename : str
Output file.
"""
if 'vtk' not in sys.modules:
raise Exception(
'write_vtk_points: vtk module is required to use this feature.')
vtk_points = vtk.vtkPoints()
for i in range(0, points.shape[0]):
vtk_points.InsertNextPoint(points[i, 0], points[i, 1], points[i, 2])
polydata = vtk.vtkPolyData()
polydata.SetPoints(vtk_points)
writer = vtk.vtkPolyDataWriter()
writer.SetInputData(polydata)
writer.SetFileName(filename)
writer.Update()
def vt2vtk_file(vessel_tree, outfile, text_label=None):
"""
vessel_tree structure
:param vessel_tree: vt structure
:param outfile: filename with .vtk extension
:param text_label: text label like 'porta' or 'hepatic_veins'
:return:
"""
import vtk
trees = fix_tree_structure(vessel_tree)
tkeys = trees.keys()
if text_label is None:
text_label = tkeys[0]
tree_data = compatibility_processing(trees[text_label])
polyData = gen_tree(tree_data)
import ipdb
ipdb.set_trace()
writer = vtk.vtkPolyDataWriter()
writer.SetFileName(outfile)
try:
writer.SetInputData(polyData)
except:
logger.warning("old vtk is used")
writer.SetInput(polyData)
writer.Write()
def write_polydata(polydata, filename):
"""Write polydata as vtkPolyData format, according to extension."""
if VERBOSE:
print "Writing ", filename, "..."
basename, extension = os.path.splitext(filename)
if (extension == '.vtk'):
writer = vtk.vtkPolyDataWriter()
writer.SetFileTypeToBinary()
elif (extension == '.vtp'):
writer = vtk.vtkXMLPolyDataWriter()
writer.SetDataModeToBinary()
else:
print 'Cannot recognize model file format'
return None
writer.SetFileName(filename)
if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
writer.SetInputData(polydata)
else:
writer.SetInput(polydata)
writer.Update()
del writer
if VERBOSE:
print "Done writing ", filename
print "Number of lines found:", outpd.GetNumberOfLines()
def write_polydata(polydata, filename):
"""Write polydata as vtkPolyData format, according to extension."""
if VERBOSE:
print "Writing ", filename, "..."
basename, extension = os.path.splitext(filename)
if (extension == '.vtk'):
writer = vtk.vtkPolyDataWriter()
writer.SetFileTypeToBinary()
elif (extension == '.vtp'):
writer = vtk.vtkXMLPolyDataWriter()
writer.SetDataModeToBinary()
else:
print 'Cannot recognize model file format'
return None
writer.SetFileName(filename)
if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
writer.SetInputData(polydata)
else:
writer.SetInput(polydata)
writer.Update()
del writer
if VERBOSE:
print "Done writing ", filename
def vt2vtk_file(vessel_tree, outfile, text_label=None, lc_all="C"):
"""
vessel_tree structure
:param vessel_tree: vt structure
:param outfile: filename with .vtk extension
:param text_label: text label like 'porta' or 'hepatic_veins'
:param lc_all: LC_ALL locale settings. Controls float numbers
format (dot or colon). If is set to "C" dot is used.
If None is used no processing is done
:return:
"""
polyData = vt2polyData(vessel_tree, text_label=text_label)
if lc_all is not None:
import locale
locale.setlocale(locale.LC_ALL, 'C')
writer = vtk.vtkPolyDataWriter()
writer.SetFileName(outfile)
try:
writer.SetInputData(polyData)
except:
logger.warning("old vtk is used")
writer.SetInput(polyData)
writer.Write()
return polyData
def Decimate_mesh(meshvtk,name_vtkmesh,nvertices=2000):
print 'test'
stlWriter = vtk.vtkSTLWriter()
stlWriter.SetFileName('meshdecimated.stl')
stlWriter.SetInputData(meshvtk)
stlWriter.Write()
mesh_om = om.PolyMesh()
Result=om.read_mesh(mesh_om, "meshdecimated.stl")
print Result
deci_om=om.PolyMeshDecimater(mesh_om)
mh=om.PolyMeshModQuadricHandle()
deci_om.add(mh)
deci_om.initialize()
deci_om.decimate_to(nvertices)
mesh_om.garbage_collection()
assert mesh_om.n_vertices()==nvertices, 'vertices goal not acomplished; nvertices={0:d}'.format(mesh_om.n_vertices())
print "Decimation to {0} vertices Sucessful".format(nvertices)
om.write_mesh(mesh_om,'meshdecimated.stl')
stlReader = vtk.vtkSTLReader()
stlReader.SetFileName('meshdecimated.stl')
stlReader.Update()
vtkwrite=vtk.vtkPolyDataWriter()
vtkwrite.SetInputData(stlReader.GetOutput())
vtkwrite.SetFileName(name_vtkmesh)
vtkwrite.Write()
print "enters"
def write_to_polydata(fname, grid):
import vtk
writer = vtk.vtkPolyDataWriter()
writer.SetFileName(fname)
writer.SetInputData(grid)
writer.Write()
def _write_to_file(polydata: Union[PolyData, JoinedPolyData],
target_folder: str,
file_name: str,
writer: VTKWriters = VTKWriters.binary):
"""Write vtkPolyData to a file."""
extension = writer.value
if writer.name == 'legacy':
_writer = vtk.vtkPolyDataWriter()
else:
_writer = vtk.vtkXMLPolyDataWriter()
if writer.name == 'binary':
_writer.SetDataModeToBinary()
else:
_writer.SetDataModeToAscii()
file_path = pathlib.Path(target_folder, f'{file_name}.{extension}')
_writer.SetFileName(file_path.as_posix())
if isinstance(polydata, vtk.vtkPolyData):
_writer.SetInputData(polydata)
else:
_writer.SetInputConnection(polydata.GetOutputPort())
_writer.Write()
return file_path.as_posix()
def chooseWriter(self, file_format, vtk_dataset_type):
"""
Return a writer based on file_format and possibly vtk_dataset_type.
@param vtk_dataset_type, None or one of the VTK_DATASET_TYPES
"""
if file_format == 'ply':
return vtk.vtkPLYWriter()
# For now we'll just return the POLYDATA writer since methods work
# only with that vtk_dataset_type.
return vtk.vtkPolyDataWriter()
if vtk_dataset_type == 'STRUCTURED_GRID':
return vtk.vtkStructuredGridWriter()
elif vtk_dataset_type == 'POLYDATA':
return vtk.vtkPolyDataWriter()
elif vtk_dataset_type == 'UNSTRUCTURED_GRID':
return vtk.vtkUnstructuredGridWriter()
def chunk_contour(data, prev, *args):
envelope, values = args
vti = vtk.vtkImageData()
vti.SetOrigin(data.origin)
vti.SetDimensions(np.array(data.shape) - np.array(envelope))
vti.SetSpacing(data.spacing)
series_name = "sparse"
add_np_to_vti(vti, data[:-envelope[0], :-envelope[1], :-envelope[2]],
series_name)
vti.GetPointData().SetActiveScalars(series_name)
contour = vtk.vtkImageMarchingCubes()
contour.SetInputData(vti)
contour.SetNumberOfContours(values.shape[0])
for i, v in enumerate(values):
contour.SetValue(i, v)
contour.ComputeScalarsOn()
contour.Update()
writer = vtk.vtkPolyDataWriter()
writer.SetInputData(contour.GetOutput())
writer.WriteToOutputStringOn()
writer.Update()
prev.append(writer.GetOutputString())
# TODO: could this return (None, prev) after issue #16 ?
return data, prev
def vtk_export(polydata, filename, method='vtk'):
"""Export VTK polyData object to different file formats.
polydata (vtk.vtkPolyData): ytk object containing vertices and simplices
filename (string): path and filename without extension
method (string): one of the following options
vtk: VTK legacy file version 4.2 (e.g. for import into ParaView)
ply: Stanford University ".ply" file (e.g. for import into MeshLab)
iv: OpenInventor 2.0 file (e.g. for import into METRO)
"""
# TODO: Binary ASCII stuff
if method == 'vtk':
export = vtkPolyDataWriter()
export.SetInputDataObject(polydata)
export.SetFileName(filename + '.vtk')
export.Write()
elif method == 'ply':
export = vtkPLYWriter()
export.SetInputDataObject(polydata)
export.SetFileName(filename + '.ply')
export.Write()
elif method == 'iv':
export = vtkIVWriter()
export.SetInputDataObject(polydata)
export.SetFileName(filename + '.iv')
export.Write()
else:
print('File format unknown!')
def writeVTK(in_data, vtk_file, verbose=0):
"""
Write tractography data into vtkPolyData
INPUT:
in_data - tractography data to be written to file
vtk_file - name of file to be written
verbose - verbosity of function; defaults 0
OUTPUT:
none
"""
filename, ext = op.splitext(vtk_file)
if (ext == ".vtk"):
misc.vprint("Writing %s ..." % vtk_file, verbose)
vtk_writer = vtk.vtkPolyDataWriter()
vtk_writer.SetFileTypeToBinary()
vtk_writer.SetFileName(vtk_file)
vtk_writer.SetInputData(in_data)
vtk_writer.Update()
return
else:
raise IOError("Invalid file format.")
def writeMeshFile(triangles, filename, binary=True, verbose=False):
"""Write mesh file.
The output format is determined by file name extension. Files can be written
in binary (default) and ASCII format."""
outformat = path.splitext(options.outfilename)[1].strip('.')
# set writer based on filename extension
if outformat == 'stl':
write = vtk.vtkSTLWriter()
elif outformat == 'vtk':
write = vtk.vtkPolyDataWriter()
elif outformat == 'obj':
write = vtk.vtkMNIObjectWriter()
elif outformat == 'tag':
write = vtk.vtkMNITagPointWriter()
else:
raise ValueError('cannot write outpur format' + outformat)
write.SetInputConnection(triangles.GetOutputPort())
if outformat != 'tag':
if binary:
if verbose: print 'setting ouptut to binary'
write.SetFileTypeToBinary()
else:
if verbose: print 'setting ouptut to ascii'
write.SetFileTypeToASCII()
write.SetFileName(filename)
err = write.Write()
if err != 1:
raise IOError('failed to write')
if verbose:
print "wrote", filename
pass
def WriteMesh(filename, mesh, binary=True):
""" Writes a VTK mesh to one of the following formats:
ply, stl, vtk
"""
# Get extention
ftype = filename[-3:]
# Get filetype
if ftype == 'ply':
writer = vtk.vtkPLYWriter()
elif ftype == 'stl':
writer = vtk.vtkSTLWriter()
elif ftype == 'vtk':
writer = vtk.vtkPolyDataWriter()
else:
raise Exception('Unknown file type')
# Write
writer.SetFileName(filename)
SetVTKInput(writer, mesh)
if binary:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
writer.Write()
def filter_step(self, unfiltered_file, include_file, exclude_file):
import shutil
fiber_basename = self.get_unique_name()
filtered_temp_file = '%s_filtered.vtp' % fiber_basename
shutil.copy2(unfiltered_file, filtered_temp_file)
if include_file:
cmd='slicerFilterFibers.sh --pass 1 %s %s %s' % (include_file, filtered_temp_file, filtered_temp_file)
exec_cmd(cmd)
if exclude_file:
cmd='slicerFilterFibers.sh --nopass 1 %s %s %s' % (exclude_file, filtered_temp_file, filtered_temp_file)
exec_cmd(cmd)
vreader = vtkXMLPolyDataReader()
vreader.SetFileName(filtered_temp_file)
vreader.Update()
polydata = vreader.GetOutput()
vwriter = vtkPolyDataWriter()
output_file = '%s_filtered.vtk' % fiber_basename
vwriter.SetFileName(output_file)
vwriter.SetInput(polydata)
vwriter.Write()
return output_file
def write_vtk_data(vtk_file, fiber_filename):
print "---Writing file ", GREEN, fiber_filename, NC
sys.stdout.flush()
try:
if fiber_filename.rfind(".vtk") != -1:
writer = vtk.vtkPolyDataWriter()
writer.SetFileName(fiber_filename)
if vtk.VTK_MAJOR_VERSION > 5:
writer.SetInputData(vtk_file)
else:
writer.SetInput(vtk_file)
del vtk_file
writer.Update()
elif fiber_filename.rfind(".vtp") != -1:
writer = vtk.vtkXMLPolyDataWriter()
writer.SetFileName(fiber_filename)
if vtk.VTK_MAJOR_VERSION > 5:
writer.SetInputData(vtk_file)
else:
writer.SetInput(vtk_file)
del vtk_file
writer.Update()
else:
raise Exception('Unknown File Format for %s' % fiber_filename)
except IOError as e:
print('Could not write:', fiber_filename, ':', e)
exit(0)
def save_object_3d(self, object_3d, path):
writer = vtkPolyDataWriter()
writer.SetFileName(path)
writer.SetFileTypeToBinary()
writer.SetHeader(object_3d.name)
writer.SetInput(object_3d.dataset)
writer.Update()
def drawBones(bones, outFile):
ptsVtk = vtk.vtkPoints()
ptsAll = np.vstack(bones)
# pts.InsertNextPoint(p1)
for i in range(ptsAll.shape[0]):
ptsVtk.InsertNextPoint(ptsAll[i, :].tolist())
polyData = vtk.vtkPolyData()
polyData.SetPoints(ptsVtk)
lines = vtk.vtkCellArray()
for i in range(int(ptsAll.shape[0] / 2)):
line = vtk.vtkLine()
line.GetPointIds().SetId(
0,
i * 2) # the second 0 is the index of the Origin in the vtkPoints
line.GetPointIds().SetId(
1, i * 2 + 1) # the second 1 is the index of P0 in the vtkPoints
# line.
lines.InsertNextCell(line)
polyData.SetLines(lines)
writer = vtk.vtkPolyDataWriter()
writer.SetInputData(polyData)
writer.SetFileName(outFile)
writer.Update()
def onMeshesComplete(dlg, obj_filepath):
"""
Called when mesh extraction is complete.
Writes the extracted mesh to an .obj file
"""
print "Mesh generation complete."
mesh_count = len( dlg.extractor.meshes )
# Mesh count can sometimes be 0 for the '<not saved yet>' object...
if mesh_count > 0:
assert mesh_count == 1, \
"Found {} meshes. (Only expected 1)".format( mesh_count )
mesh = dlg.extractor.meshes.values()[0]
# Use VTK to write to a temporary .vtk file
tmpdir = tempfile.mkdtemp()
vtkpoly_path = os.path.join(tmpdir, 'meshes.vtk')
w = vtkPolyDataWriter()
w.SetFileTypeToASCII()
w.SetInput(mesh)
w.SetFileName(vtkpoly_path)
w.Write()
# Now convert the file to .obj format.
print "Saving meshes to {}".format( obj_filepath )
convertVTPtoOBJ(vtkpoly_path, obj_filepath)
shutil.rmtree( tmpdir )
def write_landmarks_as_vtk_points_external(landmarks, file_name):
print('############ write landmarks as vtk points #############')
print('############ filename : ', file_name)
n_landmarks = landmarks.shape[0]
print('########### landmarks: ', landmarks)
print('########### landmarks.shape[0]: ', landmarks.shape[0])
pd = vtk.vtkPolyData()
points = vtk.vtkPoints()
verts = vtk.vtkCellArray()
for lm_no in range(n_landmarks):
pid = points.InsertNextPoint(landmarks[lm_no, :])
verts.InsertNextCell(1)
verts.InsertCellPoint(pid)
pd.SetPoints(points)
del points
pd.SetVerts(verts)
del verts
writer = vtk.vtkPolyDataWriter()
writer.SetInputData(pd)
writer.SetFileName(file_name)
writer.Write()
del writer
del pd
def generate_tori(filename, meshDir, randomize_center, randomize_rotation, randomize_ring_radius, randomize_cross_section_radius):
vtkFileName = meshDir+"torus_"+filename+".vtk"
if randomize_center:
center_loc = list(np.random.randint(low = 0,high=50,size=3))
else:
center_loc = [0,0,0]
if randomize_ring_radius:
ring_radius = np.random.randint(low =15,high=25,size =1)[0]
else:
ring_radius = 20
if randomize_cross_section_radius:
cross_section_radius = np.random.randint(low =5,high=15,size =1)[0]
else:
cross_section_radius = 10
radii = [ring_radius,cross_section_radius]
if randomize_rotation:
rotation = np.random.randint(low=0,high=180,size=1)[0]
else:
rotation = 0
torus = addTorus(center_loc,radii,rotation)
vtk_writer = vtk.vtkPolyDataWriter()
vtk_writer.SetInputData(torus.GetOutput())
vtk_writer.SetFileName(vtkFileName)
vtk_writer.Update()
def writevtk(surface,filename):
"""Write vtk polydata file."""
writer = vtk.vtkPolyDataWriter()
writer.SetInputData(surface)
writer.SetFileTypeToASCII()
writer.SetFileName(filename)
writer.Write()
def write_vtk_polydata(poly, fn):
"""
This function writes a vtk polydata to disk
Args:
poly: vtk polydata
fn: file name
Returns:
None
"""
print('Writing vtp with name:', fn)
if (fn == ''):
return 0
_, extension = os.path.splitext(fn)
if extension == '.vtk':
writer = vtk.vtkPolyDataWriter()
elif extension == '.stl':
writer = vtk.vtkSTLWriter()
elif extension == '.vtp':
writer = vtk.vtkXMLPolyDataWriter()
elif extension == '.obj':
writer = vtk.vtkOBJWriter()
else:
raise ValueError("Incorrect extension" + extension)
writer.SetInputData(poly)
writer.SetFileName(fn)
writer.Update()
writer.Write()
return
def onMeshesComplete():
"""
Called when mesh extraction is complete.
Writes the extracted mesh to an .obj file
"""
logger.info( "Mesh generation complete." )
mesh_count = len( window.extractor.meshes )
# Mesh count can sometimes be 0 for the '<not saved yet>' object...
if mesh_count > 0:
assert mesh_count == 1, \
"Found {} meshes processing object '{}',"\
"(only expected 1)".format( mesh_count, object_name )
mesh = window.extractor.meshes.values()[0]
logger.info( "Saving meshes to {}".format( obj_filepath ) )
# Use VTK to write to a temporary .vtk file
tmpdir = tempfile.mkdtemp()
vtkpoly_path = os.path.join(tmpdir, 'meshes.vtk')
w = vtkPolyDataWriter()
w.SetFileTypeToASCII()
w.SetInput(mesh)
w.SetFileName(vtkpoly_path)
w.Write()
# Now convert the file to .obj format.
convertVTPtoOBJ(vtkpoly_path, obj_filepath)
# Cleanup: We don't need the window anymore.
window.setParent(None)
# If there are still objects left to process,
# start again with the remainder of the list.
if object_names:
self._exportMeshes(object_names, obj_filepaths)
def Write(vtkdata, output_name):
outfilename = output_name
print("Writting:", outfilename)
polydatawriter = vtk.vtkPolyDataWriter()
polydatawriter.SetFileName(outfilename)
polydatawriter.SetInputData(vtkdata)
polydatawriter.Write()
def main():
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
infile = sys.argv[1]
if len(sys.argv) >= 3:
outfile = sys.argv[2]
else:
outfile = 'output.vtk'
yaml_file = open(infile, 'r')
tree_raw_data = yaml.load(yaml_file)
tree_data = process_tree(tree_raw_data['graph']['porta'])
try:
tree_data = process_tree(tree_raw_data['graph']['porta'])
except:
tree_data = process_tree(tree_raw_data['Graph']['porta'])
polyData = gen_tree(tree_data)
writer = vtk.vtkPolyDataWriter()
writer.SetFileName(outfile)
writer.SetInput(polyData)
writer.Write()
def save_vtk(self, outfile, inflated=False):
""" Export a mesh in '.vtk' format.
This code uses vtk.
Parameters
----------
outfile: str (mandatory)
the location where the mesh will be written.
inflated: bool (optional, default False)
if True write the inflated volume.
"""
# Import here since vtk is not required by the package
import vtk
# Check that the inflated vertices are specified if requested
if inflated and self.inflated_vertices is None:
raise ValueError("Can't save inflated volume '{0}' since it has "
"not been specified.".format(outfile))
# Create the desired polydata
polydata = self._polydata(inflated=inflated)
# Write the polydata
writer = vtk.vtkPolyDataWriter()
writer.SetDataModeToAscii()
writer.SetFileName(outfile)
if vtk.VTK_MAJOR_VERSION <= 5:
writer.SetInput(polydata)
else:
writer.SetInputData(polydata)
writer.Write()
def downsample_surface(surface_file, reduction, output):
decimate = vtk.vtkDecimatePro()
clean = vtk.vtkCleanPolyData()
writer = vtk.vtkPolyDataWriter()
# load the surface
surface = load_vtk(surface_file)
# To guarantee a given level of reduction,
# the ivar PreserveTopology must be off; the ivar Splitting is on;
# the ivar BoundaryVertexDeletion is on; and the ivar MaximumError is set to VTK_DOUBLE_MAX
# reduce the number of vertices in the mesh
decimate.SetInputData(surface)
decimate.SetTargetReduction(reduction)
decimate.PreserveTopologyOff()
decimate.SplittingOn()
decimate.BoundaryVertexDeletionOn()
decimate.SetMaximumError(vtk.VTK_DOUBLE_MAX)
# remove unneeded vertices
clean.SetInputConnection(decimate.GetOutputPort())
clean.Update()
# save a copy of the downsampled mesh
writer.SetFileName(output)
writer.SetInputData(clean.GetOutput())
writer.Write()
def __init__(self):
self._extension_map = {}
self._scalars_name = 'scalars'
self._writer = vtk.vtkPolyDataWriter()
# register file types
self.registerFileTypes()
def mris2vtk(input_name, output_name):
"""
Converts a FreeSurfer surface to VTK file format
"""
# convert surface to VTK format
check_call(['mris_convert', input_name, output_name])
# get surface RAS translation
out = check_output(["mris_info", input_name], stderr=STDOUT)
m = re.search("c_\(ras\)\s:\s\((-?\d+\.\d+),\s(-?\d+\.\d+),\s(-?\d+\.\d+)\)", out)
if m is None: raise RuntimeError('Could not find c_(ras) coordinates in mris_info output!')
tx = float(m.group(1))
ty = float(m.group(2))
tz = float(m.group(3))
# transform vertex positions to scanner RAS of orig.mgz
reader = vtkPolyDataReader()
reader.SetFileName(output_name)
reader.Update()
surface = reader.GetOutput()
points = surface.GetPoints()
for i in range(points.GetNumberOfPoints()):
x, y, z = points.GetPoint(i)
points.SetPoint(i, x + tx, y + ty, z + tz)
surface.SetPoints(points)
writer = vtkPolyDataWriter()
writer.SetFileName(output_name)
writer.SetInput(surface)
writer.Write()
def save_polydata(mesh: vtk.vtkPolyData, filename: str):
"""Saves a mesh as a vtkPolyData file.
Parameters
----------
mesh : vtkPolyData
Input mesh
filename : str
File path where the mesh will be saved
output_type : vtk or ply
Format of output polydata file
"""
# Output file format
output_type = filename.split(".")[-1]
if output_type not in ["vtk", "ply"]:
raise ValueError(
f"Output format {output_type} not supported. Please use vtk or ply."
)
if output_type == "vtk":
writer = vtk.vtkPolyDataWriter()
else:
writer = vtk.vtkPLYWriter()
writer.SetInputData(mesh)
writer.SetFileName(filename)
writer.Write()
def writeVTK(data, vtkfile):
"""
Write tractography data to .vtk file (vtkPolyData).
INPUT:
data - vtkPolydata to be written to file
vtkfile - Name of file to be written
OUTPUT:
none
"""
if VERBOSE:
print "\nWriting", vtkfile, "..."
filename, ext = os.path.splitext(vtkfile)
if (ext == '.vtk'):
writer = vtk.vtkPolyDataWriter()
writer.SetFileTypeToBinary()
else:
print 'Invalid file format'
return None
writer.SetFileName(vtkfile)
writer.SetInputData(data)
writer.Update()
del writer
if VERBOSE:
print "Finished writing data to ", filename
def get_region(mesh, mesh_out, region):
"""
From a region with two connected components,
get either first or second connected component
and save them to mesh_out.
Returns the output mesh
"""
# Get region
cc = vtk.vtkPolyDataConnectivityFilter()
cc.SetInputData(mesh)
cc.SetExtractionModeToSpecifiedRegions()
cc.AddSpecifiedRegion(region)
cc.Update()
mesh_1 = cc.GetOutput(0)
# Remove connected points
clean = vtk.vtkCleanPolyData()
clean.SetInputData(mesh_1)
clean.Update()
mesh_1 = clean.GetOutput(0)
# Save
rd = vtk.vtkPolyDataWriter()
rd.SetInputData(mesh_1)
rd.SetFileName(mesh_out)
rd.Write()
return mesh_1
def onMeshesComplete():
"""
Called when mesh extraction is complete.
Writes the extracted mesh to an .obj file
"""
logger.info( "Mesh generation complete." )
mesh_count = len( window.extractor.meshes )
# Mesh count can sometimes be 0 for the '<not saved yet>' object...
if mesh_count > 0:
assert mesh_count == 1, \
"Found {} meshes processing object '{}',"\
"(only expected 1)".format( mesh_count, object_name )
mesh = window.extractor.meshes.values()[0]
logger.info( "Saving meshes to {}".format( obj_filepath ) )
# Use VTK to write to a temporary .vtk file
tmpdir = tempfile.mkdtemp()
vtkpoly_path = os.path.join(tmpdir, 'meshes.vtk')
w = vtkPolyDataWriter()
w.SetFileTypeToASCII()
w.SetInput(mesh)
w.SetFileName(vtkpoly_path)
w.Write()
# Now convert the file to .obj format.
convertVTPtoOBJ(vtkpoly_path, obj_filepath)
# Cleanup: We don't need the window anymore.
window.setParent(None)
# If there are still objects left to process,
# start again with the remainder of the list.
if object_names:
self._exportMeshes(object_names, obj_filepaths)
def drawCorrs(pts1, pts2, outCorrFile):
ptsVtk = vtk.vtkPoints()
ptsAll = np.vstack([pts1, pts2])
numPts = pts1.shape[0]
assert pts1.shape[0] == pts2.shape[0]
# pts.InsertNextPoint(p1)
for i in range(ptsAll.shape[0]):
ptsVtk.InsertNextPoint(ptsAll[i, :].tolist())
polyData = vtk.vtkPolyData()
polyData.SetPoints(ptsVtk)
lines = vtk.vtkCellArray()
for i in range(pts1.shape[0]):
line = vtk.vtkLine()
line.GetPointIds().SetId(
0, i) # the second 0 is the index of the Origin in the vtkPoints
line.GetPointIds().SetId(
1, i + numPts) # the second 1 is the index of P0 in the vtkPoints
# line.
lines.InsertNextCell(line)
polyData.SetLines(lines)
writer = vtk.vtkPolyDataWriter()
writer.SetInputData(polyData)
writer.SetFileName(outCorrFile)
writer.Update()
def VisualizeBones(inSkelJsonFile, outSkelVTK):
jData = json.load(open(inSkelJsonFile))
jointPosition = jData["JointPos"]
numJoints = len(jointPosition[0])
ptsVtk = vtk.vtkPoints()
# pts.InsertNextPoint(p1)
for i in range(numJoints):
ptsVtk.InsertNextPoint(
[jointPosition[0][i], jointPosition[1][i], jointPosition[2][i]])
polyData = vtk.vtkPolyData()
polyData.SetPoints(ptsVtk)
lines = vtk.vtkCellArray()
for i in range(1, numJoints):
iParent = jData['Parents'].get(str(i))
if iParent != None:
line = vtk.vtkLine()
line.GetPointIds().SetId(
0,
i) # the second 0 is the index of the Origin in the vtkPoints
line.GetPointIds().SetId(
1, iParent) # the second 1 is the index of P0 in the vtkPoints
lines.InsertNextCell(line)
polyData.SetLines(lines)
writer = vtk.vtkPolyDataWriter()
writer.SetInputData(polyData)
writer.SetFileName(outSkelVTK)
writer.Update()
def writeMeshFile(triangles, filename, binary=True, verbose=False):
"""Write mesh file.
The output format is determined by file name extension. Files can be written
in binary (default) and ASCII format."""
outformat = path.splitext(options.outfilename)[1].strip('.')
# set writer based on filename extension
if outformat=='stl':
write = vtk.vtkSTLWriter()
elif outformat=='vtk':
write = vtk.vtkPolyDataWriter()
elif outformat=='obj':
write = vtk.vtkMNIObjectWriter()
elif outformat=='tag':
write = vtk.vtkMNITagPointWriter()
else:
raise ValueError('cannot write outpur format' + outformat)
write.SetInputConnection(triangles.GetOutputPort())
if outformat!='tag':
if binary:
if verbose: print 'setting ouptut to binary'
write.SetFileTypeToBinary()
else:
if verbose: print 'setting ouptut to ascii'
write.SetFileTypeToASCII()
write.SetFileName(filename)
err = write.Write()
if err != 1:
raise IOError('failed to write')
if verbose:
print "wrote", filename
pass
def convert_mris(input_name, output_name):
"""
Converts a FreeSurfer surface to VTK file format
"""
# convert surface to VTK format
if output_name.endswith('.vtp'): temp_name = output_name[0:-1] + 'k'
else: temp_name = output_name
if not temp_name.endswith('.vtk'):
raise RuntimeError('Output file name extension must be either .vtk or .vtp')
check_call(['mris_convert', input_name, temp_name])
# get surface RAS translation
out = check_output(["mris_info", input_name], stderr=STDOUT)
m = re.search("c_\(ras\)\s:\s\((-?\d+\.\d+),\s(-?\d+\.\d+),\s(-?\d+\.\d+)\)", out)
if m is None: raise RuntimeError('Could not find c_(ras) coordinates in mris_info output!')
tx = float(m.group(1))
ty = float(m.group(2))
tz = float(m.group(3))
# transform vertex positions to scanner RAS of orig.mgz
reader = vtkPolyDataReader()
reader.SetFileName(temp_name)
reader.Update()
surface = reader.GetOutput()
points = surface.GetPoints()
for i in range(points.GetNumberOfPoints()):
x, y, z = points.GetPoint(i)
points.SetPoint(i, x + tx, y + ty, z + tz)
surface.SetPoints(points)
if output_name.endswith('.vtp'): writer = vtkXMLPolyDataWriter()
else: writer = vtkPolyDataWriter()
writer.SetFileName(output_name)
writer.SetInput(surface)
writer.Write()
if temp_name != output_name:
remove(temp_name)
def write(obj, fileoutput):
'''
Write 3D object to file.
Possile extensions are: .vtk, .ply, .obj, .stl, .byu, .vtp
'''
fr = fileoutput.lower()
if '.vtk' in fr: w = vtk.vtkPolyDataWriter()
elif '.ply' in fr: w = vtk.vtkPLYWriter()
elif '.obj' in fr:
w = vtk.vtkOBJExporter()
w.SetFilePrefix(fileoutput.replace('.obj', ''))
vc.printc('Please use write(vp.renderWin)', 3)
w.SetInput(obj)
w.Update()
vc.printc("Saved file: " + fileoutput, 'g')
return
elif '.stl' in fr:
w = vtk.vtkSTLWriter()
elif '.byu' in fr or '.g' in fr:
w = vtk.vtkBYUWriter()
elif '.vtp' in fr:
w = vtk.vtkXMLPolyDataWriter()
else:
vc.printc('Unavailable format in file ' + fileoutput, c='r')
exit(1)
try:
vu.setInput(w, vu.polydata(obj, True))
w.SetFileName(fileoutput)
w.Write()
vc.printc("Saved file: " + fileoutput, 'g')
except:
vc.printc("Error saving: " + fileoutput, 'r')
def write_landmarks_as_vtk_points(self, dir_name=None):
if dir_name is None:
dir_name = str(self.config.temp_dir)
print('Writing to', dir_name)
lm_name = dir_name + '/lms_as_points.vtk'
n_landmarks = self.heatmap_maxima.shape[0]
pd = vtk.vtkPolyData()
points = vtk.vtkPoints()
verts = vtk.vtkCellArray()
for lm_no in range(n_landmarks):
pid = points.InsertNextPoint(self.landmarks[lm_no, :])
verts.InsertNextCell(1)
verts.InsertCellPoint(pid)
pd.SetPoints(points)
del points
pd.SetVerts(verts)
del verts
writer = vtk.vtkPolyDataWriter()
writer.SetInputData(pd)
writer.SetFileName(lm_name)
writer.Write()
del writer
del pd
def WriteVTKNetworkFile(self):
if self.OutputFileName == '':
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing VTK network file.')
writer = vtk.vtkPolyDataWriter()
writer.SetInput(self.Network)
writer.SetFileName(self.OutputFileName)
writer.Write()
def WriteVTKSurfaceFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing VTK surface file.')
writer = vtk.vtkPolyDataWriter()
writer.SetInput(self.Surface)
writer.SetFileName(self.OutputFileName)
writer.Write()
def exportToVTKPolydata(self, filename):
"""
Export the reconstructed mesh to a VTKpolyMesh file.
@param filename: the name of the file
@type filename: str
"""
self.__exportToVtkDataExporter(vtk.vtkPolyDataWriter(),
self.vtkMesh.GetOutput(),
filename)
def WriteVTKSurfaceFile(self):
if self.OutputFileName == "":
self.PrintError("Error: no OutputFileName.")
self.PrintLog("Writing VTK surface file.")
writer = vtk.vtkPolyDataWriter()
if self.Ascii:
writer.SetDataModeToAscii()
writer.SetInput(self.Surface)
writer.SetFileName(self.OutputFileName)
writer.Write()
def ply2vtk(filename1,filename2):
"""Read a ply file and save as vtk ascii."""
reader = vtk.vtkPLYReader()
reader.SetFileName(filename1)
reader.Update()
writer = vtk.vtkPolyDataWriter()
writer.SetInputConnection(reader.GetOutputPort())
writer.SetFileTypeToASCII()
writer.SetFileName(filename2)
writer.Write()
def Run(profileFile):
"""Process all the Inlets specified by profileFile, solving the Navier-
Stokes equations for steady flow down an infinite channel with the cross
section of the inlet. Writes the point ID and the fluid velocity at that
point, the velocity being such that the integral of the flow across the
channel is unity.
Currently output is written as vtkPolyData to files like
"$GEOMETRYFILEBASENAME.inlet$ID.vtp"
"""
# Load the profile
profile = Profile()
profile.LoadFromFile(profileFile)
surfaceFile = profile.StlFile
surfaceFileScale = profile.StlFileUnit.SizeInMetres
print profile.OutputXmlFile
ipFinder = GeometryInletPointFinder(profile.OutputXmlFile)
inletPointIndices = ipFinder.GetInletData()
if len(inletPointIndices) == 0:
print "WARNING: no inletPointIndices found. This may mean that HemeLb is run with no inlets inside the simulation domain (e.g., the inlets defined in the xml file reside outside of the physical geometry)."
intersectionFinder = SurfaceIntersectionFinder()
intersectionFinder.SetFileName(surfaceFile)
intersectionFinder.SetFileUnitLength(surfaceFileScale)
for inletId, inlet in enumerate(io for io in profile.Iolets if isinstance(io, Inlet)):
print inletId, len(profile.Iolets), len(inletPointIndices)
inletPointPD = inletPointIndices[inletId]
intersectionFinder.SetIolet(inlet)
tesselator = Tesselator()
tesselator.SetInlet(inlet)
tesselator.SetEdgeConnection(intersectionFinder.GetOutputPort())
tesselator.SetSitesConnection(inletPointPD.GetProducerPort())
#solver = PoiseuilleSolver()
#solver.SetInputConnection(tesselator.GetOutputPort())
cellToPoint = vtk.vtkCellDataToPointData()
cellToPoint.SetInputConnection(tesselator.GetOutputPort())
cellToPoint.Update()
#writer = vtk.vtkXMLPolyDataWriter()
writer = vtk.vtkPolyDataWriter()
writer.SetFileTypeToASCII()
writer.SetInputConnection(cellToPoint.GetOutputPort())
# print type(cellToPoint) #cellToPoint is of type vtkobject
# print dir(cellToPoint)
base, gmy = os.path.splitext(profile.OutputGeometryFile)
writer.SetFileName(base + '.inlet%d.txt' % inletId)
writer.Write()
return base + '.inlet%d.txt' % inletId
def construct_and_write_poly_data(xy_list, z_list, vtk_file):
points = vtk.vtkPoints()
for ii, xy in enumerate(xy_list):
points.InsertPoint(ii, xy[0], xy[1], z_list[ii])
pointset = vtk.vtkPolyData()
pointset.SetPoints(points)
writer = vtk.vtkPolyDataWriter()
writer.SetInput(pointset)
writer.SetFileName(vtk_file)
writer.Write()
return pointset
def write_surface(ugrid, filename):
surface_filter = vtk.vtkDataSetSurfaceFilter()
surface_filter.SetInputData(ugrid)
triangle_filter = vtk.vtkTriangleFilter()
triangle_filter.SetInputConnection(surface_filter.GetOutputPort())
writer = vtk.vtkPolyDataWriter()
writer.SetFileName(filename)
writer.SetInputConnection(triangle_filter.GetOutputPort())
writer.Write()
def obj_to_vtk(in_filename, out_filename):
# Read the obj file
reader = vtk.vtkOBJReader()
reader.SetFileName(in_filename)
reader.Update()
# Write the vtk file
writer = vtk.vtkPolyDataWriter()
writer.SetFileName(out_filename)
writer.SetInputConnection(reader.GetOutputPort())
writer.Write()
def write(self):
writer=vtk.vtkPolyDataWriter()
writer.SetInput(self.probe_filter.GetOutput())
#proboje wczytac workspace z pliku, jesli sie nie uda to otwiera folder w ktorym sie znajduje kod
try:
dir=ReadFile().read_variable('output_folder:')
except:
dir=""
self.filename=asksaveasfilename(initialdir=dir,filetypes=[("allfiles","*"),("VTKfiles","*.vtk")])
writer.SetFileName(self.filename)
writer.Write()
def WriteVTKSurfaceFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing VTK surface file.')
writer = vtk.vtkPolyDataWriter()
writer.SetInputData(self.Surface)
writer.SetFileName(self.OutputFileName)
if self.Mode == "binary":
writer.SetFileTypeToBinary()
elif self.Mode == "ascii":
writer.SetFileTypeToASCII()
writer.Write()
def write_vtk(self, data_dir='./data', file_name='spines.vtk', binary=False):
"""
Write the spines into a vtk file.
call signature:
write_vtk(data_dir='./data', file_name='spines.vtk', binary=False)
Arguments:
*data_dir*:
Target data directory.
*file_name*:
Target file name.
*binary*:
Write file in binary or ASCII format.
"""
writer = vtk.vtkPolyDataWriter()
if binary:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
writer.SetFileName(os.path.join(data_dir, file_name))
poly_data = vtk.vtkPolyData()
points = vtk.vtkPoints()
# Create the cell to store the lines in.
cells = vtk.vtkCellArray()
poly_lines = []
offset = 0
for line_idx in range(len(self.spines)):
n_points = self.spines[line_idx].shape[0]
poly_lines.append(vtk.vtkPolyLine())
poly_lines[-1].GetPointIds().SetNumberOfIds(n_points)
for point_idx in range(n_points):
points.InsertNextPoint(self.spines[line_idx][point_idx])
poly_lines[-1].GetPointIds().SetId(point_idx,
point_idx + offset)
cells.InsertNextCell(poly_lines[-1])
offset += n_points
poly_data.SetPoints(points)
poly_data.SetLines(cells)
# Insure compatability between vtk 5 and 6.
try:
writer.SetInputData(poly_data)
except:
writer.SetInput(poly_data)
writer.Write()
def SavePoly():
option_verbose=__main__.option_verbose
my_print(option_verbose,'----------------------------')
my_print(option_verbose,'Saving VTK object')
polywriter=vtk.vtkPolyDataWriter()
polywriter.SetFileName('out_poly.vtk')
#polywriter.SetInputConnection(__main__.boundariespolydata.GetOutputPort())
#polywriter.SetInputConnection(__main__.polydata2.GetOutputPort())
polywriter.SetInputConnection(__main__.clean.GetOutputPort())
#polywriter.SetInputConnection(__main__.continentspolydata.GetOutputPort())
polywriter.Write()
