def OnExportSurface(self, pubsub_evt):
filename, filetype = pubsub_evt.data
if (filetype == const.FILETYPE_STL) or\
(filetype == const.FILETYPE_VTP) or\
(filetype == const.FILETYPE_PLY) or\
(filetype == const.FILETYPE_STL_ASCII):
# First we identify all surfaces that are selected
# (if any)
proj = prj.Project()
polydata_list = []
for index in proj.surface_dict:
surface = proj.surface_dict[index]
if surface.is_shown:
polydata_list.append(surface.polydata)
if len(polydata_list) == 0:
utl.debug("oops - no polydata")
return
elif len(polydata_list) == 1:
polydata = polydata_list[0]
else:
polydata = pu.Merge(polydata_list)
# Having a polydata that represents all surfaces
# selected, we write it, according to filetype
if filetype == const.FILETYPE_STL:
writer = vtk.vtkSTLWriter()
writer.SetFileTypeToBinary()
elif filetype == const.FILETYPE_STL_ASCII:
writer = vtk.vtkSTLWriter()
writer.SetFileTypeToASCII()
elif filetype == const.FILETYPE_VTP:
writer = vtk.vtkXMLPolyDataWriter()
#elif filetype == const.FILETYPE_IV:
# writer = vtk.vtkIVWriter()
elif filetype == const.FILETYPE_PLY:
writer = vtk.vtkPLYWriter()
writer.SetFileTypeToASCII()
writer.SetColorModeToOff()
#writer.SetDataByteOrderToLittleEndian()
#writer.SetColorModeToUniformCellColor()
#writer.SetColor(255, 0, 0)
if filetype in (const.FILETYPE_STL, const.FILETYPE_PLY):
# Invert normals
normals = vtk.vtkPolyDataNormals()
normals.SetInputData(polydata)
normals.SetFeatureAngle(80)
normals.AutoOrientNormalsOn()
# normals.GetOutput().ReleaseDataFlagOn()
normals.UpdateInformation()
normals.Update()
polydata = normals.GetOutput()
filename = filename.encode(wx.GetDefaultPyEncoding())
writer.SetFileName(filename)
writer.SetInputData(polydata)
writer.Write()
def OnExportSurface(self, pubsub_evt):
filename, filetype = pubsub_evt.data
if (filetype == const.FILETYPE_STL) or\
(filetype == const.FILETYPE_VTP) or\
(filetype == const.FILETYPE_PLY) or\
(filetype == const.FILETYPE_STL_ASCII):
# First we identify all surfaces that are selected
# (if any)
proj = prj.Project()
polydata_list = []
for index in proj.surface_dict:
surface = proj.surface_dict[index]
if surface.is_shown:
polydata_list.append(surface.polydata)
if len(polydata_list) == 0:
utl.debug("oops - no polydata")
return
elif len(polydata_list) == 1:
polydata = polydata_list[0]
else:
polydata = pu.Merge(polydata_list)
# Having a polydata that represents all surfaces
# selected, we write it, according to filetype
if filetype == const.FILETYPE_STL:
writer = vtk.vtkSTLWriter()
writer.SetFileTypeToBinary()
elif filetype == const.FILETYPE_STL_ASCII:
writer = vtk.vtkSTLWriter()
writer.SetFileTypeToASCII()
elif filetype == const.FILETYPE_VTP:
writer = vtk.vtkXMLPolyDataWriter()
#elif filetype == const.FILETYPE_IV:
# writer = vtk.vtkIVWriter()
elif filetype == const.FILETYPE_PLY:
writer = vtk.vtkPLYWriter()
writer.SetFileTypeToASCII()
writer.SetColorModeToOff()
#writer.SetDataByteOrderToLittleEndian()
#writer.SetColorModeToUniformCellColor()
#writer.SetColor(255, 0, 0)
if filetype in (const.FILETYPE_STL, const.FILETYPE_PLY):
# Invert normals
normals = vtk.vtkPolyDataNormals()
normals.SetInputData(polydata)
normals.SetFeatureAngle(80)
normals.AutoOrientNormalsOn()
# normals.GetOutput().ReleaseDataFlagOn()
normals.UpdateInformation()
normals.Update()
polydata = normals.GetOutput()
filename = filename.encode(wx.GetDefaultPyEncoding())
writer.SetFileName(filename)
writer.SetInputData(polydata)
writer.Write()
def write_data(input_data, filename):
"""
Write the given input data based on the file name extension.
Args:
input_data (vtkSTL/vtkPolyData/vtkXMLPolydata/vtkXMLUnstructured): Input data.
filename (str): Save path location.
"""
# Check filename format
fileType = filename.split(".")[-1]
if fileType == '':
raise NameError('The file does not have an extension')
# Get writer
if fileType == 'stl':
writer = vtk.vtkSTLWriter()
elif fileType == 'vtp':
writer = vtk.vtkXMLPolyDataWriter()
elif fileType == 'vtu':
writer = vtk.vtkXMLUnstructuredGridWriter()
else:
raise NameError('Unknown file type %s' % fileType)
# Set filename and input
writer.SetFileName(filename)
writer.SetInputData(input_data)
writer.Update()
# Write
writer.Write()
def create_mesh_and_save(cloud):
filename = "object.stl"
vtk_points = vtk.vtkPoints()
np_cloud = np.asarray(cloud)
for i in range(0, np_cloud.shape[0]):
vtk_points.InsertPoint(i, np_cloud[i][0], np_cloud[i][1], np_cloud[i][2])
profile = vtk.vtkPolyData()
profile.SetPoints(vtk_points)
aCellArray = vtk.vtkCellArray()
boundary = vtk.vtkPolyData()
boundary.SetPoints(profile.GetPoints())
boundary.SetPolys(aCellArray)
delny = vtk.vtkDelaunay2D()
delny.SetInputData(profile)
delny.SetSourceData(boundary)
delny.SetTolerance(0.0001)
delny.SetAlpha(4.0)
delny.SetOffset(1.25)
delny.BoundingTriangulationOff()
delny.Update()
stl_writer = vtk.vtkSTLWriter()
stl_writer.SetFileName(filename)
stl_writer.SetInputConnection(delny.GetOutputPort())
stl_writer.Write()
def get_boundaries(self):
'''
Extracts the boundaries of the model to a polydata object, if export_STL is selected then ask for where to save it.
'''
#can't be activated unless load_model has run
extract_surface = vtk.vtkDataSetSurfaceFilter()
extract_surface.SetInputDataObject(self.vtu_output)
extract_surface.Update()
self.model_boundary = vtk.vtkPolyData()
self.model_boundary = extract_surface.GetOutput()
msg = 'Extracted boundaries.'
if self.ui.export_STL_button.isChecked():
#get file name
fileo, _ = get_save_file('*.stl')
if fileo is None:
return
writer = vtk.vtkSTLWriter()
writer.SetFileName(fileo)
writer.SetInputData(self.model_boundary)
msg = 'Extracted boundaries and wrote STL file.' #overwrite msg if stl was written
writer.Write()
self.display_info(msg)
self.ui.vtkWidget.update()
def write_model_stl(self, path):
write = vtk.vtkSTLWriter()
write.SetInputData(self.mapper.GetInput())
write.SetFileTypeToBinary()
write.SetFileName(path)
write.Write()
write.Update()
def remesh_file(inputname, outputname, N):
_meshfix.clean_from_file(inputname, outputname)
stlReader = vtk.vtkSTLReader()
stlReader.SetFileName(outputname)
stlReader.Update()
mesh = stlReader.GetOutput()
mesh = pyvista.PolyData(mesh)
cobj = clustering.Clustering(mesh)
cobj.subdivide(
3
) # lijn toegevoegd tov python3 versie bart, want remeshing lukte niet cfr pyacvd documentatie
cobj.cluster(N)
remesh = cobj.create_mesh()
w = vtk.vtkSTLWriter()
w.SetFileName(outputname)
w.SetInputData(remesh)
w.Update()
_meshfix.clean_from_file(outputname, outputname)
ctrl, vil = read.read_stl(outputname)
mesh = TriangleMeshObject()
for xi in ctrl:
mesh.add_vertex(tuple(xi))
for ti in vil:
mesh.add_triangle(tuple([int(el) for el in ti]))
if mesh.is_cavity():
vil = [el[::-1] for el in vil]
write.save_stl(ctrl, vil, outputname)
return
def load_nii_save_stl(self,
in_name='data/skull.nii',
out_name='data/skull.stl',
threshold=100.0):
print "Function: load_nii_save_stl"
print "Para1: input file name (.nii file)\nPara2: output file name (.stl file)"
reader = vtk.vtkNIFTIImageReader()
reader.SetFileName(in_name)
reader.Update()
image = reader.GetOutput()
surface = vtk.vtkMarchingCubes()
surface.SetInputData(image)
surface.SetValue(0, threshold)
surface.Update()
# extract largest connectivity area
confilter = vtk.vtkPolyDataConnectivityFilter()
confilter.SetInputData(surface.GetOutput())
confilter.SetExtractionModeToLargestRegion()
confilter.Update()
skull = confilter.GetOutput()
writer = vtk.vtkSTLWriter()
writer.SetFileName(out_name)
writer.SetInputData(skull)
writer.Update()
print out_name, ' saved!'
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkSTLWriter(), 'Writing vtkSTL.',
('vtkSTL',), (),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def _save_polydata(self, data, write_bin=False):
"""
This private method saves into `filename` the `data`. `data` is a
vtkPolydata. It is possible to specify format for `filename`: if
`write_bin` is True, file is written in binary format, otherwise in
ASCII format. This method save cached polydata to reduce number of IO
operations.
:param vtkPolyData data: polydatat to save.
:param bool write_bin: for binary format file.
"""
self._cached_data = data
writer = vtk.vtkSTLWriter()
if write_bin:
writer.SetFileTypeToBinary()
writer.SetFileName(self._filename)
if vtk.VTK_MAJOR_VERSION <= 5:
writer.SetInput(data)
else:
writer.SetInputData(data)
writer.Write()
def save(self): # writer to new file
logger.log('Exporting temp STL of model %s...' % self.name)
# Extract transformations done to the actor
matrix = vtk.vtkMatrix4x4()
self.getActor().GetMatrix(matrix)
# Apply transformation
transform = vtk.vtkTransform()
transform.SetMatrix(matrix)
# T
t_filter = vtk.vtkTransformPolyDataFilter()
t_filter.SetInput(self.getPolyData())
t_filter.SetTransform(transform)
# Triangle filter
#vtkTriangleFilter
# Clean Polydata
#vtkcleanpolydata
# Simplify the model
#vtk.vtkDecimate
# Save data to a STL file
writer = vtk.vtkSTLWriter()
writer.SetFileName('temp.stl')
writer.SetInputConnection(t_filter.GetOutputPort())
writer.SetFileTypeToBinary()
writer.Write()
logger.log('End exporting')
def createSTL(mha, stl):
reader = vtk.vtkMetaImageReader()
reader.SetFileName(mha)
reader.Update()
threshold = vtk.vtkImageThreshold()
threshold.SetInputConnection(reader.GetOutputPort())
threshold.ThresholdByLower(0.1)
threshold.ReplaceInOn()
threshold.SetInValue(0) # set all values below 0.1 to 0
threshold.ReplaceOutOn()
threshold.SetOutValue(1) # set all values above 0.1 to 1
threshold.Update()
dmc = vtk.vtkFlyingEdges3D()
dmc.SetInputConnection(threshold.GetOutputPort())
dmc.ComputeNormalsOn()
dmc.GenerateValues(1, 1, 1)
dmc.Update()
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(dmc.GetOutputPort())
smoother.SetNumberOfIterations(15)
smoother.BoundarySmoothingOff()
smoother.Update()
writer = vtk.vtkSTLWriter()
writer.SetInputConnection(smoother.GetOutputPort())
writer.SetFileTypeToBinary()
writer.SetFileName(stl)
writer.Write()
return 0
def save_stl(array, spacing, origin, name):
# array to vtkImageData
flatten_array = array.ravel()
shape = np.array(array.shape)
vtk_data_array = numpy_to_vtk(
num_array=
flatten_array, # ndarray contains the fitting result from the points. It is a 3D array
deep=True,
array_type=vtk.VTK_FLOAT)
# convert vessel array to poly and save as STL
img_vtk = vtk.vtkImageData()
img_vtk.SetDimensions(shape[::-1])
img_vtk.SetSpacing(spacing)
img_vtk.SetOrigin(origin)
img_vtk.SetDirectionMatrix(-1, 0, 0, 0, -1, 0, 0, 0, 1)
img_vtk.GetPointData().SetScalars(vtk_data_array)
surf = vtk.vtkDiscreteMarchingCubes()
surf.SetInputData(img_vtk)
surf.SetValue(0, array.max())
# smoothing the mesh
smoother = vtk.vtkSmoothPolyDataFilter()
smoother.SetInputConnection(surf.GetOutputPort())
smoother.SetNumberOfIterations(50)
smoother.SetRelaxationFactor(0.1)
smoother.FeatureEdgeSmoothingOff()
smoother.BoundarySmoothingOn()
smoother.Update()
stl_writer = vtk.vtkSTLWriter()
stl_writer.SetFileName(name)
stl_writer.SetInputData(smoother.GetOutput())
stl_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 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 _save_polydata(self, data, write_bin=False):
"""
This private method saves into `filename` the `data`. `data` is a
vtkPolydata. It is possible to specify format for `filename`: if
`write_bin` is True, file is written in binary format, otherwise in
ASCII format. This method save cached polydata to reduce number of IO
operations.
:param vtkPolyData data: polydatat to save.
:param bool write_bin: for binary format file.
"""
self._cached_data = data
writer = vtk.vtkSTLWriter()
if write_bin:
writer.SetFileTypeToBinary()
writer.SetFileName(self._filename)
if vtk.VTK_MAJOR_VERSION <= 5:
writer.SetInput(data)
else:
writer.SetInputData(data)
writer.Write()
def write_STL(pointCloud):
# Write the stl file to disk
filename = "DataPoints.stl"
stlWriter = vtk.vtkSTLWriter()
stlWriter.SetFileName(filename)
stlWriter.SetInputData(pointCloud.vtkPolyData)
stlWriter.Write()
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 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 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 GravarModeloCortado(self, path):
write = vtk.vtkSTLWriter()
write.SetInputConnection(self.clipper.GetOutputPort())
write.SetFileTypeToBinary()
write.SetFileName(path)
write.Write()
write.Update()
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 write_to_file(filename, face_to_delete, output_filename):
Points = vtk.vtkPoints()
Triangles = vtk.vtkCellArray()
Triangle = vtk.vtkTriangle()
points, faces = parse(filename)
for point in points:
id = Points.InsertNextPoint(point[0], point[1], point[2])
for i, face in enumerate(faces):
skip = compare_faces(face_to_delete, face)
if not skip:
Triangle.GetPointIds().SetId(0, int(face[0]))
Triangle.GetPointIds().SetId(1, int(face[1]))
Triangle.GetPointIds().SetId(2, int(face[2]))
Triangles.InsertNextCell(Triangle)
polydata = vtk.vtkPolyData()
polydata.SetPoints(Points)
polydata.SetPolys(Triangles)
polydata.Modified()
if vtk.VTK_MAJOR_VERSION <= 5:
polydata.Update()
writer = vtk.vtkSTLWriter()
writer.SetFileName(output_filename)
if vtk.VTK_MAJOR_VERSION <= 5:
writer.SetInput(polydata)
else:
writer.SetInputData(polydata)
writer.Write()
def smooth_surface(vtk_path, output_path):
reader = vtk.vtkPolyDataReader()
reader.SetFileName(vtk_path)
reader.Update()
if (reader.GetOutput().GetNumberOfPoints() == 0):
print('WARNING: nothing to smooth for', vtk_path)
return
smoothingIterations = 50
passBand = 0.05
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(reader.GetOutputPort())
smoother.SetNumberOfIterations(smoothingIterations)
smoother.SetPassBand(passBand)
smoother.Update()
decimate = vtk.vtkDecimatePro()
decimate.SetInputData(smoother.GetOutput())
decimate.SetTargetReduction(0.8)
decimate.PreserveTopologyOn()
decimate.Update()
writer = vtk.vtkSTLWriter()
writer.SetInputData(decimate.GetOutput())
writer.SetFileTypeToASCII()
writer.SetFileName(output_path) # .stl
writer.Update()
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 labels2meshes_vtk(surfdir,
compdict,
labelimage,
labels=[],
spacing=[1, 1, 1],
offset=[0, 0, 0],
nvoxthr=0):
"""Generate meshes from a labelimage with vtk marching cubes."""
try:
import vtk
except ImportError:
return
if not labels:
labels = np.unique(labelimage)
labels = np.delete(labels, 0)
# labels = np.unique(labelimage[labelimage > 0])
print('number of labels to process: ', len(labels))
labelimage = np.lib.pad(labelimage.tolist(), ((1, 1), (1, 1), (1, 1)),
'constant')
dims = labelimage.shape
vol = vtk.vtkImageData()
vol.SetDimensions(dims[0], dims[1], dims[2])
vol.SetOrigin(offset[0] * spacing[0] + spacing[0],
offset[1] * spacing[1] + spacing[1],
offset[2] * spacing[2] + spacing[2])
# vol.SetOrigin(0, 0, 0)
vol.SetSpacing(spacing[0], spacing[1], spacing[2])
sc = vtk.vtkFloatArray()
sc.SetNumberOfValues(labelimage.size)
sc.SetNumberOfComponents(1)
sc.SetName('tnf')
for ii, val in enumerate(np.ravel(labelimage.swapaxes(0, 2))):
# FIXME: why swapaxes???
sc.SetValue(ii, val)
vol.GetPointData().SetScalars(sc)
dmc = vtk.vtkDiscreteMarchingCubes()
dmc.SetInput(vol)
dmc.ComputeNormalsOn()
for label in labels:
try:
labelname = compdict[label]['name']
except KeyError:
labelname = 'label.{:05d}'.format(label)
fpath = os.path.join(surfdir, '{:s}.stl'.format(labelname))
print("Processing label {} (value: {:05d})".format(labelname, label))
dmc.SetValue(0, label)
dmc.Update()
writer = vtk.vtkSTLWriter()
writer.SetInputConnection(dmc.GetOutputPort())
writer.SetFileName(fpath)
writer.Write()
def main():
# data_dir = os.environ.get('OneDrive') + r'\data\dti_navigation\joonas'
#
# filenames = {'T1': 'sub-S1_ses-S8741_T1w',
# 'STL_INVESALIUS': 'half_head_inv',
# 'STL_WORLD': 'half_head_world'}
subj_id = 7
item = 'brain'
data_dir = os.environ.get(
'OneDrive') + r'\data\nexstim_coord\mri\ppM1_S{}'.format(subj_id)
filenames = {
'T1': 'ppM1_S{}'.format(subj_id),
'STL_INVESALIUS': 'ppM1_S{}_{}_shell_inv'.format(subj_id, item),
'STL_WORLD': 'ppM1_S{}_{}_shell_world'.format(subj_id, item)
}
img_path = os.path.join(data_dir, filenames['T1'] + '.nii')
stl_invesalius_path = os.path.join(data_dir,
filenames['STL_INVESALIUS'] + '.stl')
stl_world_path = os.path.join(data_dir, filenames['STL_WORLD'] + '.stl')
imagedata, affine = imf.load_image(img_path)
# mri2inv_mat = imf.mri2inv(imagedata, affine)
inv2mri_mat = imf.inv2mri(imagedata, affine)
matrix_vtk = vtk.vtkMatrix4x4()
for row in range(0, 4):
for col in range(0, 4):
matrix_vtk.SetElement(row, col, inv2mri_mat[row, col])
reader = vtk.vtkSTLReader()
reader.SetFileName(stl_invesalius_path)
reader.Update()
# poly_normals = vtk.vtkPolyDataNormals()
# poly_normals.SetInputData(reader.GetOutput())
# poly_normals.ConsistencyOn()
# poly_normals.AutoOrientNormalsOn()
# poly_normals.SplittingOff()
# poly_normals.UpdateInformation()
# poly_normals.Update()
transform = vtk.vtkTransform()
transform.SetMatrix(matrix_vtk)
transform_polydata = vtk.vtkTransformPolyDataFilter()
transform_polydata.SetTransform(transform)
transform_polydata.SetInputData(reader.GetOutput())
transform_polydata.Update()
stl_writer = vtk.vtkSTLWriter()
stl_writer.SetFileTypeToBinary()
stl_writer.SetFileName(stl_world_path)
stl_writer.SetInputConnection(transform_polydata.GetOutputPort())
stl_writer.Write()
def labels2meshes_vtk(datadir,
compdict,
labelimage,
labels=[],
spacing=[1, 1, 1],
offset=[0, 0, 0],
nvoxthr=0):
""""""
if not labels:
labels = np.unique(labelimage)
labels = np.delete(labels,
0) # labels = np.unique(labelimage[labelimage>0])
print('number of labels to process: ', len(labels))
labelimage = np.lib.pad(labelimage.tolist(), ((1, 1), (1, 1), (1, 1)),
'constant')
dims = labelimage.shape
vol = vtk.vtkImageData()
vol.SetDimensions(dims[0], dims[1], dims[2])
vol.SetOrigin(offset[0] * spacing[0] + spacing[0],
offset[1] * spacing[1] + spacing[1], offset[2] * spacing[2] +
spacing[2]) # vol.SetOrigin(0, 0, 0)
vol.SetSpacing(spacing[0], spacing[1], spacing[2])
sc = vtk.vtkFloatArray()
sc.SetNumberOfValues(labelimage.size)
sc.SetNumberOfComponents(1)
sc.SetName('tnf')
for ii, val in enumerate(np.ravel(labelimage.swapaxes(
0, 2))): # why swapaxes???
sc.SetValue(ii, val)
vol.GetPointData().SetScalars(sc)
dmc = vtk.vtkDiscreteMarchingCubes()
dmc.SetInput(vol)
dmc.ComputeNormalsOn()
surfdir = 'dmcsurf'
mkdir_p(os.path.join(datadir, surfdir))
for ii, label in enumerate(labels):
for labelclass, labels in compdict.items():
if label in labels:
break
else:
labelclass = 'NN'
ndepth = 1
fpath = os.path.join(
datadir, surfdir,
labelclass + '.{:05d}.{:02d}.stl'.format(label, ndepth))
print("Processing labelnr " + str(ii) + " of class " + labelclass +
" with value: " + str(label))
# print("Saving to " + fpath)
dmc.SetValue(0, label)
# dmc.GenerateValues(nb_labels, 0, nb_labels)
dmc.Update()
writer = vtk.vtkSTLWriter()
writer.SetInputConnection(dmc.GetOutputPort())
writer.SetFileName(fpath)
writer.Write()
def saveCone(self, path):
filename = path + "/" + self.coneNameInput.text() + "stl"
self.cone.SetResolution(int(self.coneResoluInput.text()))
writer = vtk.vtkSTLWriter()
writer.SetFileName(filename)
writer.SetInputConnection(self.cone.GetOutputPort())
writer.Write()
def WriteSTLSurfaceFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing STL surface file.')
writer = vtk.vtkSTLWriter()
writer.SetInputData(self.Surface)
writer.SetFileName(self.OutputFileName)
writer.Write()
def WriteModel(self):
"""Writes model to file as stl file"""
if self.fname == '':
self.fname = 'Model1'
stlWriter = vtk.vtkSTLWriter()
stlWriter.SetFileName(self.fname + '.stl')
stlWriter.SetInputData(self.clipped.GetOutput())
stlWriter.Write()
def salva_triOsso(self, path):
assembly = self.assemblagem(self.ListaOssos)
write = vtk.vtkSTLWriter()
write.SetInputConnection(assembly.GetOutputPort())
write.SetFileTypeToBinary()
write.SetFileName(path)
write.Write()
write.Update()
def vtp_to_stl(file_in, file_out):
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(file_in)
writer = vtk.vtkSTLWriter()
writer.SetInputConnection(reader.GetOutputPort())
writer.SetFileName(file_out)
writer.SetFileTypeToBinary()
writer.Write()
def writeStl(self, name):
# Write the stl file to disk
self.writer = vtk.vtkSTLWriter()
self.writer.SetFileName(name)
# self.writer.SetFileTypeToASCII()
self.writer.SetFileTypeToBinary()
self.writer.SetInputConnection(self.reader.GetOutputPort())
self.writer.Write()
def OnSaveSTL(self, e):
path = self._dialog_save()
if path:
w = vtk.vtkSTLWriter()
w.SetFileTypeToBinary()
w.SetFileName(path)
w.SetInputData(self.cortical_viewer.actor.GetMapper().GetInput())
w.Write()
def WriteSTLSurfaceFile(self):
if self.OutputFileName == "":
self.PrintError("Error: no OutputFileName.")
self.PrintLog("Writing STL surface file.")
writer = vtk.vtkSTLWriter()
writer.SetInput(self.Surface)
writer.SetFileName(self.OutputFileName)
writer.Write()
def ConvertMSH(file_name):
out_name = file_name.split('.')[0]+'.stl'
print 'Out file:'+out_name
# read file head
file = open(file_name,'r')
line = file.readline().split('=')
while(line[0].strip() != 'Points'):
line = file.readline().split('=')
print 'Processing ', line[0]
if(line[0].strip() == 'NPoints'):
num_Points = int(line[1].strip())
print 'Number of Points is ' + str(num_Points)
# put in to vtkPoints
print 'Writing Points'
points = vtk.vtkPoints()
points.SetNumberOfPoints(num_Points)
for i in range(0,num_Points):
line = file.readline()
nums = line.split( )
x = float(nums[1])
y = float(nums[2])
z = float(nums[3])
points.SetPoint(i,x,y,z)
# create cells
print 'Writing Cells'
line = file.readline().split('=')
while(line[0].strip() != 'Cells'):
line = file.readline().split('=')
print 'Processing ', line[0]
if(line[0].strip() == 'NCells'):
num_Triangles = int(line[1].strip())
print 'Number of num_Triangles: '+str(num_Triangles)
polys = vtk.vtkCellArray()
for i in range(1,num_Triangles):
line = file.readline()
nums = line.split( )
a = int(nums[1])
b = int(nums[2])
c = int(nums[3])
polys.InsertNextCell(3)
polys.InsertCellPoint(a)
polys.InsertCellPoint(b)
polys.InsertCellPoint(c)
polyData = vtk.vtkPolyData()
polyData.SetPoints(points)
polyData.SetPolys(polys)
print 'Writing to STL file'
writer = vtk.vtkSTLWriter()
writer.SetFileName(out_name)
writer.SetInputData(polyData)
writer.Update()
def exportToSTL(self, filename):
"""
Export the rendered scene to a Wavefront .obj file.
@param filename: the name of the file
@type filename: str
"""
self.__exportToVtkDataExporter(vtk.vtkSTLWriter(),
self.vtkMesh.GetOutput(),
filename)
def write_stl(ugrid, filename):
surface_filter = vtk.vtkDataSetSurfaceFilter()
surface_filter.SetInputData(ugrid)
triangle_filter = vtk.vtkTriangleFilter()
triangle_filter.SetInputConnection(surface_filter.GetOutputPort())
writer = vtk.vtkSTLWriter()
writer.SetFileName(filename)
writer.SetInputConnection(triangle_filter.GetOutputPort())
writer.Write()
def main():
poly = load_file(sys.argv[1])
steps = int(sys.argv[3])
new_poly = taubin_smooth(poly, 0.5, -0.53, steps)
w = vtk.vtkSTLWriter()
w.SetFileName(sys.argv[2])
w.SetInput(new_poly)
w.SetFileTypeToBinary()
w.Write()
def writeSTL(
pdata,
filename,
verbose=1):
myVTK.myPrint(verbose, "*** writeSTL: " + filename + " ***")
stl_writer = vtk.vtkSTLWriter()
stl_writer.SetFileName(filename)
stl_writer.SetInputData(pdata)
stl_writer.Update()
stl_writer.Write()
def WriteSTLSurfaceFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing STL surface file.')
writer = vtk.vtkSTLWriter()
writer.SetInputData(self.Surface)
writer.SetFileName(self.OutputFileName)
if self.Mode == "binary":
writer.SetFileTypeToBinary()
elif self.Mode == "ascii":
writer.SetFileTypeToASCII()
writer.Write()
def vtk2stl(fn_in, fn_out):
reader = vtk.vtkDataSetReader()
reader.SetFileName(fn_in)
reader.Update()
gfilter = vtk.vtkGeometryFilter()
gfilter.SetInput(reader.GetOutput())
writer = vtk.vtkSTLWriter()
writer.SetFileName(fn_out)
writer.SetInput(gfilter.GetOutput())
writer.Write()
def gravar_Modelo_stl(self, path):
app_polidata = vtk.vtkAppendPolyData()
app_polidata.AddInput(self.polydata)
app_polidata.AddInput(self.estruturas.GetOutput())
app_polidata.Update()
write = vtk.vtkSTLWriter()
write.SetInputData(app_polidata.GetOutput())
write.SetFileTypeToBinary()
write.SetFileName(path)
write.Write()
write.Update()
def __init__(self):
"""
Initializes VTK objects for rendering.
"""
# vtk objects for rendering
self.vtkrenderer = vtk.vtkRenderer()
self.vtkcamera = vtk.vtkCamera()
self.vtkcamera.SetPosition(self.camera_pos)
self.vtkcamera.SetFocalPoint(0, 0, 0)
self.vtkcamera.SetViewUp(self.camera_up)
# lighting
self.light1 = vtk.vtkLight()
self.light1.SetIntensity(.4)
self.light1.SetPosition(10, -10, 10)
self.light1.SetDiffuseColor(1, 1, 1)
self.light2 = vtk.vtkLight()
self.light2.SetIntensity(.4)
self.light2.SetPosition(-10, -10, 10)
self.light2.SetDiffuseColor(1, 1, 1)
self.light3 = vtk.vtkLight()
self.light3.SetIntensity(.4)
self.light3.SetPosition(10, -10, -10)
self.light3.SetDiffuseColor(1, 1, 1)
self.light4 = vtk.vtkLight()
self.light4.SetIntensity(.4)
self.light4.SetPosition(-10, -10, -10)
self.light4.SetDiffuseColor(1, 1, 1)
self.vtkrenderer.AddLight(self.light1)
self.vtkrenderer.AddLight(self.light2)
self.vtkrenderer.AddLight(self.light3)
self.vtkrenderer.AddLight(self.light4)
self.vtkrenderer.SetBackground(0.1, 0.1, 0.1) # Background color
self.vtkrender_window = vtk.vtkRenderWindow()
self.vtkrender_window.AddRenderer(self.vtkrenderer)
self.vtkrender_window.SetSize(self.render_size)
self.vtkrender_window_interactor = vtk.vtkRenderWindowInteractor()
self.vtkrender_window_interactor.SetRenderWindow(self.vtkrender_window)
# vtk objects for reading, and rendering object parts
self.part_source = vtk.vtkCubeSource()
self.part_output = self.part_source.GetOutput()
self.part_mapper = vtk.vtkPolyDataMapper()
self.part_mapper.SetInput(self.part_output)
# exporters
self.vtkvrml_exporter = vtk.vtkVRMLExporter()
self.vtkobj_exporter = vtk.vtkOBJExporter()
self.stl_writer = vtk.vtkSTLWriter()
def main():
poly = load_file('monkey.ply')
poly.BuildLinks(0)
np = poly.GetNumberOfPoints()
Ls = numpy.zeros((np, np))
X, Y, Z = numpy_support.vtk_to_numpy(poly.GetPoints().GetData()).transpose()
for i in xrange(np):
for j in xrange(np):
if i != j :
if poly.IsEdge(i, j):
Ls[i, j] = -1
Ls[i, i] += 1
Ls = numpy.matrix(Ls)
Dx = X * Ls
Dy = Y * Ls
Dz = Z * Ls
Dxg = gaussian_filter1d(Dx, 1)
Dyg = gaussian_filter1d(Dy, 1)
Dzg = gaussian_filter1d(Dz, 1)
#Lsn = numpy.linalg.inv(Ls)
#Xn = Lsn * Dxg
#Yn = Lsn * Dyg
#Zn = Lsn * Dzg
X[:] = numpy.linalg.lstsq(Ls, Dxg.transpose())
Y[:] = Dyg[0, :]
Z[:] = Dzg[0, :]
print X.shape
V = numpy.zeros((np, 3))
V[:,0] = X
V[:,1] = Y
V[:,2] = Z
poly.GetPoints().SetData(numpy_support.numpy_to_vtk(V))
poly.BuildLinks(0)
poly.BuildCells()
w = vtk.vtkSTLWriter()
w.SetFileName('/tmp/teste.stl')
w.SetInput(poly)
w.Write()
def writeSTL(
pdata,
filename,
verbose=1):
myVTK.myPrint(verbose, "*** writeSTL: "+filename+" ***")
stl_writer = vtk.vtkSTLWriter()
stl_writer.SetFileName(filename)
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
stl_writer.SetInputData(pdata)
else:
stl_writer.SetInput(pdata)
stl_writer.Update()
stl_writer.Write()
def CylinderGenerator(radius, length, resolution, outfile, direction=(0,0,1)):
"""Write an STL file of a triangulated, uncapped, origin-centred cylinder
of the specified radius, length and resolution to the specified file.
"""
tcs = TriangulatedCylinderSource()
w = vtkSTLWriter()
w.SetInputConnection(tcs.GetOutputPort())
tcs.SetRadius(radius)
tcs.SetResolution(resolution)
tcs.SetHeight(length)
tcs.SetDirection(direction)
tcs.CappingOff()
w.SetFileName(outfile)
w.Write()
def writeSTL(mesh, name):
try:
writer = vtk.vtkSTLWriter()
if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
print "writeSTL 1"
writer.SetInputData( mesh )
else:
print "writeSTL 2"
writer.SetInput( mesh )
writer.SetFileTypeToBinary()
writer.SetFileName( name )
writer.Write()
print "Output mesh:", name
writer = None
except:
print "STL mesh writer failed"
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout)
return None
def vtk2stl(fn_in, fn_out):
reader = vtk.vtkDataSetReader()
reader.SetFileName(fn_in)
reader.Update()
gfilter = vtk.vtkGeometryFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
gfilter.SetInput(reader.GetOutput())
else:
gfilter.SetInputData(reader.GetOutput())
gfilter.Update()
writer = vtk.vtkSTLWriter()
writer.SetFileName(fn_out)
if vtk.VTK_MAJOR_VERSION <= 5:
writer.SetInput(gfilter.GetOutput())
else:
writer.SetInputData(gfilter.GetOutput())
writer.Write()
def getWriter(self,polyData):
writer = None;
if self.destFormat == "ply":
writer = vtk.vtkPLYWriter();
writer.SetFileTypeToBinary();
elif self.destFormat == "stl":
writer = vtk.vtkSTLWriter();
writer.SetFileTypeToBinary();
elif self.destFormat == "vtp":
writer = vtk.vtkXMLPolyDataWriter();
writer.SetDataModeToBinary();
elif self.destFormat == "obj":
writer = VTKOBJWriter();
elif self.destFormat == "json":
writer = my_vtkGeoJSONWriter();
else:
raise IOError("Export {} is not supported currently".format(self.destFormat));
writer.SetFileName(self.dest);
writer.SetInputData(polyData);
return writer;
def write(self, mesh_points, filename, write_bin=False):
"""
Writes a stl file, called filename, copying all the lines from
self.filename but the coordinates. mesh_points is a matrix that contains
the new coordinates to write in the stl file.
:param numpy.ndarray mesh_points: it is a `n_points`-by-3 matrix
containing the coordinates of the points of the mesh.
:param string filename: name of the output file.
:param boolean write_bin: flag to write in the binary format. Default is
False.
"""
self._check_filename_type(filename)
self._check_extension(filename)
self._check_infile_instantiation()
self.outfile = filename
reader = vtk.vtkSTLReader()
reader.SetFileName(self.infile)
reader.Update()
data = reader.GetOutput()
points = vtk.vtkPoints()
for i in range(data.GetNumberOfPoints()):
points.InsertNextPoint(mesh_points[i, :])
data.SetPoints(points)
writer = vtk.vtkSTLWriter()
writer.SetFileName(self.outfile)
writer.SetInputData(data)
if write_bin:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
writer.Write()
def decimate_pro(nameOfInputFile, nameOfOutputFile, reductionValue):
reader = vtkSTLReader()
reader.SetFileName(nameOfInputFile)
reader.Update()
input = vtkPolyData()
input.ShallowCopy(reader.GetOutput())
decimate = vtkDecimatePro()
decimate.SetInputConnection(input.GetProducerPort())
decimate.SetTargetReduction(reductionValue)
decimate.Update()
decimated = vtkPolyData()
decimated.ShallowCopy(decimate.GetOutput())
writer = vtk.vtkSTLWriter()
writer.SetFileName(nameOfOutputFile)
if vtk.VTK_MAJOR_VERSION <= 5:
writer.SetInput(decimated)
else:
writer.SetInputData(decimated)
writer.Write()
def __init__(self, module_manager):
# call parent constructor
ModuleBase.__init__(self, module_manager)
# need to make sure that we're all happy triangles and stuff
self._cleaner = vtk.vtkCleanPolyData()
self._tf = vtk.vtkTriangleFilter()
self._tf.SetInput(self._cleaner.GetOutput())
self._writer = vtk.vtkSTLWriter()
self._writer.SetInput(self._tf.GetOutput())
# 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()
# following is the standard way of connecting up the devide progress
# callback to a VTK object; you should do this for all objects in
mm = self._module_manager
for textobj in (('Cleaning data', self._cleaner),
('Converting to triangles', self._tf),
('Writing STL data', self._writer)):
module_utils.setup_vtk_object_progress(self, textobj[1],
textobj[0])
# ctor for this specific mixin
FilenameViewModuleMixin.__init__(
self,
'Select a filename',
'STL data (*.stl)|*.stl|All files (*)|*',
{'vtkSTLWriter': self._writer},
fileOpen=False)
# set up some defaults
self._config.filename = ''
self.sync_module_logic_with_config()
def main(filenameIn,filenameOut,xmin,ymin,zmin,dx,dy,dz,render):
# print vtk.VTK_MAJOR_VERSION # Check the version
# Read the file and create polydata
reader = vtk.vtkSTLReader()
reader.SetFileName(filenameIn)
# Define planes for clipping
Origins=[
[xmin,ymin,zmin],
[xmin,ymin,zmin],
[xmin,ymin,zmin],
[xmin+dx,ymin+dy,zmin+dz],
[xmin+dx,ymin+dy,zmin+dz],
[xmin+dx,ymin+dy,zmin+dz],
]
Normals=[
[[-1,0,0],[0,-1,0],[0,0,-1],[-1,0,0],[0,-1,0],[0,0,-1]],
[[+1,0,0],[0,-1,0],[0,0,-1],[-1,0,0],[0,-1,0],[0,0,-1]],
[[+1,0,0],[0,-1,0],[0,0,-1],[+1,0,0],[0,-1,0],[0,0,-1]],
[[-1,0,0],[0,+1,0],[0,0,-1],[-1,0,0],[0,-1,0],[0,0,-1]],
[[+1,0,0],[0,+1,0],[0,0,-1],[-1,0,0],[0,-1,0],[0,0,-1]],
[[+1,0,0],[0,+1,0],[0,0,-1],[+1,0,0],[0,-1,0],[0,0,-1]],
[[-1,0,0],[0,+1,0],[0,0,-1],[-1,0,0],[0,+1,0],[0,0,-1]],
[[+1,0,0],[0,+1,0],[0,0,-1],[-1,0,0],[0,+1,0],[0,0,-1]],
[[+1,0,0],[0,+1,0],[0,0,-1],[+1,0,0],[0,+1,0],[0,0,-1]],
[[-1,0,0],[0,-1,0],[0,0,+1],[-1,0,0],[0,-1,0],[0,0,-1]],
[[+1,0,0],[0,-1,0],[0,0,+1],[-1,0,0],[0,-1,0],[0,0,-1]],
[[+1,0,0],[0,-1,0],[0,0,+1],[+1,0,0],[0,-1,0],[0,0,-1]],
[[-1,0,0],[0,+1,0],[0,0,+1],[-1,0,0],[0,-1,0],[0,0,-1]],
[[+1,0,0],[0,+1,0],[0,0,+1],[-1,0,0],[0,-1,0],[0,0,-1]],
[[+1,0,0],[0,+1,0],[0,0,+1],[+1,0,0],[0,-1,0],[0,0,-1]],
[[-1,0,0],[0,+1,0],[0,0,+1],[-1,0,0],[0,+1,0],[0,0,-1]],
[[+1,0,0],[0,+1,0],[0,0,+1],[-1,0,0],[0,+1,0],[0,0,-1]],
[[+1,0,0],[0,+1,0],[0,0,+1],[+1,0,0],[0,+1,0],[0,0,-1]],
[[-1,0,0],[0,-1,0],[0,0,+1],[-1,0,0],[0,-1,0],[0,0,+1]],
[[+1,0,0],[0,-1,0],[0,0,+1],[-1,0,0],[0,-1,0],[0,0,+1]],
[[+1,0,0],[0,-1,0],[0,0,+1],[+1,0,0],[0,-1,0],[0,0,+1]],
[[-1,0,0],[0,+1,0],[0,0,+1],[-1,0,0],[0,-1,0],[0,0,+1]],
[[+1,0,0],[0,+1,0],[0,0,+1],[-1,0,0],[0,-1,0],[0,0,+1]],
[[+1,0,0],[0,+1,0],[0,0,+1],[+1,0,0],[0,-1,0],[0,0,+1]],
[[-1,0,0],[0,+1,0],[0,0,+1],[-1,0,0],[0,+1,0],[0,0,+1]],
[[+1,0,0],[0,+1,0],[0,0,+1],[-1,0,0],[0,+1,0],[0,0,+1]],
[[+1,0,0],[0,+1,0],[0,0,+1],[+1,0,0],[0,+1,0],[0,0,+1]],
]
# Define directions for moving clipped regions
Direction=[
[dx,dy,dz],
[0,dy,dz],
[-dx,dy,dz],
[dx,0,dz],
[0,0,dz],
[-dx,0,dz],
[dx,-dy,dz],
[0,-dy,dz],
[-dx,-dy,dz],
[dx,dy,0],
[0,dy,0],
[-dx,dy,0],
[dx,0,0],
[0,0,0],
[-dx,0,0],
[dx,-dy,0],
[0,-dy,0],
[-dx,-dy,0],
[dx,dy,-dz],
[0,dy,-dz],
[-dx,dy,-dz],
[dx,0,-dz],
[0,0,-dz],
[-dx,0,-dz],
[dx,-dy,-dz],
[0,-dy,-dz],
[-dx,-dy,-dz],
]
regions=[]
n=27
for j in xrange(n):
polydata=reader
# Clip it with all 6 planes
for i in xrange(6):
plane=vtk.vtkPlane()
plane.SetOrigin(Origins[i])
plane.SetNormal(Normals[j][i])
clipper = vtk.vtkClipPolyData()
clipper.SetInputConnection(polydata.GetOutputPort())
clipper.SetClipFunction(plane)
polydata=clipper
polydata.Update()
# Move it if not empty
if polydata.GetOutput().GetLength()>0:
transform = vtk.vtkTransform()
transform.Translate(Direction[j])
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputConnection(polydata.GetOutputPort())
transformFilter.Update()
regions.append(vtk.vtkPolyData())
regions[j].ShallowCopy(transformFilter.GetOutput())
else:
regions.append(vtk.vtkPolyData())
regions[j].ShallowCopy(polydata.GetOutput())
# Append the all regions
appendFilter = vtk.vtkAppendPolyData()
if vtk.VTK_MAJOR_VERSION <= 5:
for j in xrange(n):
appendFilter.AddInputConnection(regions[j].GetProducerPort())
else:
for j in xrange(n):
appendFilter.AddInputData(regions[j])
appendFilter.Update()
# Remove any duplicate points
cleanFilter = vtk.vtkCleanPolyData()
cleanFilter.SetInputConnection(appendFilter.GetOutputPort())
cleanFilter.Update()
# One more rotation - not needed
# transform = vtk.vtkTransform()
# transform.Translate(-6,-6,-6)
# transformFilter = vtk.vtkTransformPolyDataFilter()
# transformFilter.SetTransform(transform)
# transformFilter.SetInputConnection(cleanFilter.GetOutputPort())
# transformFilter.Update()
# transform = vtk.vtkTransform()
# transform.RotateWXYZ(90,1,0,0)
# transform.RotateWXYZ(-90,0,1,0)
# transformFilter2 = vtk.vtkTransformPolyDataFilter()
# transformFilter2.SetTransform(transform)
# transformFilter2.SetInputConnection(transformFilter.GetOutputPort())
# transformFilter2.Update()
# transform = vtk.vtkTransform()
# transform.Translate(6,6,6)
# transformFilter = vtk.vtkTransformPolyDataFilter()
# transformFilter.SetTransform(transform)
# transformFilter.SetInputConnection(transformFilter2.GetOutputPort())
# transformFilter.Update()
# Final data to be saved and displayed
finalData=cleanFilter
# Write the stl file to disk
stlWriter = vtk.vtkSTLWriter()
stlWriter.SetFileName(filenameOut)
stlWriter.SetInputConnection(finalData.GetOutputPort())
stlWriter.Write()
if render:
# Create mappper and actor for rendering
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(finalData.GetOutput())
else:
mapper.SetInputConnection(finalData.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Create a rendering window and renderer
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
# Create a renderwindowinteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Assign actor to the renderer
ren.AddActor(actor)
# Enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
#!/usr/bin/env python
import vtk
filename = "example1_python.stl"
sphereSource = vtk.vtkSphereSource()
sphereSource.Update()
# Write the stl file to disk
stlWriter = vtk.vtkSTLWriter()
stlWriter.SetFileName(filename)
stlWriter.SetInputConnection(sphereSource.GetOutputPort())
stlWriter.Write()
# Read and display for verification
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(reader.GetOutput())
else:
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Create a rendering window and renderer
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
def _makeSTL(self):
local_dir = self._gray_dir
surface_dir = self._vol_dir+'_surfaces'+self._path_dlm
try:
os.mkdir(surface_dir)
except:
pass
files = fnmatch.filter(sorted(os.listdir(local_dir)),'*.tif')
counter = re.search("[0-9]*\.tif", files[0]).group()
prefix = self._path_dlm+string.replace(files[0],counter,'')
counter = str(len(counter)-4)
prefixImageName = local_dir + prefix
### Create the renderer, the render window, and the interactor. The renderer
# The following reader is used to read a series of 2D slices (images)
# that compose the volume. The slice dimensions are set, and the
# pixel spacing. The data Endianness must also be specified. The reader
v16=vtk.vtkTIFFReader()
v16.SetFilePrefix(prefixImageName)
v16.SetDataExtent(0,100,0,100,1,len(files))
v16.SetFilePattern("%s%0"+counter+"d.tif")
v16.Update()
im = v16.GetOutput()
im.SetSpacing(self._pixel_dim[0],self._pixel_dim[1],self._pixel_dim[2])
v = vte.vtkImageExportToArray()
v.SetInputData(im)
n = np.float32(v.GetArray())
idx = np.argwhere(n)
(ystart,xstart,zstart), (ystop,xstop,zstop) = idx.min(0),idx.max(0)+1
I,J,K = n.shape
if ystart > 5:
ystart -= 5
else:
ystart = 0
if ystop < I-5:
ystop += 5
else:
ystop = I
if xstart > 5:
xstart -= 5
else:
xstart = 0
if xstop < J-5:
xstop += 5
else:
xstop = J
if zstart > 5:
zstart -= 5
else:
zstart = 0
if zstop < K-5:
zstop += 5
else:
zstop = K
a = n[ystart:ystop,xstart:xstop,zstart:zstop]
itk_img = sitk.GetImageFromArray(a)
itk_img.SetSpacing([self._pixel_dim[0],self._pixel_dim[1],self._pixel_dim[2]])
print "\n"
print "-------------------------------------------------------"
print "-- Applying Patch Based Denoising - this can be slow --"
print "-------------------------------------------------------"
print "\n"
pb = sitk.PatchBasedDenoisingImageFilter()
pb.KernelBandwidthEstimationOn()
pb.SetNoiseModel(3) #use a Poisson noise model since this is confocal
pb.SetNoiseModelFidelityWeight(1)
pb.SetNumberOfSamplePatches(20)
pb.SetPatchRadius(4)
pb.SetNumberOfIterations(10)
fimg = pb.Execute(itk_img)
b = sitk.GetArrayFromImage(fimg)
intensity = b.max()
#grad = sitk.GradientMagnitudeRecursiveGaussianImageFilter()
#grad.SetSigma(0.05)
gf = sitk.GradientMagnitudeImageFilter()
gf.UseImageSpacingOn()
grad = gf.Execute(fimg)
edge = sitk.Cast(sitk.BoundedReciprocal( grad ),sitk.sitkFloat32)
print "\n"
print "-------------------------------------------------------"
print "---- Thresholding to deterimine initial level sets ----"
print "-------------------------------------------------------"
print "\n"
t = 0.5
seed = sitk.BinaryThreshold(fimg,t*intensity)
#Opening (Erosion/Dilation) step to remove islands smaller than 2 voxels in radius)
seed = sitk.BinaryMorphologicalOpening(seed,2)
seed = sitk.BinaryFillhole(seed!=0)
#Get connected regions
r = sitk.ConnectedComponent(seed)
labels = sitk.GetArrayFromImage(r)
ids = sorted(np.unique(labels))
N = len(ids)
if N > 2:
i = np.copy(N)
while i == N and (t-self._tratio)>-1e-7:
t -= 0.01
seed = sitk.BinaryThreshold(fimg,t*intensity)
#Opening (Erosion/Dilation) step to remove islands smaller than 2 voxels in radius)
seed = sitk.BinaryMorphologicalOpening(seed,2)
seed = sitk.BinaryFillhole(seed!=0)
#Get connected regions
r = sitk.ConnectedComponent(seed)
labels = sitk.GetArrayFromImage(r)
i = len(np.unique(labels))
if i > N:
N = np.copy(i)
t+=0.01
else:
t = np.copy(self._tratio)
seed = sitk.BinaryThreshold(fimg,t*intensity)
#Opening (Erosion/Dilation) step to remove islands smaller than 2 voxels in radius)
seed = sitk.BinaryMorphologicalOpening(seed,2)
seed = sitk.BinaryFillhole(seed!=0)
#Get connected regions
r = sitk.ConnectedComponent(seed)
labels = sitk.GetArrayFromImage(r)
labels = np.unique(labels)[1:]
'''
labels[labels==0] = -1
labels = sitk.GetImageFromArray(labels)
labels.SetSpacing([self._pixel_dim[0],self._pixel_dim[1],self._pixel_dim[2]])
#myshow3d(labels,zslices=range(20))
#plt.show()
ls = sitk.ScalarChanAndVeseDenseLevelSetImageFilter()
ls.UseImageSpacingOn()
ls.SetLambda2(1.5)
#ls.SetCurvatureWeight(1.0)
ls.SetAreaWeight(1.0)
#ls.SetReinitializationSmoothingWeight(1.0)
ls.SetNumberOfIterations(100)
seg = ls.Execute(sitk.Cast(labels,sitk.sitkFloat32),sitk.Cast(fimg,sitk.sitkFloat32))
seg = sitk.Cast(seg,sitk.sitkUInt8)
seg = sitk.BinaryMorphologicalOpening(seg,1)
seg = sitk.BinaryFillhole(seg!=0)
#Get connected regions
#r = sitk.ConnectedComponent(seg)
contours = sitk.BinaryContour(seg)
myshow3d(sitk.LabelOverlay(sitk.Cast(fimg,sitk.sitkUInt8),contours),zslices=range(fimg.GetSize()[2]))
plt.show()
'''
segmentation = sitk.Image(r.GetSize(),sitk.sitkUInt8)
segmentation.SetSpacing([self._pixel_dim[0],self._pixel_dim[1],self._pixel_dim[2]])
for l in labels:
d = sitk.SignedMaurerDistanceMap(r==l,insideIsPositive=False,squaredDistance=True,useImageSpacing=True)
#d = sitk.BinaryThreshold(d,-1000,0)
#d = sitk.Cast(d,edge.GetPixelIDValue() )*-1+0.5
#d = sitk.Cast(d,edge.GetPixelIDValue() )
seg = sitk.GeodesicActiveContourLevelSetImageFilter()
seg.SetPropagationScaling(1.0)
seg.SetAdvectionScaling(1.0)
seg.SetCurvatureScaling(0.5)
seg.SetMaximumRMSError(0.01)
levelset = seg.Execute(d,edge)
levelset = sitk.BinaryThreshold(levelset,-1000,0)
segmentation = sitk.Add(segmentation,levelset)
print ("RMS Change for Cell %d: "% l,seg.GetRMSChange())
print ("Elapsed Iterations for Cell %d: "% l, seg.GetElapsedIterations())
'''
contours = sitk.BinaryContour(segmentation)
myshow3d(sitk.LabelOverlay(sitk.Cast(fimg,sitk.sitkUInt8),contours),zslices=range(fimg.GetSize()[2]))
plt.show()
'''
n[ystart:ystop,xstart:xstop,zstart:zstop] = sitk.GetArrayFromImage(segmentation)*100
i = vti.vtkImageImportFromArray()
i.SetDataSpacing([self._pixel_dim[0],self._pixel_dim[1],self._pixel_dim[2]])
i.SetDataExtent([0,100,0,100,1,len(files)])
i.SetArray(n)
i.Update()
thres=vtk.vtkImageThreshold()
thres.SetInputData(i.GetOutput())
thres.ThresholdByLower(0)
thres.ThresholdByUpper(101)
iso=vtk.vtkImageMarchingCubes()
iso.SetInputConnection(thres.GetOutputPort())
iso.SetValue(0,1)
regions = vtk.vtkConnectivityFilter()
regions.SetInputConnection(iso.GetOutputPort())
regions.SetExtractionModeToAllRegions()
regions.ColorRegionsOn()
regions.Update()
N = regions.GetNumberOfExtractedRegions()
for i in xrange(N):
r = vtk.vtkConnectivityFilter()
r.SetInputConnection(iso.GetOutputPort())
r.SetExtractionModeToSpecifiedRegions()
r.AddSpecifiedRegion(i)
g = vtk.vtkExtractUnstructuredGrid()
g.SetInputConnection(r.GetOutputPort())
geo = vtk.vtkGeometryFilter()
geo.SetInputConnection(g.GetOutputPort())
geo.Update()
t = vtk.vtkTriangleFilter()
t.SetInputConnection(geo.GetOutputPort())
t.Update()
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(t.GetOutputPort())
s = vtk.vtkSmoothPolyDataFilter()
s.SetInputConnection(cleaner.GetOutputPort())
s.SetNumberOfIterations(50)
dl = vtk.vtkDelaunay3D()
dl.SetInputConnection(s.GetOutputPort())
dl.Update()
self.cells.append(dl)
for i in xrange(N):
g = vtk.vtkGeometryFilter()
g.SetInputConnection(self.cells[i].GetOutputPort())
t = vtk.vtkTriangleFilter()
t.SetInputConnection(g.GetOutputPort())
#get the surface points of the cells and save to points attribute
v = t.GetOutput()
points = []
for j in xrange(v.GetNumberOfPoints()):
p = [0,0,0]
v.GetPoint(j,p)
points.append(p)
self.points.append(points)
#get the volume of the cell
vo = vtk.vtkMassProperties()
vo.SetInputConnection(t.GetOutputPort())
self.volumes.append(vo.GetVolume())
stl = vtk.vtkSTLWriter()
stl.SetInputConnection(t.GetOutputPort())
stl.SetFileName(surface_dir+'cell%02d.stl' % (i+self._counter))
stl.Write()
if self._display:
skinMapper = vtk.vtkDataSetMapper()
skinMapper.SetInputConnection(regions.GetOutputPort())
skinMapper.SetScalarRange(regions.GetOutput().GetPointData().GetArray("RegionId").GetRange())
skinMapper.SetColorModeToMapScalars()
#skinMapper.ScalarVisibilityOff()
skinMapper.Update()
skin = vtk.vtkActor()
skin.SetMapper(skinMapper)
#skin.GetProperty().SetColor(0,0,255)
# An outline provides context around the data.
#
outlineData = vtk.vtkOutlineFilter()
outlineData.SetInputConnection(v16.GetOutputPort())
mapOutline = vtk.vtkPolyDataMapper()
mapOutline.SetInputConnection(outlineData.GetOutputPort())
outline = vtk.vtkActor()
#outline.SetMapper(mapOutline)
#outline.GetProperty().SetColor(0,0,0)
colorbar = vtk.vtkScalarBarActor()
colorbar.SetLookupTable(skinMapper.GetLookupTable())
colorbar.SetTitle("Cells")
colorbar.SetNumberOfLabels(N)
# Create the renderer, the render window, and the interactor. The renderer
# draws into the render window, the interactor enables mouse- and
# keyboard-based interaction with the data within the render window.
#
aRenderer = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(aRenderer)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# It is convenient to create an initial view of the data. The FocalPoint
# and Position form a vector direction. Later on (ResetCamera() method)
# this vector is used to position the camera to look at the data in
# this direction.
aCamera = vtk.vtkCamera()
aCamera.SetViewUp (0, 0, -1)
aCamera.SetPosition (0, 1, 0)
aCamera.SetFocalPoint (0, 0, 0)
aCamera.ComputeViewPlaneNormal()
# Actors are added to the renderer. An initial camera view is created.
# The Dolly() method moves the camera towards the FocalPoint,
# thereby enlarging the image.
aRenderer.AddActor(outline)
aRenderer.AddActor(skin)
aRenderer.AddActor(colorbar)
aRenderer.SetActiveCamera(aCamera)
aRenderer.ResetCamera ()
aCamera.Dolly(1.5)
# Set a background color for the renderer and set the size of the
# render window (expressed in pixels).
aRenderer.SetBackground(0.0,0.0,0.0)
renWin.SetSize(800, 600)
# Note that when camera movement occurs (as it does in the Dolly()
# method), the clipping planes often need adjusting. Clipping planes
# consist of two planes: near and far along the view direction. The
# near plane clips out objects in front of the plane the far plane
# clips out objects behind the plane. This way only what is drawn
# between the planes is actually rendered.
aRenderer.ResetCameraClippingRange()
im=vtk.vtkWindowToImageFilter()
im.SetInput(renWin)
iren.Initialize();
iren.Start();
#remove gray directory
shutil.rmtree(local_dir)
