def run(neuron_num):
file = "meshes-with-axons-filled-assembled/n%02d.vtp" % neuron_num
readerVolume = vtk.vtkXMLPolyDataReader()
readerVolume.SetFileName(file)
readerVolume.Update()
decimate = readerVolume
nlod = 5
for i in range(nlod):
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(decimate.GetOutputPort())
smoother.SetNumberOfIterations(20) # This has little effect on the error!
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.SetPassBand(.1) # This increases the error a lot! .001
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.GenerateErrorScalarsOn()
smoother.Update()
decimate = vtk.vtkQuadricDecimation ()
decimate.SetInputData(smoother.GetOutput())
decimate.SetTargetReduction(.7)
decimate.Update()
full_out_name = 'meshes-with-axons-filled-assembled-lod/n%02d_LOD%d.obj' % (neuron_num, i - 1)
writer = vtk.vtkOBJWriter()
writer.SetFileName(full_out_name)
writer.SetInputData(decimate.GetOutput())
writer.Write()
def writeOBJ(mesh, name):
"""Write an STL mesh file."""
try:
writer = vtk.vtkOBJWriter()
"""
if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
print("writeSTL 1")
writer.SetInputData(mesh)
else:
print("writeSTL 2")
writer.SetInput(mesh)
"""
writer.SetInputData(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 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 writeSimpleOBJ(model, file):
file = file.with_suffix('.obj')
print(f'Writing File : {file}')
writer = vtk.vtkOBJWriter()
writer.SetFileName(str(file))
writer.SetInputData(model)
writer.Write()
def WriteOBJSurfaceFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing wavefront obj surface file.')
writer = vtk.vtkOBJWriter()
writer.SetInputData(self.Surface)
writer.SetFileName(self.OutputFileName)
writer.Write()
def vtk_writer(polydata, objfile):
assert polydata
from packaging import version
assert (version.parse(vtk.vtkVersion().GetVTKVersion()) >=
version.parse("8.2.0")), "OBJWriter is not available before 8.2.0"
obj_writer = vtk.vtkOBJWriter()
obj_writer.SetFileName(objfile)
obj_writer.SetInputData(polydata)
obj_writer.Update()
def writeToFile(fp,mesh,format='ply'):
name=mesh.name#.split("/")
#t=len(tmp)
#name=tmp[t-1].split(".")[0]
if format=='ply':
writer=vtk.vtkPLYWriter()
if format=='stl':
writer=vtk.vtkSTLWriter()
if format=='obj':
writer=vtk.vtkOBJWriter()
writer.SetInputData(mesh.polydata)
writer.SetFileName(os.path.join(fp, name+"."+format))
writer.Write()
return(True)
def file_output(file_path):
polydata_mesh = meshfactory.MeshFactory.mesh_from_file(file_path)
####### PLY ########################
plywriter = vtk.vtkPLYWriter()
plywriter.SetFileName(file_path + "_mesh_exported.ply")
plywriter.SetInputConnection(polydata_mesh.GetOutputPort())
plywriter.SetFileTypeToBinary()
plywriter.Write()
####### STL ########################
stlwriter = vtk.vtkSTLWriter()
stlwriter.SetFileName(file_path + "_mesh_exported.stl")
stlwriter.SetInputConnection(polydata_mesh.GetOutputPort())
stlwriter.SetFileTypeToBinary()
stlwriter.Write()
####### OBJ ########################
objwriter = vtk.vtkOBJWriter()
objwriter.SetFileName(file_path + "_mesh_exported.obj")
objwriter.SetInputConnection(polydata_mesh.GetOutputPort())
objwriter.SetFileTypeToBinary()
objwriter.Write()
def Write_Poly_Data(poly_data:Poly_Data, path):
'''
Input:
poly_data: Poly_Data, data to write
path: string, full path of data to write. Support stl, ply, obj, vtk.
Output:
Description: Write poly data in various formats.
'''
vtk_poly_data = poly_data.Get_vtkPolyData()
if path.endswith('.vtk'):
writer = vtk.vtkPolyDataWriter()
elif path.endswith('.stl'):
writer = vtk.vtkSTLWriter()
elif path.endswith('.ply'):
writer = vtk.vtkPLYWriter()
elif path.endswith('.obj'):
writer = vtk.vtkOBJWriter()
else:
return 0
writer.SetInputData(vtk_poly_data)
writer.SetFileName(path)
writer.Write()
def write(objct, fileoutput, binary=True):
"""
Write 3D object to file. (same as `save()`).
Possile extensions are:
- vtk, vti, npy, ply, obj, stl, byu, vtp, vti, mhd, xyz, tif, png, bmp.
"""
obj = objct
if isinstance(obj, Actor): # picks transformation
obj = objct.polydata(True)
elif isinstance(obj, (vtk.vtkActor, vtk.vtkVolume)):
obj = objct.GetMapper().GetInput()
elif isinstance(obj, (vtk.vtkPolyData, vtk.vtkImageData)):
obj = objct
fr = fileoutput.lower()
if ".vtk" in fr:
writer = vtk.vtkPolyDataWriter()
elif ".ply" in fr:
writer = vtk.vtkPLYWriter()
pscal = obj.GetPointData().GetScalars()
if not pscal:
pscal = obj.GetCellData().GetScalars()
if pscal and pscal.GetName():
writer.SetArrayName(pscal.GetName())
#writer.SetColorMode(0)
lut = objct.GetMapper().GetLookupTable()
if lut:
writer.SetLookupTable(lut)
elif ".stl" in fr:
writer = vtk.vtkSTLWriter()
elif ".obj" in fr:
writer = vtk.vtkOBJWriter()
elif ".vtp" in fr:
writer = vtk.vtkXMLPolyDataWriter()
elif ".vtm" in fr:
g = vtk.vtkMultiBlockDataGroupFilter()
for ob in objct:
g.AddInputData(ob)
g.Update()
mb = g.GetOutputDataObject(0)
wri = vtk.vtkXMLMultiBlockDataWriter()
wri.SetInputData(mb)
wri.SetFileName(fileoutput)
wri.Write()
return mb
elif ".xyz" in fr:
writer = vtk.vtkSimplePointsWriter()
elif ".facet" in fr:
writer = vtk.vtkFacetWriter()
elif ".tif" in fr:
writer = vtk.vtkTIFFWriter()
writer.SetFileDimensionality(len(obj.GetDimensions()))
elif ".vti" in fr:
writer = vtk.vtkXMLImageDataWriter()
elif ".mhd" in fr:
writer = vtk.vtkMetaImageWriter()
elif ".nii" in fr:
writer = vtk.vtkNIFTIImageWriter()
elif ".png" in fr:
writer = vtk.vtkPNGWriter()
elif ".jpg" in fr:
writer = vtk.vtkJPEGWriter()
elif ".bmp" in fr:
writer = vtk.vtkBMPWriter()
elif ".npy" in fr:
if utils.isSequence(objct):
objslist = objct
else:
objslist = [objct]
dicts2save = []
for obj in objslist:
dicts2save.append( _np_dump(obj) )
np.save(fileoutput, dicts2save)
return dicts2save
elif ".xml" in fr: # write tetrahedral dolfin xml
vertices = objct.coordinates().astype(str)
faces = np.array(objct.faces()).astype(str)
ncoords = vertices.shape[0]
outF = open(fileoutput, "w")
outF.write('<?xml version="1.0" encoding="UTF-8"?>\n')
outF.write('<dolfin xmlns:dolfin="http://www.fenicsproject.org">\n')
if len(faces[0]) == 4:# write tetrahedral mesh
ntets = faces.shape[0]
outF.write(' <mesh celltype="tetrahedron" dim="3">\n')
outF.write(' <vertices size="' + str(ncoords) + '">\n')
for i in range(ncoords):
x, y, z = vertices[i]
outF.write(' <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'" z="'+z+'"/>\n')
outF.write(' </vertices>\n')
outF.write(' <cells size="' + str(ntets) + '">\n')
for i in range(ntets):
v0, v1, v2, v3 = faces[i]
outF.write(' <tetrahedron index="'+str(i)
+ '" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'" v3="'+v3+'"/>\n')
elif len(faces[0]) == 3:# write triangle mesh
ntri = faces.shape[0]
outF.write(' <mesh celltype="triangle" dim="2">\n')
outF.write(' <vertices size="' + str(ncoords) + '">\n')
for i in range(ncoords):
x, y, dummy_z = vertices[i]
outF.write(' <vertex index="'+str(i)+'" x="'+x+'" y="'+y+'"/>\n')
outF.write(' </vertices>\n')
outF.write(' <cells size="' + str(ntri) + '">\n')
for i in range(ntri):
v0, v1, v2 = faces[i]
outF.write(' <triangle index="'+str(i)+'" v0="'+v0+'" v1="'+v1+'" v2="'+v2+'"/>\n')
outF.write(' </cells>\n')
outF.write(" </mesh>\n")
outF.write("</dolfin>\n")
outF.close()
return objct
else:
colors.printc("~noentry Unknown format", fileoutput, "file not saved.", c="r")
return objct
try:
if hasattr(writer, 'SetFileTypeToBinary'):
if binary:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
writer.SetInputData(obj)
writer.SetFileName(fileoutput)
writer.Write()
colors.printc("~save Saved file: " + fileoutput, c="g")
except Exception as e:
colors.printc("~noentry Error saving: " + fileoutput, "\n", e, c="r")
return objct
def exportWindow(fileoutput, binary=False, speed=None, html=True):
'''
Exporter which writes out the renderered scene into an OBJ, X3D or Numpy file.
X3D is an XML-based format for representation 3D scenes (similar to VRML).
Check out http://www.web3d.org/x3d for more details.
:param float speed: set speed for x3d files.
:param bool html: generate a test html page for x3d files.
|export_x3d| |export_x3d.py|_
`generated webpage <https://vtkplotter.embl.es/examples/embryo.html>`_
See also: FEniCS test `webpage <https://vtkplotter.embl.es/examples/fenics_elasticity.html>`_.
.. note:: the rendering window can also be exported to `numpy` file `scene.npy`
by pressing ``E`` keyboard at any moment during visualization.
'''
fr = fileoutput.lower()
if fr.endswith(".obj"):
w = vtk.vtkOBJExporter()
w.SetInputData(settings.plotter_instance.window)
w.Update()
colors.printc("~save Saved file:", fileoutput, c="g")
elif fr.endswith(".obj"):
writer = vtk.vtkOBJWriter()
writer.SetInputData(settings.plotter_instance.window)
writer.SetFileName(fileoutput)
writer.Write()
elif fr.endswith(".x3d"):
exporter = vtk.vtkX3DExporter()
exporter.SetBinary(binary)
exporter.FastestOff()
if speed:
exporter.SetSpeed(speed)
exporter.SetInput(settings.plotter_instance.window)
exporter.SetFileName(fileoutput)
exporter.Update()
exporter.Write()
if not html:
return
from vtkplotter.docs import x3d_html
x3d_html = x3d_html.replace("~fileoutput", fileoutput)
wsize = settings.plotter_instance.window.GetSize()
x3d_html = x3d_html.replace("~width", str(wsize[0]))
x3d_html = x3d_html.replace("~height", str(wsize[1]))
#b = settings.plotter_instance.renderer.ComputeVisiblePropBounds()
#s = max(b[1] - b[0], b[3] - b[2], b[5] - b[4])
#c = (b[1] + b[0])/2, (b[3] + b[2])/2, (b[5] + b[4])/2
#x3d_html = x3d_html.replace("~size", str(s*2))
#x3d_html = x3d_html.replace("~center", str(c[0])+" "+str(c[1])+" "+str(c[2]))
outF = open(fileoutput.replace('.x3d', '.html'), "w")
outF.write(x3d_html)
outF.close()
colors.printc("~save Saved files:", fileoutput,
fileoutput.replace('.x3d', '.html'), c="g")
elif fr.endswith(".npy"):
sdict = dict()
vp = settings.plotter_instance
sdict['shape'] = vp.shape #todo
sdict['sharecam'] = vp.sharecam #todo
sdict['camera'] = None #todo
sdict['position'] = vp.pos
sdict['size'] = vp.size
sdict['axes'] = vp.axes
sdict['title'] = vp.title
sdict['xtitle'] = vp.xtitle
sdict['ytitle'] = vp.ytitle
sdict['ztitle'] = vp.ztitle
sdict['backgrcol'] = colors.getColor(vp.backgrcol)
sdict['useDepthPeeling'] = settings.useDepthPeeling
sdict['renderPointsAsSpheres'] = settings.renderPointsAsSpheres
sdict['renderLinesAsTubes'] = settings.renderLinesAsTubes
sdict['hiddenLineRemoval'] = settings.hiddenLineRemoval
sdict['visibleGridEdges'] = settings.visibleGridEdges
sdict['interactorStyle'] = settings.interactorStyle
sdict['useParallelProjection'] = settings.useParallelProjection
sdict['objects'] = []
for a in vp.getMeshes() + vp.getVolumes():
sdict['objects'].append(_np_dump(a))
np.save(fileoutput, [sdict])
return
import vtk
if __name__ == "__main__":
# sphereSource = vtk.vtkSphereSource()
# sphereSource.SetPhiResolution(100)
# sphereSource.SetThetaResolution(100)
# sphereSource.Update()
# reader = vtk.vtkSTLReader()
# reader.SetFileName("./sampleData/maxilary.stl")
# reader.Update()
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName("./sampleData/sample1.vtp")
reader.Update()
reader.GetOutput()
data = reader.GetOutput()
objWriter = vtk.vtkOBJWriter()
objWriter.SetInputData(data)
objWriter.SetFileName("./sampleData/mandibular_nonmanifold.obj")
objWriter.Update()
def ProceduralSegmentation(self, inputDir, outputDir):
# Importing Dicom into temporary database
dicomDataDir = inputDir
from DICOMLib import DICOMUtils
loadedNodeIDs = []
with DICOMUtils.TemporaryDICOMDatabase() as db:
DICOMUtils.importDicom(dicomDataDir, db)
patientUIDs = db.patients()
for patientUID in patientUIDs:
loadedNodeIDs.extend(DICOMUtils.loadPatientByUID(patientUID))
# Loading Dicom into scene
seriesVolumeNode = slicer.util.getNode(loadedNodeIDs[0])
storageVolumeNode = seriesVolumeNode.CreateDefaultStorageNode()
slicer.mrmlScene.AddNode(storageVolumeNode)
storageVolumeNode.UnRegister(slicer.mrmlScene)
seriesVolumeNode.SetAndObserveStorageNodeID(storageVolumeNode.GetID())
# Access segmentation module
slicer.util.selectModule('Segment Editor')
segmentationNode = slicer.mrmlScene.AddNewNodeByClass(
"vtkMRMLSegmentationNode")
slicer.mrmlScene.AddNode(segmentationNode)
segmentationNode.CreateDefaultDisplayNodes() # only needed for display
segmentationNode.SetReferenceImageGeometryParameterFromVolumeNode(
seriesVolumeNode)
# TODO Automate creation of different segments in the future (using some form of -type argument)
# Create spine segment
segmentTypeID = "Spine"
newSegment = slicer.vtkSegment()
newSegment.SetName(segmentTypeID)
newSegment.SetColor([0.89, 0.85, 0.78])
segmentationNode.GetSegmentation().AddSegment(newSegment,
segmentTypeID)
# Create segment editor widget to get access to effects
segmentEditorWidget = slicer.qMRMLSegmentEditorWidget()
segmentEditorWidget.setMRMLScene(slicer.mrmlScene)
# Access segment editor node
segmentEditorNode = slicer.mrmlScene.AddNewNodeByClass(
"vtkMRMLSegmentEditorNode")
slicer.mrmlScene.AddNode(segmentEditorNode)
segmentEditorWidget.setMRMLSegmentEditorNode(segmentEditorNode)
segmentEditorWidget.setSegmentationNode(segmentationNode)
segmentEditorWidget.setMasterVolumeNode(seriesVolumeNode)
# Segment Editor Effect: Thresholding
segmentEditorWidget.setActiveEffectByName("Threshold")
effect = segmentEditorWidget.activeEffect()
effect.setParameter("MinimumThreshold", "90")
effect.setParameter("MaximumThreshold", "1600")
effect.self().onApply()
# Setting Closed Surface Representation Values
segmentationNode.GetSegmentation().SetConversionParameter(
"Oversampling factor", "1.0")
segmentationNode.GetSegmentation().SetConversionParameter(
"Joint smoothing", "0.50")
segmentationNode.GetSegmentation().SetConversionParameter(
"Smoothing factor", "0.50")
# Segment Editor Effect: Smoothing
segmentEditorWidget.setActiveEffectByName("Smoothing")
effect = segmentEditorWidget.activeEffect()
# 2mm MEDIAN Smoothing
effect.setParameter("SmoothingMethod", "MEDIAN")
effect.setParameter("KernelSizeMm", 2.5)
effect.self().onApply()
# 2mm OPEN Smoothing
#effect.setParameter("SmoothingMethod", "MORPHOLOGICAL_OPENING")
#effect.setParameter("KernelSizeMm", 2)
#effect.self().onApply
# 1.5mm CLOSED Smoothing
#effect.setParameter("SmoothingMethod", "MORPHOLOGICAL_CLOSING")
#effect.setParameter("KernelSizeMm", 1.5)
#effect.self().onApply
# Create Closed Surface Representation
segmentationNode.CreateClosedSurfaceRepresentation()
# Export Segmentation to Model Node
shNode = slicer.mrmlScene.GetSubjectHierarchyNode()
exportFolderItemId = shNode.CreateFolderItem(shNode.GetSceneItemID(),
"Segments")
slicer.modules.segmentations.logic().ExportAllSegmentsToModels(
segmentationNode, exportFolderItemId)
segmentID = segmentationNode.GetSegmentation().GetNthSegmentID(0)
surfaceMesh = segmentationNode.GetClosedSurfaceInternalRepresentation(
segmentID)
# Decimate Model
decimator = vtk.vtkDecimatePro()
decimator.SplittingOff()
decimator.PreserveTopologyOn()
decimator.SetTargetReduction(0.95)
decimator.SetInputData(surfaceMesh)
decimator.Update()
surfaceMesh = decimator.GetOutput()
# Smooth the Model
smoothingFactor = 0.5
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputData(surfaceMesh)
smoother.SetNumberOfIterations(50)
smoother.SetPassBand(pow(10.0, -4.0 * smoothingFactor))
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
surfaceMesh = smoother.GetOutput()
# Clean up Model
cleaner = vtk.vtkCleanPolyData()
#cleaner.PointMergingOff()
#cleaner.ConvertLinesToPointsOn()
#cleaner.ConvertPolysToLinesOn()
#cleaner.ConvertStripsToPolysOn()
cleaner.SetInputData(surfaceMesh)
cleaner.Update()
surfaceMesh = cleaner.GetOutput()
# Write to OBJ File
outputFileName = outputDir + "segmentation.obj"
writer = vtk.vtkOBJWriter()
writer.SetFileName(outputFileName)
writer.SetInputData(surfaceMesh)
writer.Update()
# Clean up
segmentEditorWidget = None
slicer.mrmlScene.RemoveNode(segmentEditorNode)
def save_mesh_as_obj(polydata, fname):
writer = vtk.vtkOBJWriter()
writer.SetInputData(polydata)
writer.SetFileName(str(fname))
writer.Write()
