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 marching_cubes(grid_fname_vtk, mesh_filename_ply, value=0.5):
""" read in a grid in vtk format, run marching cubes, save the result as ply
mesh
Parameters
----------
grid_fname_vtk : str
The file name of the grid in vtk format
mesh_filename_ply : str
The file name to save the ply mesh results
value : float, optional
The value
"""
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(grid_fname_vtk)
reader.Update()
points = reader.GetOutput()
mcubes = vtk.vtkMarchingCubes()
mcubes.SetInput(points)
mcubes.SetValue(0, value)
mcubes.Update()
mesh = mcubes.GetOutput()
writer = vtk.vtkPLYWriter()
writer.SetInput(mesh)
writer.SetFileName(mesh_filename_ply)
writer.Update()
writer.Write()
def create_ply(savepath, vtkPoly):
# write results to output file
writer = vtkPLYWriter()
writer.SetInputData(vtkPoly)
writer.SetFileName(savepath)
writer.Write()
def make_mesh_watertight(self, hole_size=None, filename=None, write=True):
"""This method reads a ply mesh from an external file and converts it into a watertight mesh
"""
self.to_ply(filename="temp.ply")
logger.info(f"Making the mesh read from {filename} watertight")
reader = vtk.vtkPLYReader()
if filename is None:
filename = Path.cwd() / "output/temp.ply"
reader.SetFileName(str(filename))
reader.Update()
polydata = reader.GetOutput()
fill = vtk.vtkFillHolesFilter()
fill.SetInputData(polydata)
hole_size = hole_size if hole_size else config.stl_from_point_cloud.watertight_mesh.hole_size if config.stl_from_point_cloud.watertight_mesh.hole_size else 1.0
fill.SetHoleSize(hole_size)
fill.Update()
self.vtk_filled = fill.GetOutput()
if write:
writer = vtk.vtkPLYWriter()
writer.SetInputData(self.vtk_filled)
writer.SetFileName(f"temp-watertight.ply")
writer.Write()
self.stl_mesh = o3d.io.read_triangle_mesh("temp-watertight.ply")
print(self.stl_mesh)
# Path.unlink(Path("temp-watertight.ply"))
# Path.unlink(filename)
return fill.GetOutput()
def main():
colors = vtk.vtkNamedColors()
filename = get_program_parameters()
sphereSource = vtk.vtkSphereSource()
sphereSource.Update()
plyWriter = vtk.vtkPLYWriter()
plyWriter.SetFileName(filename)
plyWriter.SetInputConnection(sphereSource.GetOutputPort())
plyWriter.Write()
# Read and display for verification
reader = vtk.vtkPLYReader()
reader.SetFileName(filename)
reader.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d('cobalt_green'))
renderWindow.Render()
renderWindowInteractor.Start()
def write(self, file_name):
writer = vtk.vtkPLYWriter()
writer.SetFileName(file_name)
writer.SetInputData(self.vtk_poly_data)
if self.is_color_mode_height:
# set lookup tbale for depth values to colors
lut = vtk.vtkLookupTable()
lut.SetTableRange(self.height_min, self.height_max)
lut.Build()
# in order to be convertable to pcd, use lut to generate colors.
# THIS IS A DIRTY HACK BUT NEEDED SINCE PCL IS STUPID
# writer.SetLookupTable(lut) only works for meshlab
cur_color_data = vtk.vtkUnsignedCharArray()
cur_color_data.SetNumberOfComponents(3)
for id in self.color_ids:
val = self.color_data.GetValue(id)
col = [0., 0., 0.]
lut.GetColor(val, col)
col = [int(c * 255) for c in col]
cur_color_data.InsertNextTuple3(col[0], col[1], col[2])
self.color_data = cur_color_data
self.color_data.SetName("Colors")
self.vtk_poly_data.GetPointData().SetActiveScalars('Colors')
self.vtk_poly_data.GetPointData().SetScalars(self.color_data)
writer.SetArrayName("Colors")
writer.Write()
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_polys(output_dir, variables, key, output_filename, index_list):
poly_name = key[0]
poly_faces = key[1]
verts = deepnet.utils.unwrapped(variables[poly_name])
faces = deepnet.utils.unwrapped(variables[poly_faces])
for i in range(verts.shape[0]):
case_name = variables['case_name'][i]
variables['__index__'] = index_list[case_name]
index_list[case_name] += 1
# make output dir
current_output_dir = os.path.join(output_dir, case_name)
os.makedirs(current_output_dir, exist_ok=True)
# save polys
current_output_filename = os.path.join(
current_output_dir, output_filename.format(**variables))
surface = convert_poly_numpy_to_vtk(verts[i], faces[i])
writer = vtk.vtkPLYWriter()
writer.SetInputData(surface)
writer.SetFileName(output_filename.format(
**variables))
writer.Update()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkPLYWriter(), 'Writing vtkPLY.',
('vtkPLY',), (),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
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 write(self, file_name):
writer = vtk.vtkPLYWriter()
writer.SetFileName(file_name)
writer.SetInputData(self.vtk_poly_data)
if self.is_color_mode_height:
# set lookup tbale for depth values to colors
lut = vtk.vtkLookupTable()
lut.SetTableRange(self.height_min, self.height_max)
lut.Build()
# in order to be convertable to pcd, use lut to generate colors.
# THIS IS A DIRTY HACK BUT NEEDED SINCE PCL IS STUPID
# writer.SetLookupTable(lut) only works for meshlab
cur_color_data = vtk.vtkUnsignedCharArray()
cur_color_data.SetNumberOfComponents(3)
for id in self.color_ids:
val = self.color_data.GetValue(id)
col = [0., 0., 0.]
lut.GetColor(val, col)
col = [int(c * 255) for c in col]
cur_color_data.InsertNextTuple3(col[0], col[1], col[2])
self.color_data = cur_color_data
self.color_data.SetName("Colors")
self.vtk_poly_data.GetPointData().SetActiveScalars('Colors')
self.vtk_poly_data.GetPointData().SetScalars(self.color_data)
writer.SetArrayName("Colors")
writer.Write()
def writeply(surface,filename):
"""Write mesh as ply file."""
writer = vtk.vtkPLYWriter()
writer.SetInputData(surface)
writer.SetFileTypeToASCII()
writer.SetFileName(filename)
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 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 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 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 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 writePLYfile(vtkPoly, savepath = None):
# write results to output file
writer = vtkPLYWriter()
writer.SetInputData(vtkPoly)
writer.SetFileName(savepath)
writer.Write()
return 1
def WritePLYSurfaceFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing PLY surface file.')
writer = vtk.vtkPLYWriter()
writer.SetInput(self.Surface)
writer.SetFileName(self.OutputFileName)
writer.Write()
def write_vtk_poly_data_to_ply_file(filename, vtk_poly_data):
ply_writer = vtk.vtkPLYWriter()
ply_writer.SetFileTypeToASCII()
ply_writer.SetFileName(filename)
ply_writer.SetInputData(vtk_poly_data)
ply_writer.SetArrayName("Colors")
ply_writer.Write()
def WritePLYSurfaceFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing PLY surface file.')
writer = vtk.vtkPLYWriter()
writer.SetInput(self.Surface)
writer.SetFileName(self.OutputFileName)
writer.Write()
def createMeshFromPolyDataTetGen(self,
inputPolyData,
outputMeshNode,
additionalParameters=""):
self.abortRequested = False
tempDir = self.createTempDirectory()
self.addLog('Mesh generation is started in working directory: ' +
tempDir)
# Write inputs
qt.QDir().mkpath(tempDir)
inputSurfaceMeshFilePath = os.path.join(tempDir, "mesh.ply")
inputWriter = vtk.vtkPLYWriter()
inputWriter.SetInputData(inputPolyData)
inputWriter.SetFileName(inputSurfaceMeshFilePath)
inputWriter.SetFileTypeToASCII()
inputWriter.Write()
inputParamsTetGen = []
inputParamsTetGen.append("-k" + additionalParameters)
inputParamsTetGen.append(inputSurfaceMeshFilePath)
# Run tetgen
ep = self.startMesher(inputParamsTetGen, self.getTetGenPath())
self.logProcessOutput(ep, self.tetGenFilename)
# Read results
if not self.abortRequested:
outputVolumetricMeshPath = os.path.join(tempDir, "mesh.1.vtk")
outputReader = vtk.vtkUnstructuredGridReader()
outputReader.SetFileName(outputVolumetricMeshPath)
outputReader.ReadAllScalarsOn()
outputReader.ReadAllVectorsOn()
outputReader.ReadAllNormalsOn()
outputReader.ReadAllTensorsOn()
outputReader.ReadAllColorScalarsOn()
outputReader.ReadAllTCoordsOn()
outputReader.ReadAllFieldsOn()
outputReader.Update()
outputMeshNode.SetUnstructuredGridConnection(
outputReader.GetOutputPort())
outputMeshDisplayNode = outputMeshNode.GetDisplayNode()
if not outputMeshDisplayNode:
# Initial setup of display node
outputMeshNode.CreateDefaultDisplayNodes()
outputMeshDisplayNode = outputMeshNode.GetDisplayNode()
outputMeshDisplayNode.SetEdgeVisibility(True)
outputMeshDisplayNode.SetClipping(True)
# Clean up
if self.deleteTemporaryFiles:
import shutil
shutil.rmtree(tempDir)
self.addLog("Model generation is completed")
def smooth(path,
iterations=100,
relaxation=0.1,
edgesmoothing=True,
savepath=None):
""" Edit a mesh file (ply format) applying iterative Laplacian smoothing """
# source https://vtk.org/Wiki/VTK/Examples/Cxx/PolyData/SmoothPolyDataFilter
# read Ply file
reader = vtkPLYReader()
reader.SetFileName(path)
reader.Update()
# create Poly data
inputPoly = vtkPolyData()
inputPoly.ShallowCopy(reader.GetOutput())
# Smooth mesh with Laplacian Smoothing
smooth = vtkSmoothPolyDataFilter()
smooth.SetInputData(inputPoly)
smooth.SetRelaxationFactor(relaxation)
smooth.SetNumberOfIterations(iterations)
if edgesmoothing:
smooth.FeatureEdgeSmoothingOn()
else:
smooth.FeatureEdgeSmoothingOff()
smooth.BoundarySmoothingOn()
smooth.Update()
smoothPoly = vtkPolyData()
smoothPoly.ShallowCopy(smooth.GetOutput())
# Find mesh normals (Not sure why)
normal = vtkPolyDataNormals()
normal.SetInputData(smoothPoly)
normal.ComputePointNormalsOn()
normal.ComputeCellNormalsOn()
normal.Update()
normalPoly = vtkPolyData()
normalPoly.ShallowCopy(normal.GetOutput())
# write results on output file
if savepath is None:
outfile_path = os.path.splitext(path)[0]
outfile_path = f"{outfile_path}_smooth_{iterations}.ply"
else:
outfile_path = os.path.splitext(path)[0]
outfile_path = f"{os.path.basename(outfile_path)}_smooth_{iterations}.ply"
outfile_path = os.path.join(savepath, outfile_path)
writer = vtkPLYWriter()
writer.SetInputData(normalPoly)
writer.SetFileName(outfile_path)
writer.Write()
print(f" -> Saving file at: {outfile_path}")
return outfile_path
def save(self, filename, binary=True):
"""Write a surface mesh to disk.
Written file may be an ASCII or binary ply, stl, or vtk mesh
file. If ply or stl format is chosen, the face normals are
computed in place to ensure the mesh is properly saved.
Parameters
----------
filename : str
Filename of mesh to be written. File type is inferred from
the extension of the filename unless overridden with
ftype. Can be one of the following types (.ply, .stl,
.vtk)
binary : bool, optional
Writes the file as binary when True and ASCII when False.
Notes
-----
Binary files write much faster than ASCII and have a smaller
file size.
"""
filename = os.path.abspath(os.path.expanduser(filename))
file_mode = True
# Check filetype
ftype = filename[-3:]
if ftype == 'ply':
writer = vtk.vtkPLYWriter()
elif ftype == 'vtp':
writer = vtk.vtkXMLPolyDataWriter()
file_mode = False
if binary:
writer.SetDataModeToBinary()
else:
writer.SetDataModeToAscii()
elif ftype == 'stl':
writer = vtk.vtkSTLWriter()
elif ftype == 'vtk':
writer = vtk.vtkPolyDataWriter()
else:
raise Exception('Filetype must be either "ply", "stl", or "vtk"')
# Recompute normals prior to save. Corrects a bug were some
# triangular meshes are not saved correctly
if ftype in ['stl', 'ply']:
self.compute_normals(inplace=True)
writer.SetFileName(filename)
writer.SetInputData(self)
if binary and file_mode:
writer.SetFileTypeToBinary()
elif file_mode:
writer.SetFileTypeToASCII()
writer.Write()
def from_polydata(polydata, output_filename):
writerPLY = vtkPLYWriter()
if not output_filename.endswith(".ply"):
output_filename += ".ply"
writerPLY.SetFileName(output_filename)
writerPLY.SetInput(polydata)
writerPLY.SetFileTypeToASCII()
writerPLY.Write()
def save_polydata(polydata, filename):
if filename.lower().endswith(".stl"):
writer = vtk.vtkSTLWriter()
elif filename.lower().endswith(".ply"):
writer = vtk.vtkPLYWriter()
else:
print("File must be STL or PLY")
sys.exit(0)
writer.SetInputData(polydata)
writer.SetFileName(filename)
writer.Write()
def writePLY(model, file):
file = file.with_suffix('.ply')
print(f'Writing File : {file}')
writer = vtk.vtkPLYWriter()
writer.SetEnableAlpha(True)
writer.SetInputData(model)
writer.SetArrayName('color')
writer.SetFileName(str(file))
writer.SetFileTypeToBinary()
writer.Write()
def salva_vertixOsso(self, path):
assembly = self.assemblagem(self.ListaOssos)
polidata = vtk.vtkPolyData()
polidata.SetPoints(assembly.GetOutput().GetPoints())
write = vtk.vtkPLYWriter()
write.SetInputData(polidata)
write.SetFileTypeToBinary()
write.SetFileName(path)
write.Write()
write.Update()
def main():
filename_input, filename_output = get_program_parameters()
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(filename_input)
reader.Update()
writer = vtk.vtkPLYWriter()
writer.SetFileName(filename_output)
writer.SetInputConnection(reader.GetOutputPort())
writer.Update()
def write_ply(pd, filename):
f = vtk.vtkTriangleFilter()
f.SetInputData(pd)
f.Update()
w = vtk.vtkPLYWriter()
w.SetFileName(filename)
w.SetInputData(f.GetOutput())
w.SetArrayName("colors")
w.SetFileTypeToASCII()
w.Update()
def saveMeshAsPly(mesh, name): channel = open(name, 'wb') channel.close() w = vtk.vtkPLYWriter() w.SetInputConnection(mesh.GetOutputPort()) w.SetFileName(name) w.SetFileTypeToBinary() w.SetDataByteOrderToLittleEndian() w.SetColorModeToUniformCellColor() w.SetColor(255, 255, 255) w.Write() print name + 'saved ...'
def niftiMask2Surface(img_path, surf_name, smooth_iter=10, filetype="vtk"):
# import the binary nifti image
reader = vtk.vtkNIFTIImageReader()
reader.SetFileName(img_path)
reader.Update()
# do marching cubes to create a surface
surface = vtk.vtkDiscreteMarchingCubes()
surface.SetInputConnection(reader.GetOutputPort())
# GenerateValues(number of surfaces, label range start, label range end)
surface.GenerateValues(1, 1, 1)
surface.Update()
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(surface.GetOutputPort())
smoother.SetNumberOfIterations(smooth_iter)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
connectivityFilter = vtk.vtkPolyDataConnectivityFilter()
connectivityFilter.SetInputConnection(smoother.GetOutputPort())
connectivityFilter.SetExtractionModeToLargestRegion()
connectivityFilter.Update()
cleaned = vtk.vtkCleanPolyData()
cleaned.SetInputConnection(connectivityFilter.GetOutputPort())
cleaned.Update()
# doesn't work, but may need in future
# close_holes = vtk.vtkFillHolesFilter()
# close_holes.SetInputConnection(smoother.GetOutputPort())
# close_holes.SetHoleSize(10)
# close_holes.Update()
if filetype == "stl":
writer = vtk.vtkSTLWriter()
writer.SetInputConnection(cleaned.GetOutputPort())
writer.SetFileTypeToASCII()
writer.SetFileName(surf_name)
writer.Write()
if filetype == "ply":
writer = vtk.vtkPLYWriter()
writer.SetInputConnection(cleaned.GetOutputPort())
writer.SetFileTypeToASCII()
writer.SetFileName(surf_name)
writer.Write()
if filetype == "vtk":
writer = vtk.vtkPolyDataWriter()
#writer = vtk.vtkDataSetWriter()
writer.SetInputConnection(cleaned.GetOutputPort())
writer.SetFileName(surf_name)
writer.Write()
def WritePLYSurfaceFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing PLY surface file.')
writer = vtk.vtkPLYWriter()
writer.SetInputData(self.Surface)
writer.SetFileName(self.OutputFileName)
if self.Mode == "binary":
writer.SetFileTypeToBinary()
elif self.Mode == "ascii":
writer.SetFileTypeToASCII()
writer.Write()
def WritePLYSurfaceFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing PLY surface file.')
writer = vtk.vtkPLYWriter()
writer.SetInputData(self.Surface)
writer.SetFileName(self.OutputFileName)
if self.Mode == "binary":
writer.SetFileTypeToBinary()
elif self.Mode == "ascii":
writer.SetFileTypeToASCII()
writer.Write()
def save_mesh_ply(polydata, fn, color=(255, 255, 255)):
# Export to rgb PLY file (STL file can not have color info)
# https://github.com/Kitware/VTK/blob/master/IO/PLY/Testing/Python/TestPLYReadWrite.py#L31
# http://www.vtk.org/doc/nightly/html/classvtkPLYWriter.html#aa7f0bdbb2decdc7a7360a890a6c10e8b
writer = vtk.vtkPLYWriter()
writer.SetFileName(fn)
writer.SetInputData(polydata)
writer.SetColorModeToUniformColor()
writer.SetColor(color[0], color[1], color[2])
writer.SetFileTypeToASCII()
writer.Write()
def ply_exporter(mesh, file_path, binary=False, **kwargs):
r"""
Given a file path to write in to write out the mesh data.
No value is returned. Only file paths are supported and if a file handle
is passed it will be ignored and a warning will be raised.
Note that this does not save out textures of textured images, and so should
not be used in isolation.
Parameters
----------
file_path : `str`
The full path where the obj will be saved out.
mesh : :map:`TriMesh`
Any subclass of :map:`TriMesh`. If :map:`TexturedTriMesh` texture
coordinates will be saved out. Note that :map:`ColouredTriMesh`
will only have shape data saved out, as .PLY doesn't robustly support
per-vertex colour information.
binary: `bool`, optional
Specify whether to format output in binary or ascii, defaults to False
"""
import vtk
from vtk.util.numpy_support import numpy_to_vtk, numpy_to_vtkIdTypeArray
file_path = _enforce_only_paths_supported(file_path, 'PLY')
polydata = vtk.vtkPolyData()
points = vtk.vtkPoints()
points.SetData(numpy_to_vtk(mesh.points))
polydata.SetPoints(points)
cells = vtk.vtkCellArray()
counts = np.empty((mesh.trilist.shape[0], 1), dtype=np.int)
counts.fill(3)
tris = np.concatenate((counts, mesh.trilist), axis=1)
cells.SetCells(mesh.trilist.shape[0], numpy_to_vtkIdTypeArray(tris))
polydata.SetPolys(cells)
if isinstance(mesh, TexturedTriMesh):
pointdata = polydata.GetPointData()
pointdata.SetTCoords(numpy_to_vtk(mesh.tcoords.points))
ply_writer = vtk.vtkPLYWriter()
ply_writer.SetFileName(str(file_path))
ply_writer.SetInputData(polydata)
if not binary:
ply_writer.SetFileTypeToASCII()
else:
ply_writer.SetFileTypeToBinary()
ply_writer.Update()
ply_writer.Write()
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 writePLY(mesh, name):
try:
writer = vtk.vtkPLYWriter()
if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
writer.SetInputData( mesh )
else:
writer.SetInput( mesh )
writer.SetFileTypeToBinary()
writer.SetFileName( name )
writer.Write()
print "Output mesh:", name
writer = None
except:
print "PLY 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 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 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=='ply':
write = vtk.vtkPLYWriter()
elif outformat=='vtp':
write = vtk.vtkXMLPolyDataWriter()
elif outformat=='tag':
write = vtk.vtkMNITagPointWriter()
else:
raise ValueError('cannot write output 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
# Check if the input directory exists
if not os.path.isdir(input_folder_name):
print("Error: input directory '" + input_folder_name + "' does not exist")
exit()
# Check if the output directory exists
if not os.path.isdir(output_folder_name):
print("Error: output directory '" + output_folder_name + "' does not exist")
exit()
print("\nthe .ply meshes will be saved in " + output_folder_name)
# The IO objects
obj_reader = OBJReader()
ply_writer = vtk.vtkPLYWriter()
ply_writer.SetFileTypeToBinary()
# First of all, we collect the names of the OBJ files
obj_file_names = list()
# Get the file names of the OBJ meshes in the provided folder
for file_name in os.listdir(input_folder_name):
full_file_name = os.path.join(input_folder_name, file_name)
# We want files only
if not os.path.isfile(full_file_name):
continue
# Get the file extension (in lower case)
file_ext = os.path.splitext(file_name)[1].lower()
# We want OBJ files only
if file_ext != ".obj":
filename = "plyWriter.ply"
channel = open(filename, "wb")
channel.close()
ss = vtk.vtkSphereSource()
ss.SetPhiResolution(10)
ss.SetThetaResolution(20)
ele = vtk.vtkSimpleElevationFilter()
ele.SetInputConnection(ss.GetOutputPort())
pd2cd = vtk.vtkPointDataToCellData()
pd2cd.SetInputConnection(ele.GetOutputPort())
# First way or writing
w = vtk.vtkPLYWriter()
w.SetInputConnection(pd2cd.GetOutputPort())
w.SetFileName(filename)
w.SetFileTypeToBinary()
w.SetDataByteOrderToLittleEndian()
w.SetColorModeToUniformCellColor()
w.SetColor(255, 0, 0)
w.Write()
r = vtk.vtkPLYReader()
r.SetFileName(filename)
r.Update()
# cleanup
#
try:
import vtk filename = "writeply.ply" sphereSource = vtk.vtkSphereSource() sphereSource.Update() plyWriter = vtk.vtkPLYWriter() plyWriter.SetFileName(filename) plyWriter.SetInputConnection(sphereSource.GetOutputPort()) plyWriter.Write() #Read and display for verication reader = vtk.vtkPLYReader() reader.SetFileName(filename) reader.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(reader.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(actor) renderer.SetBackground(.3, .6, .3) #Background color green
def write_poly(polygons, filename):
plyWriter = vtkPLYWriter()
plyWriter.SetFileName(filename)
plyWriter.SetInputConnection(polygons.GetOutputPort())
plyWriter.Write()
def run(self):
logging.info('')
# self.iren.Start()
if self._output['movie_preflight']:
create_survey_movie(self,
survey_mesh=False,
nsteps=self._output['preflight_nsteps'],
fps=self._output['preflight_fps'])
if self._output['movie']:
pp = mabdi.PostProcess(
movie={'scenario': True,
'depth_images': True,
'plots': True,
'param_fps': self._output['movie_fps']},
scenario_render_window=self.renWin,
filter_classifier=self.classifier,
length_of_path=len(self.position),
global_mesh=self.mesh,
file_prefix=self._file_prefix,
savefig_at_frame=self._output['movie_savefig_at_frame'])
# if a dynamic environment, set the initial state
deintst = self._sim_param['dynamic_environment_init_state']
if deintst:
for i, obj_state in enumerate(deintst):
self.source.set_object_state(object_id=i, state=obj_state)
self.source.Update()
# dynamic environment controls
de = self._sim_param['dynamic_environment'] # dynamic environment
defn, deobjn = zip(*de) # frame number, objnumber
for i, (pos, lka) in enumerate(zip(self.position, self.lookat)):
logging.debug('START MAIN LOOP')
start = timer()
self.di.set_sensor_orientation(pos, lka)
self.sdi.set_sensor_orientation(pos, lka)
if i in defn:
ind = defn.index(i)
self.source.set_object_state(object_id=deobjn[ind], state=True)
self.source.Update()
logging.debug('di.Modified()')
self.di.Modified()
logging.debug('sdi.Modified()')
self.sdi.Modified()
logging.debug('classifier.Update()')
self.classifier.Update()
logging.debug('mesh.Update()')
self.mesh.Update()
logging.debug('iren.Render()')
self.iren.Render()
if self._output['movie']:
pp.collect_info()
if self._sim_param['interactive']:
self.iren.Start()
end = timer()
logging.debug('END MAIN LOOP time {:.4f} seconds'.format(end - start))
if self._output['movie']:
pp.save_movie()
if self._output['movie_postflight']:
create_survey_movie(self,
survey_mesh=True,
nsteps=self._output['postflight_nsteps'],
fps=self._output['postflight_fps'])
# mabdi.MovieNamesList.write_movie_list(self._file_prefix) # has a bug
if self._output['save_global_mesh']:
plywriter = vtk.vtkPLYWriter()
plywriter.SetFileName(self._file_prefix + 'global_mesh.ply')
plywriter.SetInputConnection(self.mesh.GetOutputPort())
plywriter.Write()
pp.save_plots()
""" Exit gracefully """
self.di.kill_render_window()
self.sdi.kill_render_window()
self.iren.GetRenderWindow().Finalize()
self.iren.TerminateApp()
del self.renWin, self.iren
def addColors(infilename, outfilename, colorfilename=None, colorstring=None,
binary=True, verbose=False):
"""add color array"""
outformat = path.splitext(outfilename)[1].strip('.')
if outformat!='ply':
raise ValueError('colors are only supported for PLY format')
informat = path.splitext(infilename)[1].strip('.')
# set reader based on filename extension
if informat=='stl':
reader = vtk.vtkSTLReader()
elif informat=='vtk':
reader = vtk.vtkPolyDataReader()
elif informat=='obj':
reader = vtk.vtkMNIObjectReader()
elif informat=='ply':
reader = vtk.vtkPLYReader()
elif informat=='vtp':
reader = vtk.vtkXMLPolyDataReader()
else:
raise ValueError('cannot read input format: ' + informat)
reader.SetFileName(infilename)
reader.Update()
#N = reader.GetOutput().GetNumberOfPolys()
N = reader.GetOutput().GetNumberOfPoints()
if verbose:
print("read %i points (vertices)" % (N,))
if colorfilename:
colorar = readColorFile(colorfilename)
if N != colorar.shape[0]:
raise ValueError('number of rows in color file does not match' +
'number of points in mesh file')
elif colorstring:
color = [int(i) for i in colorstring.split()]
colorar = np.ones((N,3)) * np.array(color)
Colors = vtk.vtkUnsignedCharArray()
Colors.SetNumberOfComponents(3)
Colors.SetName("Colors")
for i in range(0,N):
Colors.InsertNextTuple3(*colorar[i,:])
polydata = vtk.vtkPolyData()
polydata = reader.GetOutput()
polydata.GetPointData().SetScalars(Colors)
polydata.Modified()
writer = vtk.vtkPLYWriter()
writer.SetArrayName("Colors")
writer.SetInputData(polydata)
writer.SetFileName(outfilename)
if binary:
if verbose: print('setting output to binary')
writer.SetFileTypeToBinary()
else:
if verbose: print('setting output to ascii')
writer.SetFileTypeToASCII()
err = writer.Write()
import sys import vtk import ca_smoothing stl = vtk.vtkSTLReader() stl.SetFileName(sys.argv[1]) stl.Update() normals = vtk.vtkPolyDataNormals() normals.SetInput(stl.GetOutput()) normals.ComputeCellNormalsOn() normals.Update() clean = vtk.vtkCleanPolyData() clean.SetInput(normals.GetOutput()) clean.Update() pd = clean.GetOutput() pd.BuildLinks() tpd = ca_smoothing.ca_smoothing(pd, 0.7, 3, 0.2, 10) ply = vtk.vtkPLYWriter() ply.SetFileName(sys.argv[2]) ply.SetInput(tpd) ply.Write()
# Very important! The following values are for the virtual fish project
voxel_size = [0.798, 0.798, 2.0]
print("\nIMPORTANT: using the following voxel size: " + str(voxel_size[0]) + ", " + str(voxel_size[1]) + ", " + str(voxel_size[2]))
print("the meshes will be saved in " + output_folder_name)
# The VTK stuff
img_reader = vtk.vtkTIFFReader()
# Gaussian image filter
img_smoother = vtk.vtkImageGaussianSmooth()
img_smoother.SetDimensionality(3)
img_smoother.SetRadiusFactor(3)
# Marching cubes
marching_cubes = vtk.vtkImageMarchingCubes()
marching_cubes.SetValue(0, 128)
# Mesh writer
mesh_writer = vtk.vtkPLYWriter()
# First of all, we collect the names of the tiff files
tiff_file_names = list()
# Get the file names of the tif images in the provided folder
for file_name in os.listdir(input_folder_name):
full_file_name = os.path.join(input_folder_name, file_name)
# We want files only
if not os.path.isfile(full_file_name):
continue
# Get the file extension (in lower case)
file_ext = os.path.splitext(file_name)[1].lower()
def AddNewActor(self, pubsub_evt):
"""
Create surface actor, save into project and send it to viewer.
"""
slice_, mask, surface_parameters = pubsub_evt.data
matrix = slice_.matrix
filename_img = slice_.matrix_filename
spacing = slice_.spacing
algorithm = surface_parameters['method']['algorithm']
options = surface_parameters['method']['options']
surface_name = surface_parameters['options']['name']
quality = surface_parameters['options']['quality']
fill_holes = surface_parameters['options']['fill']
keep_largest = surface_parameters['options']['keep_largest']
mode = 'CONTOUR' # 'GRAYSCALE'
min_value, max_value = mask.threshold_range
colour = mask.colour
try:
overwrite = surface_parameters['options']['overwrite']
except KeyError:
overwrite = False
mask.matrix.flush()
if quality in const.SURFACE_QUALITY.keys():
imagedata_resolution = const.SURFACE_QUALITY[quality][0]
smooth_iterations = const.SURFACE_QUALITY[quality][1]
smooth_relaxation_factor = const.SURFACE_QUALITY[quality][2]
decimate_reduction = const.SURFACE_QUALITY[quality][3]
#if imagedata_resolution:
#imagedata = iu.ResampleImage3D(imagedata, imagedata_resolution)
pipeline_size = 4
if decimate_reduction:
pipeline_size += 1
if (smooth_iterations and smooth_relaxation_factor):
pipeline_size += 1
if fill_holes:
pipeline_size += 1
if keep_largest:
pipeline_size += 1
## Update progress value in GUI
UpdateProgress = vu.ShowProgress(pipeline_size)
UpdateProgress(0, _("Creating 3D surface..."))
language = ses.Session().language
if (prj.Project().original_orientation == const.CORONAL):
flip_image = False
else:
flip_image = True
n_processors = multiprocessing.cpu_count()
pipe_in, pipe_out = multiprocessing.Pipe()
o_piece = 1
piece_size = 2000
n_pieces = int(round(matrix.shape[0] / piece_size + 0.5, 0))
q_in = multiprocessing.Queue()
q_out = multiprocessing.Queue()
p = []
for i in xrange(n_processors):
sp = surface_process.SurfaceProcess(pipe_in, filename_img,
matrix.shape, matrix.dtype,
mask.temp_file,
mask.matrix.shape,
mask.matrix.dtype,
spacing,
mode, min_value, max_value,
decimate_reduction,
smooth_relaxation_factor,
smooth_iterations, language,
flip_image, q_in, q_out,
algorithm != 'Default',
algorithm,
imagedata_resolution)
p.append(sp)
sp.start()
for i in xrange(n_pieces):
init = i * piece_size
end = init + piece_size + o_piece
roi = slice(init, end)
q_in.put(roi)
print "new_piece", roi
for i in p:
q_in.put(None)
none_count = 1
while 1:
msg = pipe_out.recv()
if(msg is None):
none_count += 1
else:
UpdateProgress(msg[0]/(n_pieces * pipeline_size), msg[1])
if none_count > n_pieces:
break
polydata_append = vtk.vtkAppendPolyData()
# polydata_append.ReleaseDataFlagOn()
t = n_pieces
while t:
filename_polydata = q_out.get()
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(filename_polydata)
# reader.ReleaseDataFlagOn()
reader.Update()
# reader.GetOutput().ReleaseDataFlagOn()
polydata = reader.GetOutput()
# polydata.SetSource(None)
polydata_append.AddInputData(polydata)
del reader
del polydata
t -= 1
polydata_append.Update()
# polydata_append.GetOutput().ReleaseDataFlagOn()
polydata = polydata_append.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
del polydata_append
if algorithm == 'ca_smoothing':
normals = vtk.vtkPolyDataNormals()
normals_ref = weakref.ref(normals)
normals_ref().AddObserver("ProgressEvent", lambda obj,evt:
UpdateProgress(normals_ref(), _("Creating 3D surface...")))
normals.SetInputData(polydata)
# normals.ReleaseDataFlagOn()
#normals.SetFeatureAngle(80)
#normals.AutoOrientNormalsOn()
normals.ComputeCellNormalsOn()
# normals.GetOutput().ReleaseDataFlagOn()
normals.Update()
del polydata
polydata = normals.GetOutput()
# polydata.SetSource(None)
del normals
clean = vtk.vtkCleanPolyData()
# clean.ReleaseDataFlagOn()
# clean.GetOutput().ReleaseDataFlagOn()
clean_ref = weakref.ref(clean)
clean_ref().AddObserver("ProgressEvent", lambda obj,evt:
UpdateProgress(clean_ref(), _("Creating 3D surface...")))
clean.SetInputData(polydata)
clean.PointMergingOn()
clean.Update()
del polydata
polydata = clean.GetOutput()
# polydata.SetSource(None)
del clean
# try:
# polydata.BuildLinks()
# except TypeError:
# polydata.BuildLinks(0)
# polydata = ca_smoothing.ca_smoothing(polydata, options['angle'],
# options['max distance'],
# options['min weight'],
# options['steps'])
mesh = cy_mesh.Mesh(polydata)
cy_mesh.ca_smoothing(mesh, options['angle'],
options['max distance'],
options['min weight'],
options['steps'])
# polydata = mesh.to_vtk()
# polydata.SetSource(None)
# polydata.DebugOn()
w = vtk.vtkPLYWriter()
w.SetInputData(polydata)
w.SetFileName('/tmp/ca_smoothing_inv.ply')
w.Write()
else:
#smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother = vtk.vtkSmoothPolyDataFilter()
smoother_ref = weakref.ref(smoother)
smoother_ref().AddObserver("ProgressEvent", lambda obj,evt:
UpdateProgress(smoother_ref(), _("Creating 3D surface...")))
smoother.SetInputData(polydata)
smoother.SetNumberOfIterations(smooth_iterations)
smoother.SetRelaxationFactor(smooth_relaxation_factor)
smoother.SetFeatureAngle(80)
#smoother.SetEdgeAngle(90.0)
#smoother.SetPassBand(0.1)
smoother.BoundarySmoothingOn()
smoother.FeatureEdgeSmoothingOn()
#smoother.NormalizeCoordinatesOn()
#smoother.NonManifoldSmoothingOn()
# smoother.ReleaseDataFlagOn()
# smoother.GetOutput().ReleaseDataFlagOn()
smoother.Update()
del polydata
polydata = smoother.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
del smoother
if decimate_reduction:
print "Decimating", decimate_reduction
decimation = vtk.vtkQuadricDecimation()
# decimation.ReleaseDataFlagOn()
decimation.SetInputData(polydata)
decimation.SetTargetReduction(decimate_reduction)
decimation_ref = weakref.ref(decimation)
decimation_ref().AddObserver("ProgressEvent", lambda obj,evt:
UpdateProgress(decimation_ref(), _("Creating 3D surface...")))
#decimation.PreserveTopologyOn()
#decimation.SplittingOff()
#decimation.BoundaryVertexDeletionOff()
# decimation.GetOutput().ReleaseDataFlagOn()
decimation.Update()
del polydata
polydata = decimation.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
del decimation
to_measure = polydata
#to_measure.Register(None)
# to_measure.SetSource(None)
if keep_largest:
conn = vtk.vtkPolyDataConnectivityFilter()
conn.SetInputData(polydata)
conn.SetExtractionModeToLargestRegion()
conn_ref = weakref.ref(conn)
conn_ref().AddObserver("ProgressEvent", lambda obj,evt:
UpdateProgress(conn_ref(), _("Creating 3D surface...")))
conn.Update()
# conn.GetOutput().ReleaseDataFlagOn()
del polydata
polydata = conn.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
del conn
#Filter used to detect and fill holes. Only fill boundary edges holes.
#TODO: Hey! This piece of code is the same from
#polydata_utils.FillSurfaceHole, we need to review this.
if fill_holes:
filled_polydata = vtk.vtkFillHolesFilter()
# filled_polydata.ReleaseDataFlagOn()
filled_polydata.SetInputData(polydata)
filled_polydata.SetHoleSize(300)
filled_polydata_ref = weakref.ref(filled_polydata)
filled_polydata_ref().AddObserver("ProgressEvent", lambda obj,evt:
UpdateProgress(filled_polydata_ref(), _("Creating 3D surface...")))
filled_polydata.Update()
# filled_polydata.GetOutput().ReleaseDataFlagOn()
del polydata
polydata = filled_polydata.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
# polydata.DebugOn()
del filled_polydata
normals = vtk.vtkPolyDataNormals()
# normals.ReleaseDataFlagOn()
normals_ref = weakref.ref(normals)
normals_ref().AddObserver("ProgressEvent", lambda obj,evt:
UpdateProgress(normals_ref(), _("Creating 3D surface...")))
normals.SetInputData(polydata)
normals.SetFeatureAngle(80)
normals.AutoOrientNormalsOn()
# normals.GetOutput().ReleaseDataFlagOn()
normals.Update()
del polydata
polydata = normals.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
del normals
# Improve performance
stripper = vtk.vtkStripper()
# stripper.ReleaseDataFlagOn()
stripper_ref = weakref.ref(stripper)
stripper_ref().AddObserver("ProgressEvent", lambda obj,evt:
UpdateProgress(stripper_ref(), _("Creating 3D surface...")))
stripper.SetInputData(polydata)
stripper.PassThroughCellIdsOn()
stripper.PassThroughPointIdsOn()
# stripper.GetOutput().ReleaseDataFlagOn()
stripper.Update()
del polydata
polydata = stripper.GetOutput()
#polydata.Register(None)
# polydata.SetSource(None)
del stripper
# Map polygonal data (vtkPolyData) to graphics primitives.
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(polydata)
mapper.ScalarVisibilityOff()
# mapper.ReleaseDataFlagOn()
mapper.ImmediateModeRenderingOn() # improve performance
# Represent an object (geometry & properties) in the rendered scene
actor = vtk.vtkActor()
actor.SetMapper(mapper)
del mapper
#Create Surface instance
if overwrite:
surface = Surface(index = self.last_surface_index)
else:
surface = Surface(name=surface_name)
surface.colour = colour
surface.polydata = polydata
del polydata
# Set actor colour and transparency
actor.GetProperty().SetColor(colour)
actor.GetProperty().SetOpacity(1-surface.transparency)
prop = actor.GetProperty()
interpolation = int(ses.Session().surface_interpolation)
prop.SetInterpolation(interpolation)
proj = prj.Project()
if overwrite:
proj.ChangeSurface(surface)
else:
index = proj.AddSurface(surface)
surface.index = index
self.last_surface_index = index
session = ses.Session()
session.ChangeProject()
# The following lines have to be here, otherwise all volumes disappear
measured_polydata = vtk.vtkMassProperties()
# measured_polydata.ReleaseDataFlagOn()
measured_polydata.SetInputData(to_measure)
volume = float(measured_polydata.GetVolume())
area = float(measured_polydata.GetSurfaceArea())
surface.volume = volume
surface.area = area
self.last_surface_index = surface.index
del measured_polydata
del to_measure
Publisher.sendMessage('Load surface actor into viewer', actor)
# Send actor by pubsub to viewer's render
if overwrite and self.actors_dict.keys():
old_actor = self.actors_dict[self.last_surface_index]
Publisher.sendMessage('Remove surface actor from viewer', old_actor)
# Save actor for future management tasks
self.actors_dict[surface.index] = actor
Publisher.sendMessage('Update surface info in GUI',
(surface.index, surface.name,
surface.colour, surface.volume,
surface.area,
surface.transparency))
#When you finalize the progress. The bar is cleaned.
UpdateProgress = vu.ShowProgress(1)
UpdateProgress(0, _("Ready"))
Publisher.sendMessage('Update status text in GUI', _("Ready"))
Publisher.sendMessage('End busy cursor')
del actor
def abs2asc(abs_file, tex_file,output):
ftex = Image.open(tex_file)
f = open(abs_file)
rows = int(f.readline().split()[0])
cols = int(f.readline().split()[0])
values = []
# Reading the junk line
f.readline()
numbers = f.read().split()
#flags
fl = numbers[0: rows * cols]
#X coordinates
x = numbers[rows * cols: rows * cols * 2]
# Y coordinates
y = numbers[rows * cols * 2: rows * cols * 3]
# Z coordinates
z = numbers[rows * cols * 3: rows * cols * 4]
for i in xrange(len(fl)):
if fl[i] == '1':
data.append([x[i], y[i], z[i]])
px = i%cols
py = i/cols
color_pixel = ftex.getpixel((px,py))
point_colors.append(color_pixel)
pointSource.SetExecuteMethod(readPoints)
pointSource.GetOutput().GetCellData().SetScalars(colors)
pointSource.GetOutput().Update()
delaunay = vtk.vtkDelaunay2D()
#delaunay.SetTolerance(0.5)
delaunay.SetAlpha(2.0)
delaunay.SetInput(pointSource.GetOutput())
delaunay.Update()
poly = delaunay.GetOutput()
w = vtk.vtkPLYWriter()
w.SetInput(poly)
w.SetFileName(output + ".ply")
w.SetFileTypeToASCII()
w.SetDataByteOrderToLittleEndian()
#w.SetColorModeToUniformPointColor()
#w.SetScalarsName("aaa")
w.Write()
lnumber = 1
count = 0
max_points = len(point_colors)
#print max_points
for line in fileinput.input(output + ".ply", inplace=1):
if lnumber > 11 and count <= max_points - 1:
r, g, b = point_colors[count]
new_line = line.replace("\n", "")
print new_line, r, g, b
count += 1
elif(lnumber == 8):
print line, "property uchar red\n", "property uchar green\n", "property uchar blue"
else:
new_line = line.replace("\n", "")
print new_line
lnumber += 1
print "Terminou >> ", abs_file, ">>" , output + ".ply"
