def obj_importer(filepath, asset=None, texture_resolver=None, **kwargs):
"""Allows importing Wavefront (OBJ) files.
Uses VTK.
Parameters
----------
asset : `object`, optional
An optional asset that may help with loading. This is unused for this
implementation.
texture_resolver : `callable`, optional
A callable that recieves the mesh filepath and returns a single
path to the texture to load.
\**kwargs : `dict`, optional
Any other keyword arguments.
Returns
-------
shape : :map:`PointCloud` or subclass
The correct shape for the given inputs.
"""
import vtk
from vtk.util.numpy_support import vtk_to_numpy
obj_importer = vtk.vtkOBJReader()
obj_importer.SetFileName(str(filepath))
obj_importer.Update()
# Get the output
polydata = obj_importer.GetOutput()
# We must have point data!
points = vtk_to_numpy(polydata.GetPoints().GetData()).astype(np.float)
trilist = np.require(vtk_ensure_trilist(polydata), requirements=['C'])
texture = None
if texture_resolver is not None:
texture_path = texture_resolver(filepath)
if texture_path is not None and texture_path.exists():
texture = mio.import_image(texture_path)
tcoords = None
if texture is not None:
try:
tcoords = vtk_to_numpy(polydata.GetPointData().GetTCoords())
except Exception:
pass
if isinstance(tcoords, np.ndarray) and tcoords.size == 0:
tcoords = None
colour_per_vertex = None
return _construct_shape_type(points, trilist, tcoords, texture,
colour_per_vertex)
def ReadOBJFile(self, filename):
'''
@param filename: str
@rtype: None
'''
reader = vtk.vtkOBJReader()
reader.SetFileName(filename)
try:
reader.Update()
cleanFilter = vtk.vtkCleanPolyData()
cleanFilter.SetInput(reader.GetOutput())
cleanFilter.ConvertLinesToPointsOn()
cleanFilter.ConvertPolysToLinesOn()
cleanFilter.ConvertStripsToPolysOn()
cleanFilter.PointMergingOn()
cleanFilter.Update()
surfaceFilter = vtk.vtkDataSetSurfaceFilter()
surfaceFilter.SetInput(cleanFilter.GetOutput())
surfaceFilter.Update()
self.setDataSet(surfaceFilter.GetOutput())
del cleanFilter
del surfaceFilter
except Exception, e:
# del reader
print e
raise IOError, "Could not read the OBJ file! "
def Read_Poly_Data(path):
'''
Input:
path: string, full path of data to import. Support stl, ply, obj, vtk.
Output: Poly_Data
Description: Import poly data in various formats.
'''
if path.endswith('.vtk'):
reader = vtk.vtkPolyDataReader()
elif path.endswith('.stl'):
reader = vtk.vtkSTLReader()
elif path.endswith('.ply'):
reader = vtk.vtkPLYReader()
elif path.endswith('.obj'):
reader = vtk.vtkOBJReader()
else:
return 0
reader.SetFileName(path)
reader.Update()
data = reader.GetOutput()
if data:
polydata = Poly_Data()
polydata.Init_From_Vtk(data)
return polydata
return 0
def __init__(self, initial_pos, is_right):
# source = vtk.vtkSphereSource()
# source.SetRadius(3.0)
# cube = vtk.vtkCubeSource()
# cube.SetXLength(5)
# cube.SetYLength(4)
# cube.SetZLength(3)
self.reader = vtk.vtkOBJReader()
self.reader.SetFileName("shoes.obj")
self.vtkPolyData = vtk.vtkPolyData()
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInputConnection(self.reader.GetOutputPort())
self.vtkActor = vtk.vtkActor()
self.vtkActor.SetMapper(self.mapper)
self.vtkActor.SetPosition(initial_pos)
if (is_right):
self.vtkActor.SetScale(0.008)
self.vtkActor.RotateZ(90)
else:
self.vtkActor.SetScale(-0.008)
self.vtkActor.RotateZ(90)
self.vtkActor.RotateX(180)
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkOBJReader(), 'Reading vtkOBJ.',
(), ('vtkOBJ',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def addModel(self, modelFilePath: QUrl) -> Model:
qDebug('ProcessingEngine::addModel()')
modelFilePathExtension = QFileInfo(
modelFilePath).suffix().lower() # returns QString
objReader = vtk.vtkOBJReader()
stlReader = vtk.vtkSTLReader()
inputData = None # vtkPolyData
if modelFilePathExtension == 'obj':
#* Read OBJ file
objReader.SetFileName(modelFilePath)
objReader.Update()
inputData = objReader.GetOutput()
else:
#* Read STL file
stlReader.SetFileName(modelFilePath)
stlReader.Update()
inputData = stlReader.GetOutput()
#* Preprocess the polydata
preprocessedPolydata = self.preprocessPolydata(
inputData) # vtkPolyData
#* Create Model instance and insert it into the vector
model = Model(preprocessedPolydata)
self.__m_models.append(model)
return self.__m_models[-1]
def main():
global INPUT_MODEL, POINTS, KDTREE
INPUT_MODEL = vtk.vtkOBJReader()
INPUT_MODEL.SetFileName(input_filename)
INPUT_MODEL.Update()
v_mapper = vtk.vtkPolyDataMapper()
v_mapper.SetInputConnection(INPUT_MODEL.GetOutputPort())
v_actor = vtk.vtkActor()
v_actor.SetMapper(v_mapper)
# get points
p = [0.0, 0.0, 0.0]
for i in range(INPUT_MODEL.GetOutput().GetNumberOfPoints()):
INPUT_MODEL.GetOutput().GetPoint(i, p)
POINTS.append(tuple(p))
KDTREE = ss.KDTree(POINTS)
ren = vtk.vtkRenderer()
ren.AddActor(v_actor)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
style = MouseInteractorPickingActor()
style.SetDefaultRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetInteractorStyle(style)
iren.SetRenderWindow(renWin)
iren.Initialize()
iren.Start()
def read_obj_files(
number_of_buildings,
begin_building_index, end_building_index, lod,
files, file_offset):
"""
Builds a multiblock dataset (similar with one built by the CityGML reader)
from a list of OBJ files.
"""
if number_of_buildings == UNINITIALIZED and begin_building_index != UNINITIALIZED and end_building_index != UNINITIALIZED:
building_range = range(begin_building_index, end_building_index)
else:
building_range = range(0, min(len(files), number_of_buildings))
root = vtk.vtkMultiBlockDataSet()
for i in building_range:
reader = vtk.vtkOBJReader()
reader.SetFileName(files[i])
reader.Update()
if i == 0:
gdal_utils.read_offset(files[i], file_offset)
polydata = reader.GetOutput()
if (polydata.GetNumberOfPoints() == 0):
logging.warning("Empty OBJ file: {}".format(files[i]))
continue
texture_file = get_obj_texture_file_name(files[i])
set_field(polydata, "texture_uri", texture_file)
building = vtk.vtkMultiBlockDataSet()
building.SetBlock(0, polydata)
root.SetBlock(root.GetNumberOfBlocks(), building)
return root
def read_obj(filename):
"""Test to read and display a wavefront OBJ
"""
reader = vtk.vtkOBJReader()
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)
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
ren.AddActor(actor)
iren.Initialize()
renWin.Render()
iren.Start()
def mesh_from_file(file_path, center_scale=False):
"""Returns a VTK PolyData object from a mesh.
TODO ing file types: off. (The PyMesh Package might help.)"""
allowed_filetypes = ['.ply', '.obj', '.stl', '.off']
if isfile(file_path) and splitext(file_path)[1] in allowed_filetypes:
if splitext(file_path)[1] == '.ply':
reader = vtkPLYReader()
elif splitext(file_path)[1] == '.obj':
reader = vtkOBJReader()
elif splitext(file_path)[1] == '.stl':
reader = vtkSTLReader()
elif splitext(file_path)[1] == '.off':
(vertices, faces) = MeshFactory.off_parser(file_path)
return MeshFactory.mesh_from_data(vertices,
faces,
center_scale=center_scale)
reader.SetFileName(file_path)
reader.Update()
polydata = reader.GetOutput()
if isinstance(polydata, vtkPolyData):
return Mesh(polydata, center_scale, file_path)
else:
msg = 'VTK reader output type expected {}, but got {}'.format(
'vtkCommonDataModelPython.vtkPolyData', type(polydata))
raise TypeError(msg)
else:
msg = 'File {} not present or not allowed filetype: {}'.format(
file_path, ', '.join(allowed_filetypes))
raise OSError(msg)
def load_polydata(file_name):
# get file extension (type)
file_extension = file_name.split(".")[-1].lower()
# todo better generic load
if file_extension == "vtk":
reader = vtk.vtkPolyDataReader()
elif file_extension == "vtp":
reader = vtk.vtkPolyDataReader()
elif file_extension == "fib":
reader = vtk.vtkPolyDataReader()
elif file_extension == "ply":
reader = vtk.vtkPLYReader()
elif file_extension == "stl":
reader = vtk.vtkSTLReader()
elif file_extension == "xml":
reader = vtk.vtkXMLPolyDataReader()
elif file_extension == "obj":
reader = vtk.vtkOBJReader()
#try: # try to read as a normal obj
# reader = vtk.vtkOBJReader()
#except: # than try load a MNI obj format
# reader = vtk.vtkMNIObjectReader()
else:
raise "polydata " + file_extension + " is not suported"
reader.SetFileName(file_name)
reader.Update()
print file_name, " Mesh ", file_extension, "Loaded"
return reader.GetOutput()
def load_points_from_file(filename):
""" Extract vtk mesh from input file.
:returns: Vtk mesh. """
if not os.path.exists(filename):
raise ValueError(f'File {filename} does not exist')
fileType = filename[-4:].lower()
if fileType == ".stl":
reader = vtk.vtkSTLReader()
elif fileType == ".obj":
reader = vtk.vtkOBJReader()
elif fileType == ".vtk":
reader = vtk.vtkPolyDataReader()
elif fileType == ".vtu":
reader = vtk.vtkXMLUnstructuredGridReader()
elif fileType == ".vtp":
reader = vtk.vtkXMLPolyDataReader()
else:
raise IOError(
"Mesh should be .vtk, .vtu, .vtp, .obj, .stl file!")
reader.SetFileName(filename)
reader.Update()
mesh = reader.GetOutput()
return mesh
def read_3D_file(filename):
"""
Read a mesh from an STL, OBJ, PLY or VTK file.
"""
def _read(filename, reader, getVtkReader):
reader.SetFileName(filename)
reader.Update()
if getVtkReader:
return reader
return reader.GetOutput()
if not os.path.exists(filename):
raise IOError('Input file "{0}" was not found'.format(filename))
filenameLower = filename.lower()
getVtkReader = False
extension = get_filename_extension(filenameLower)
if extension == 'stl':
reader = vtk.vtkSTLReader()
sm = _read(filename, reader, getVtkReader)
elif extension == 'obj':
reader = vtk.vtkOBJReader()
sm = _read(filename, reader, getVtkReader)
elif extension == 'ply':
reader = vtk.vtkPLYReader()
sm = _read(filename, reader, getVtkReader)
elif extension == 'vtk':
reader = vtk.vtkGenericDataObjectReader()
reader.SetFileName(filename)
reader.Update()
if reader.IsFilePolyData():
sm = reader.GetPolyDataOutput()
else:
raise Exception
else:
raise Exception('Unknown file format : {0}'.format(extension))
return sm
def CreateSurfaceFromFile(self, filename):
if filename.lower().endswith('.stl'):
reader = vtk.vtkSTLReader()
elif filename.lower().endswith('.ply'):
reader = vtk.vtkPLYReader()
elif filename.lower().endswith('.obj'):
reader = vtk.vtkOBJReader()
elif filename.lower().endswith('.vtp'):
reader = vtk.vtkXMLPolyDataReader()
else:
wx.MessageBox(_("File format not reconized by InVesalius"),
_("Import surface error"))
return
if _has_win32api:
reader.SetFileName(
win32api.GetShortPathName(filename).encode(const.FS_ENCODE))
else:
reader.SetFileName(filename.encode(const.FS_ENCODE))
reader.Update()
polydata = reader.GetOutput()
if polydata.GetNumberOfPoints() == 0:
wx.MessageBox(_("InVesalius was not able to import this surface"),
_("Import surface error"))
else:
name = os.path.splitext(os.path.split(filename)[-1])[0]
self.CreateSurfaceFromPolydata(polydata, name=name)
def loadMesh(path, scale):
# Read in STL
meshPath = cleanResourcePath(path)
extension = os.path.splitext(path)[1]
if extension == ".stl" or extension == ".STL":
meshInput = vtk.vtkSTLReader()
meshInput.SetFileName(path)
meshReader = vtk.vtkTextureMapToPlane()
meshReader.SetInputConnection(meshInput.GetOutputPort())
elif extension == ".obj" or extension == ".OBJ":
meshReader = vtk.vtkOBJReader()
meshReader.SetFileName(path)
else:
ROS_FATAL("Mesh file has invalid extension (" + extension + ")")
# Scale STL
transform = vtk.vtkTransform()
transform.Scale(scale, scale, scale)
# transform.RotateWXYZ(rot[1], rot[2], rot[3], rot[0])
# transform.Translate(pos[0],pos[1], pos[2])
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputConnection(meshReader.GetOutputPort())
transformFilter.Update()
return transformFilter.GetOutput()
def setMeshPath(self, meshPath, scale):
self.meshPath = meshPath
self.scale = scale
# Set up 3D actor for organ
meshPath = cleanResourcePath(self.meshPath)
extension = os.path.splitext(meshPath)[1]
if extension == ".stl" or extension == ".STL":
meshReader = vtk.vtkSTLReader()
elif extension == ".obj" or extension == ".OBJ":
meshReader = vtk.vtkOBJReader()
else:
ROS_FATAL("Mesh file has invalid extension (" + extension + ")")
meshReader.SetFileName(meshPath)
# Scale STL
transform = vtk.vtkTransform()
transform.Scale(scale, scale, scale)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputConnection(meshReader.GetOutputPort())
transformFilter.Update()
color = (0,0,1)
self._updateActorPolydata(self.actor_moving,
polydata=transformFilter.GetOutput(),
color = color)
if image is not None:
# Set texture to default
image = cv2.imread(cleanResourcePath(self.texturePath))
self.actor_moving.setTexture(image)
self.actor_moving.textureOnOff(True)
def write_obj(infile='./data/itokawa_low.obj', outfile='./data/point_clouds/itokawa_low_vtkwriter'):
"""Read from a OBJ and then write to a different one
"""
reader = vtk.vtkOBJReader()
reader.SetFileName(infile)
# write the stl file to a disk
objWriter = vtk.vtkOBJExporter()
objWriter.SetFilePrefix(outfile)
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(reader.GetOutput())
else:
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
ren.AddActor(actor)
iren.Initialize()
renWin.Render()
iren.Start()
objWriter.SetRenderWindow(renWin)
objWriter.Write()
def get_polydata(self):
if not self.enabled:
return None
if self.polydata is None:
if self.parent.status_callback is not None:
self.parent.status_callback(
'Loading mesh file: {:s}...'.format(
os.path.split(self.filename)[1]))
if self.filetype == 'stl':
reader = vtk.vtkSTLReader()
elif self.filetype == 'obj':
reader = vtk.vtkOBJReader()
reader.SetFileName(self.filename)
reader.Update()
scaler = vtk.vtkTransformPolyDataFilter()
scale_transform = vtk.vtkTransform()
scale_transform.Scale(self.scale, self.scale, self.scale)
scaler.SetInputData(reader.GetOutput())
scaler.SetTransform(scale_transform)
scaler.Update()
self.polydata = scaler.GetOutput()
if self.parent.status_callback is not None:
self.parent.status_callback(None)
return self.polydata
def load_polydata(file_name):
# get file extension (type)
file_extension = file_name.split(".")[-1].lower()
# todo better generic load
if file_extension == "vtk":
reader = vtk.vtkPolyDataReader()
elif file_extension == "vtp":
reader = vtk.vtkPolyDataReader()
elif file_extension == "fib":
reader = vtk.vtkPolyDataReader()
elif file_extension == "ply":
reader = vtk.vtkPLYReader()
elif file_extension == "stl":
reader = vtk.vtkSTLReader()
elif file_extension == "xml":
reader = vtk.vtkXMLPolyDataReader()
elif file_extension == "obj":
reader = vtk.vtkOBJReader()
# try: # try to read as a normal obj
# reader = vtk.vtkOBJReader()
# except: # than try load a MNI obj format
# reader = vtk.vtkMNIObjectReader()
else:
raise "polydata " + file_extension + " is not suported"
reader.SetFileName(file_name)
reader.Update()
print(file_name + " Mesh " + file_extension + " Loaded")
return reader.GetOutput()
def CreateSurfaceFromFile(self, filename):
scalar = False
if filename.lower().endswith('.stl'):
reader = vtk.vtkSTLReader()
elif filename.lower().endswith('.ply'):
reader = vtk.vtkPLYReader()
elif filename.lower().endswith('.obj'):
reader = vtk.vtkOBJReader()
elif filename.lower().endswith('.vtp'):
reader = vtk.vtkXMLPolyDataReader()
scalar = True
else:
wx.MessageBox(_("File format not reconized by InVesalius"), _("Import surface error"))
return
if _has_win32api:
reader.SetFileName(win32api.GetShortPathName(filename).encode(const.FS_ENCODE))
else:
reader.SetFileName(filename.encode(const.FS_ENCODE))
reader.Update()
polydata = reader.GetOutput()
if polydata.GetNumberOfPoints() == 0:
wx.MessageBox(_("InVesalius was not able to import this surface"), _("Import surface error"))
else:
name = os.path.splitext(os.path.split(filename)[-1])[0]
self.CreateSurfaceFromPolydata(polydata, name=name, scalar=scalar)
def unpack_sdf_vtk_samples(filename, num_points=1000):
reader = vtk.vtkOBJReader()
reader.SetFileName(filename)
reader.Update()
polydata = reader.GetOutput()
pdd = vtk.vtkImplicitPolyDataDistance()
pdd.SetInput(polydata)
sdf = []
closestPoints = []
vectors = []
F=3
V = np.random.uniform(-1,1,(int(num_points),F))
for i in range(int(num_points)):
closestPoint = np.zeros(3)
distance = pdd.EvaluateFunctionAndGetClosestPoint(V[i,:],closestPoint)
sdf.append(distance)
vector_gt = np.subtract(V[i,:],closestPoint)
closestPoints.append(closestPoint)
vectors.append(vector_gt)
vectors = np.stack(vectors)
vectors = np.reshape(vectors,(vectors.shape[0],-1))
sdf = np.stack(sdf)
sdf = np.reshape(sdf,(sdf.shape[0],-1))
samples = np.concatenate((V,sdf,vectors),axis=1)
samples = torch.from_numpy(samples).float()
return samples
def __init__(self, module_manager):
"""Constructor (initialiser) for the PD reader.
This is almost standard code for most of the modules making use of
the FilenameViewModuleMixin mixin.
"""
# call the constructor in the "base"
ModuleBase.__init__(self, module_manager)
# setup necessary VTK objects
self._reader = vtk.vtkOBJReader()
# ctor for this specific mixin
FilenameViewModuleMixin.__init__(
self,
'Select a filename',
'Wavefront OBJ data (*.obj)|*.obj|All files (*)|*',
{'vtkOBJReader': self._reader})
module_utils.setup_vtk_object_progress(self, self._reader,
'Reading Wavefront OBJ data')
# set up some defaults
self._config.filename = ''
self.sync_module_logic_with_config()
def obj_importer(filepath, asset=None, texture_resolver=None, **kwargs):
obj_importer = vtk.vtkOBJReader()
obj_importer.SetFileName(str(filepath))
obj_importer.Update()
# Get the output
polydata = obj_importer.GetOutput()
# We must have point data!
points = vtk_to_numpy(polydata.GetPoints().GetData()).astype(np.float)
trilist = np.require(vtk_ensure_trilist(polydata), requirements=['C'])
texture = None
if texture_resolver is not None:
texture_path = texture_resolver(filepath)
if texture_path is not None and texture_path.exists():
texture = mio.import_image(texture_path)
tcoords = None
if texture is not None:
try:
tcoords = vtk_to_numpy(polydata.GetPointData().GetTCoords())
except Exception:
pass
if isinstance(tcoords, np.ndarray) and tcoords.size == 0:
tcoords = None
colour_per_vertex = None
return _construct_shape_type(points, trilist, tcoords, texture,
colour_per_vertex)
def obj_to_numpy(filename):
"""Convert OBJ to a numpy array
https://stackoverflow.com/questions/23138112/vtk-to-maplotlib-using-numpy
"""
reader = vtk.vtkOBJReader()
reader.SetFileName(filename)
reader.Update()
output = reader.GetOutput()
points = output.GetPoints()
verts = numpy_support.vtk_to_numpy(points.GetData())
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(reader.GetOutput())
else:
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
ren.AddActor(actor)
iren.Initialize()
renWin.Render()
iren.Start()
return verts
def load_OBJ(filename):
"""Loads Wavefront OBJ file format.
It relies on the reader from the VTK library.
Parameters
----------
filename: str
name of the mesh file on disk
Returns
-------
vertices: ndarray
numpy array of the coordinates of the mesh's nodes
faces: ndarray
numpy array of the faces' nodes connectivities
Note
----
VTU files have a 0-indexing
"""
_check_file(filename)
from vtk import vtkOBJReader
reader = vtkOBJReader()
reader.SetFileName(filename)
reader.Update()
vtk_mesh = reader.GetOutput()
vertices, faces = _dump_vtk(vtk_mesh)
return vertices, faces
def Model(model_path, model_image_path=None):
if model_path[-4:].lower() == '.obj':
reader = vtk.vtkOBJReader()
reader.SetFileName(model_path)
reader.Update()
polyData = reader.GetOutput()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(polyData)
objActor = vtk.vtkActor()
objActor.SetMapper(mapper)
# texture from image
if model_image_path is not None:
texture = vtk.vtkTexture()
if model_image_path[-4:].lower(
) == '.jpg' or model_image_path[-4:].lower() == '.jpeg':
jpgReader = vtk.vtkJPEGReader()
jpgReader.SetFileName(model_image_path)
jpgReader.Update()
texture.SetInputConnection(jpgReader.GetOutputPort())
elif model_image_path[-4:].lower() == '.png':
pngReader = vtk.vtkPNGReader()
pngReader.SetFileName(model_image_path)
pngReader.Update()
texture.SetInputConnection(pngReader.GetOutputPort())
objActor.SetTexture(texture)
return objActor
def CanReadFile(self, filename):
'''
Static methods for I/O
@param filename: str
@rtype: unsigned int
'''
if self.IsMeshExtension(os.path.splitext(filename)[1]):
return self.FILE_IS_VTK
if self.IsOBJExtension(os.path.splitext(filename)[1]):
reader = vtk.vtkOBJReader()
reader.SetFileName(filename)
try:
reader.Update()
except:
# del reader
return 0
# del reader
return self.FILE_IS_OBJ
if not self.IsVtkExtension(os.path.splitext(filename)[1]):
return 0
try:
reader = vtk.vtkPolyDataReader()
reader.SetFileName(filename)
if reader.IsFilePolyData():
# del reader
return self.FILE_IS_VTK
# del reader
except:
pass
return 0
def load_vtk_mesh(fileName):
"""
Loads surface/volume mesh to VTK
"""
if (fileName == ''):
return 0
fn_dir, fn_ext = os.path.splitext(fileName)
if (fn_ext == '.vtk'):
print('Reading vtk with name: ', fileName)
reader = vtk.vtkPolyDataReader()
elif (fn_ext == '.vtp'):
print('Reading vtp with name: ', fileName)
reader = vtk.vtkXMLPolyDataReader()
elif (fn_ext == '.stl'):
print('Reading stl with name: ', fileName)
reader = vtk.vtkSTLReader()
elif (fn_ext == '.obj'):
print('Reading obj with name: ', fileName)
reader = vtk.vtkOBJReader()
elif (fn_ext == '.vtu'):
print('Reading vtu with name: ', fileName)
reader = vtk.vtkXMLUnstructuredGridReader()
elif (fn_ext == '.pvtu'):
print('Reading pvtu with name: ', fileName)
reader = vtk.vtkXMLPUnstructuredGridReader()
else:
print(fn_ext)
raise ValueError('File extension not supported')
reader.SetFileName(fileName)
reader.Update()
return reader.GetOutput()
def makeTexturedObjData(objPath, scale=1):
""" Loads .obj into VTK polyData optimized for searching texture space.
Args:
objPath (string): File path to .obj file to load
Returns:
polyData (vtk.vtkPolyData): VTK polyData object optimized for finding
mapping from 2D texture coordinates to 3D world coordinates
"""
meshReader = vtk.vtkOBJReader()
meshReader.SetFileName(objPath)
triFilter = vtk.vtkTriangleFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
triFilter.SetInput(meshReader.GetOutput())
else:
triFilter.SetInputConnection(meshReader.GetOutputPort())
transform = vtk.vtkTransform()
transform.Scale(scale,scale,scale)
transformFilter=vtk.vtkTransformPolyDataFilter()
transformFilter.SetTransform(transform)
if vtk.VTK_MAJOR_VERSION <= 5:
triFilter.SetInput(meshReader.GetOutput())
else:
transformFilter.SetInputConnection(triFilter.GetOutputPort())
normalGenerator = vtk.vtkPolyDataNormals()
normalGenerator.ComputePointNormalsOn()
normalGenerator.ComputeCellNormalsOn()
if vtk.VTK_MAJOR_VERSION <= 5:
normalGenerator.SetInput(transformFilter.GetOutput())
else:
normalGenerator.SetInputConnection(transformFilter.GetOutputPort())
normalGenerator.Update()
polyData = normalGenerator.GetOutput()
return polyData
def vtk_read(path):
reader = vtk.vtkOBJReader()
reader.SetFileName(path)
reader.Update()
pdata = reader.GetOutput()
# check if the stl file is closed
featureEdge = vtk.vtkFeatureEdges()
featureEdge.FeatureEdgesOff()
featureEdge.BoundaryEdgesOn()
featureEdge.NonManifoldEdgesOn()
featureEdge.SetInputData(pdata)
featureEdge.Update()
# pass pdata through a triangle filter
tr = vtk.vtkTriangleFilter()
tr.SetInputData(pdata)
tr.PassVertsOff()
tr.PassLinesOff()
tr.Update()
# normals filter
pnormal = vtk.vtkPolyDataNormals()
pnormal.SetInputData(tr.GetOutput())
pnormal.AutoOrientNormalsOff()
pnormal.ComputePointNormalsOn()
pnormal.ComputeCellNormalsOff()
pnormal.SplittingOff()
pnormal.ConsistencyOn()
pnormal.FlipNormalsOn()
pnormal.Update()
pdata = pnormal.GetOutput()
# create a vtkSelectEnclosedPoints filter
filter = vtk.vtkSelectEnclosedPoints()
filter.SetSurfaceData(pdata)
print(pdata.GetNumberOfPoints())
print(pdata.GetPointData().GetNumberOfTuples())
# print(pdata)
obj_points = np.zeros([pdata.GetNumberOfPoints(), 3])
obj_normals = np.zeros([pdata.GetNumberOfPoints(), 3])
polydata = vtk.vtkPolyData()
polydata.ShallowCopy(pdata)
for i in range(pdata.GetNumberOfPoints()):
obj_points[i, :] = pdata.GetPoint(i)
obj_normals[i, :] = pdata.GetPointData().GetNormals().GetTuple(i)
obj_polygons = numpy.zeros([pdata.GetNumberOfCells(), 3]).astype(np.int)
for i in range(pdata.GetNumberOfCells()):
cell = vtk.vtkIdList()
pdata.GetCellPoints(i, cell)
for j in range(3):
obj_polygons[i, j] = cell.GetId(j)
# print(cell.GetId(j) )
return (obj_points, obj_normals, obj_polygons)
def readOBJECT(self, *args):
# create reader
reader = vtk.vtkOBJReader()
reader.SetFileName(os.path.join(self.directory, args[0]))
reader.Update()
return reader
def ReadOBJSurfaceFile(self):
if (self.InputFileName == ''):
self.PrintError('Error: no InputFileName.')
self.PrintLog('Reading wavefront surface file.')
reader = vtk.vtkOBJReader()
reader.SetFileName(self.InputFileName)
reader.Update()
self.Surface = reader.GetOutput()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkOBJReader(),
'Reading vtkOBJ.', (), ('vtkOBJ', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def loadOBJ(self):
"""
初始化，加载模型.obj格式文件
"""
self.reader = vtk.vtkOBJReader()
self.reader.SetFileName(self.filename)
self.reader.Update()
self.data = self.reader.GetOutput()
def load_obj(self, obj_file):
reader = vtk.vtkOBJReader()
reader.SetFileName(obj_file)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
return self._add_mesh_actor(actor)
def obj_importer(filepath, asset=None, texture_resolver=None, **kwargs):
"""Allows importing Wavefront (OBJ) files.
Uses VTK.
Parameters
----------
asset : `object`, optional
An optional asset that may help with loading. This is unused for this
implementation.
texture_resolver : `callable`, optional
A callable that recieves the mesh filepath and returns a single
path to the texture to load.
\**kwargs : `dict`, optional
Any other keyword arguments.
Returns
-------
shape : :map:`PointCloud` or subclass
The correct shape for the given inputs.
"""
import vtk
from vtk.util.numpy_support import vtk_to_numpy
obj_importer = vtk.vtkOBJReader()
obj_importer.SetFileName(str(filepath))
obj_importer.Update()
# Get the output
polydata = obj_importer.GetOutput()
# We must have point data!
points = vtk_to_numpy(polydata.GetPoints().GetData()).astype(np.float)
trilist = np.require(vtk_ensure_trilist(polydata), requirements=['C'])
texture = None
if texture_resolver is not None:
texture_path = texture_resolver(filepath)
if texture_path is not None and texture_path.exists():
texture = mio.import_image(texture_path)
tcoords = None
if texture is not None:
try:
tcoords = vtk_to_numpy(polydata.GetPointData().GetTCoords())
except Exception:
pass
if isinstance(tcoords, np.ndarray) and tcoords.size == 0:
tcoords = None
colour_per_vertex = None
return _construct_shape_type(points, trilist, tcoords, texture,
colour_per_vertex)
def loadPolyData(filename):
'''Load a file and return a vtkPolyData object (not a vtkActor).'''
if not os.path.exists(filename):
colors.printc('Error in loadPolyData: Cannot find', filename, c=1)
return None
fl = filename.lower()
if fl.endswith('.vtk') or fl.endswith('.vtp'):
reader = vtk.vtkPolyDataReader()
elif fl.endswith('.ply'):
reader = vtk.vtkPLYReader()
elif fl.endswith('.obj'):
reader = vtk.vtkOBJReader()
elif fl.endswith('.stl'):
reader = vtk.vtkSTLReader()
elif fl.endswith('.byu') or fl.endswith('.g'):
reader = vtk.vtkBYUReader()
elif fl.endswith('.vtp'):
reader = vtk.vtkXMLPolyDataReader()
elif fl.endswith('.vts'):
reader = vtk.vtkXMLStructuredGridReader()
elif fl.endswith('.vtu'):
reader = vtk.vtkXMLUnstructuredGridReader()
elif fl.endswith('.txt'):
reader = vtk.vtkParticleReader() # (x y z scalar)
elif fl.endswith('.xyz'):
reader = vtk.vtkParticleReader()
else:
reader = vtk.vtkDataReader()
reader.SetFileName(filename)
if fl.endswith('.vts'): # structured grid
reader.Update()
gf = vtk.vtkStructuredGridGeometryFilter()
gf.SetInputConnection(reader.GetOutputPort())
gf.Update()
poly = gf.GetOutput()
elif fl.endswith('.vtu'): # unstructured grid
reader.Update()
gf = vtk.vtkGeometryFilter()
gf.SetInputConnection(reader.GetOutputPort())
gf.Update()
poly = gf.GetOutput()
else:
try:
reader.Update()
poly = reader.GetOutput()
except:
poly = None
if not poly:
return None
cleanpd = vtk.vtkCleanPolyData()
cleanpd.SetInputData(poly)
cleanpd.Update()
return cleanpd.GetOutput()
def obj_to_vtk(in_filename, out_filename):
# Read the obj file
reader = vtk.vtkOBJReader()
reader.SetFileName(in_filename)
reader.Update()
# Write the vtk file
writer = vtk.vtkPolyDataWriter()
writer.SetFileName(out_filename)
writer.SetInputConnection(reader.GetOutputPort())
writer.Write()
def loadOBJforVTK(filenameOBJ):
readerOBJ = vtk.vtkOBJReader()
readerOBJ.SetFileName(filenameOBJ)
# 'update' the reader i.e. read the .stl file
readerOBJ.Update()
polydata = readerOBJ.GetOutput()
# If there are no points in 'vtkPolyData' something went wrong
if polydata.GetNumberOfPoints() == 0:
raise ValueError(
"No point data could be loaded from '" + filenameOBJ)
return None
return polydata
def readOBJ(self, filename=None):
if filename is not None:
self.filename = filename
r = vtk.vtkOBJReader()
r.SetFileName( self.filename )
r.Update()
self.polydata = r.GetOutput()
if self.polydata.GetPoints()==None:
raise IOError, 'file not loaded'
else:
self._loadPoints()
self._loadTriangles()
def CreateCoilReference(self):
#SILVER COIL
self.coil_reference = vtk.vtkOBJReader()
#self.coil_reference.SetFileName(os.path.realpath(os.path.join('..',
# 'models',
# 'coil_cti_2_scale10.obj')))
self.coil_reference.SetFileName('C:\Users\Biomag\Desktop\invesalius_navigator\icons\coil_cti_2_scale10.obj')
##self.coil_reference.Update()
coilMapper = vtk.vtkPolyDataMapper()
coilMapper.SetInputConnection(self.coil_reference.GetOutputPort())
self.coilActor = vtk.vtkActor()
self.coilActor.SetMapper(coilMapper)
def getReader(self):
reader = None;
if self.convertAsTemplate:
self.tempSrc = "{}.stlb".format(self.src[:self.src.rindex(".")]);
import ivcon;
if ivcon.convert(self.src,self.tempSrc) > 0:
self.src = self.tempSrc;
self.hasTemplate = True;
self.convertAsTemplate = False;
else:
raise IOError("{} is not supported currently".format(self.srcFormat));
if self.srcFormat in ("stl","stla","stlb",) :
reader = vtk.vtkSTLReader();
elif self.srcFormat == "ply":
reader = vtk.vtkPLYReader();
elif self.srcFormat == "vtp":
reader = vtk.vtkXMLPolyDataReader();
elif self.srcFormat == "obj":
reader = vtk.vtkOBJReader();
reader.SetFileName(self.src);
reader.Update();
return reader;
(options, args) = parser.parse_args()
assert(len(options.ModelFilename) > 0 )
assert(len(options.TraySizeInMM) == 2 )
TraySizeInMM = [float(sz) for sz in options.TraySizeInMM]
assert(len(options.WindowSize) == 2 )
WindowSize = [int(sz) for sz in options.WindowSize]
if '.STL' in options.ModelFilename.upper():
Model = vtk.vtkSTLReader()
elif '.OBJ' in options.ModelFilename.upper():
Model = vtk.vtkOBJReader()
else:
raise Exception('Unknown file type for model: %s'%options.ModelFilename)
Model.SetFileName(options.ModelFilename)
Model.Update()
ModelOutput = Model.GetOutput()
BoundingBox = ModelOutput.GetBounds()
Mapper = vtk.vtkPolyDataMapper()
Mapper.SetInputConnection(Model.GetOutputPort())
Actor = vtk.vtkLODActor()
Actor.SetMapper(Mapper)
def CurvaturesDemo(self, filePath, nominalRadius):
sphere = Sphere(filePath, nominalRadius, False)
errors = np.abs(sphere.fittingError())
print sphere.curvature.max()
print sphere.curvature.argmax()
reader = vtk.vtkOBJReader()
reader.SetFileName(sys.argv[1])
reader.Update()
# Colour transfer function.
ctf = vtk.vtkColorTransferFunction()
ctf.SetColorSpaceToDiverging()
ctf.AddRGBPoint(0.0, 0.230, 0.299, 0.754)
ctf.AddRGBPoint(0.5, 1.0, 1.0, 1.0)
ctf.AddRGBPoint(1.0, 0.706, 0.016, 0.150)
cc = list()
for i in range(256):
cc.append(ctf.GetColor(float(i) / 255.0))
scalars = vtk.vtkFloatArray()
scalars.SetNumberOfComponents(1)
for errorVal in errors:
scalars.InsertNextTuple([errorVal])
mean = np.mean(errors)
std = np.std(errors)
min3 = mean - std
max3 = mean + std
# Now we have the sources, lets put them into a list.
sources = list()
sources.append(reader)
sources.append(reader)
sources.append(sphere.polyData)
sources.append(sphere.polyData)
curvatures = list()
for idx in range(2):
curvatures.append(vtk.vtkCurvatures())
curvatures[idx].SetInputConnection(sources[idx].GetOutputPort())
if idx % 2 == 0:
curvatures[idx].SetCurvatureTypeToGaussian()
curvatures[idx].Update()
npcurv1 = numpy_support.vtk_to_numpy(curvatures[idx].GetOutput().GetPointData().GetScalars())
mean = np.mean(npcurv1)
std = np.std(npcurv1)
min1 = 0.01*(mean - std)
max1 = 0.01*(mean + std)
else:
curvatures[idx].SetCurvatureTypeToMean()
curvatures[idx].Update()
npcurv2 = np.abs(numpy_support.vtk_to_numpy(curvatures[idx].GetOutput().GetPointData().GetScalars()))
mean = np.mean(npcurv2)
std = np.std(npcurv2)
#print 'Curvature (min / max / mean / total): ' + str(np.min(npcurv2)) + ' / ' + str(np.max(npcurv2)) + ' / ' + str(np.mean(npcurv2)) + ' / ' + str(np.sum(npcurv2))
min2 = mean - std
max2 = mean + std
fig = plt.figure()
xa = np.arange(-0.1, 0.1,0.001)
#plt.hist(npcurv1, bins=xa)
plt.hist(npcurv2/npcurv2.max(), bins=xa)
print 'By vtk:'
print npcurv2.max()
print npcurv2.argmax()
plt.gca().set_yscale('log')
plt.show()
# Lookup table.
lut = list()
for idx in range(len(sources)):
lut.append(vtk.vtkLookupTable())
lut[idx].SetNumberOfColors(256)
for i, item in enumerate(cc):
lut[idx].SetTableValue(i, item[0], item[1], item[2], 1.0)
if idx == 0:
lut[idx].SetRange(min1, max1)
if idx == 1:
lut[idx].SetRange(min2, max2)
if idx == 2:
lut[idx].SetRange(min3, max3)
lut[idx].Build()
renderers = list()
mappers = list()
actors = list()
textmappers = list()
textactors = list()
scalarbars = list()
# Create a common text property.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(16)
textProperty.SetJustificationToCentered()
names = ['Sphere - Gaussian Curvature', 'Sphere - Mean Curvature', 'Sphere - Residuals to fitted sphere', 'Sphere - Residuals to fitted sphere']
# Link the pipeline together.
for idx, item in enumerate(sources):
#sources[idx].Update()
mappers.append(vtk.vtkPolyDataMapper())
mappers[idx].SetUseLookupTableScalarRange(1)
if idx < 2:
#print npcurv.min(), npcurv.max()
#print npcurv
mappers[idx].SetInputConnection(curvatures[idx].GetOutputPort())
mappers[idx].SetLookupTable(lut[idx])
else:
#mappers[idx].SetInputConnection(sources[idx].GetOutputPort())
mappers[idx].SetInputData(sources[idx])
mappers[idx].SetColorModeToMapScalars()
#mappers[idx].GetPointData().SetScalars(scalars)
mappers[idx].SetLookupTable(lut[idx])
actors.append(vtk.vtkActor())
actors[idx].SetMapper(mappers[idx])
if idx == 3:
actors[idx].GetProperty().SetEdgeVisibility(1)
actors[idx].GetProperty().SetEdgeColor(0.5, 0.5, 0.5);
actors[idx].GetProperty().SetLineWidth(0.5)
textmappers.append(vtk.vtkTextMapper())
textmappers[idx].SetInput(names[idx])
textmappers[idx].SetTextProperty(textProperty)
textactors.append(vtk.vtkActor2D())
textactors[idx].SetMapper(textmappers[idx])
textactors[idx].SetPosition(150, 16)
scalarbars.append(vtk.vtkScalarBarActor())
scalarbars[idx].SetLookupTable(lut[idx])
renderers.append(vtk.vtkRenderer())
gridDimensions = 2
for idx in range(len(sources)):
if idx < gridDimensions * gridDimensions:
renderers.append(vtk.vtkRenderer)
rendererSize = 300
# Create the RenderWindow
#
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(rendererSize * gridDimensions, 0)
# Add and position the renders to the render window.
viewport = list()
for row in range(gridDimensions):
for col in range(gridDimensions):
idx = row * gridDimensions + col
viewport[:] = []
viewport.append(float(col) * rendererSize / (gridDimensions * rendererSize))
viewport.append(float(gridDimensions - (row+1)) * rendererSize / (gridDimensions * rendererSize))
viewport.append(float(col+1)*rendererSize / (gridDimensions * rendererSize))
viewport.append(float(gridDimensions - row) * rendererSize / (gridDimensions * rendererSize))
if idx > (len(sources) - 1):
continue
renderers[idx].SetViewport(viewport)
renderWindow.AddRenderer(renderers[idx])
renderers[idx].AddActor(actors[idx])
renderers[idx].AddActor(textactors[idx])
renderers[idx].AddActor(scalarbars[idx])
renderers[idx].SetBackground(0.5,0.5,0.5)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
# read polydata file # poly = vtk.vtkPolyDataReader() poly.SetFileName(poly_filename) polyMapper = vtk.vtkPolyDataMapper() polyMapper.SetInputConnection(poly.GetOutputPort()) polyActor = vtk.vtkActor() polyActor.SetMapper(polyMapper) #polyActor.GetProperty().SetRepresentationToWireframe(); #polyActor.GetProperty().SetColor(1.0, 0.2, 0.2) ############################################################################### # read obj file # object = vtk.vtkOBJReader() object.SetFileName(obj_filename) objectMapper = vtk.vtkPolyDataMapper() objectMapper.SetInputConnection(object.GetOutputPort()) objectActor = vtk.vtkActor() objectActor.SetMapper(objectMapper) objectActor.GetProperty().SetRepresentationToWireframe(); objectActor.GetProperty().SetColor(1.0, 0.2, 0.2) ############################################################################### # read second obj file # object2 = vtk.vtkOBJReader() object2.SetFileName(obj2_filename) object2Mapper = vtk.vtkPolyDataMapper()
# transform = vtk.vtkTransform() transform.RotateWXYZ(180, 1, 0, 0) move = [0, 0, 0] transform.Translate(move) #transformFilter = vtk.vtkTransformPolyDataFilter() #transformFilter.SetTransform(transform) transforms = [] transforms_filter = [] ############################################################################### # read obj file # obj_filename = '/mnt/data1/StandardBrain/SB/SB256.obj' object = vtk.vtkOBJReader() object.SetFileName(obj_filename) objectSmoother = vtk.vtkSmoothPolyDataFilter() objectSmoother.SetInputConnection(object.GetOutputPort()) objectSmoother.SetNumberOfIterations(100) transforms_filter.append(vtk.vtkTransformPolyDataFilter()) transforms_filter[-1].SetTransform(transform) transforms_filter[-1].SetInputConnection(objectSmoother.GetOutputPort()) transforms_filter[-1].Update() objectMapper = vtk.vtkPolyDataMapper() objectMapper.SetInputConnection(transforms_filter[-1].GetOutputPort()) objectActor = vtk.vtkActor() objectActor.SetMapper(objectMapper)
#!/usr/bin/env python
import sys
import vtk
if (len(sys.argv) == 1):
print "This script should at least contain 1 argument.\nUsage: vtkpython ImportObj.py $inputFile"
sys.exit()
path = sys.argv[1]
opath = "/tmp/tmp.vtp"
if len(sys.argv) > 2:
opath = sys.argv[3]
reader = vtk.vtkOBJReader()
reader.SetFileName(path)
reader.Update()
mesh = reader.GetOutput()
print "Input mesh file:\n"+path+"\n------------------\nnp:"+str(mesh.GetNumberOfPoints())+"\tnc:"+str(mesh.GetNumberOfCells())+"\n------------------\n"
writer = vtk.vtkXMLPolyDataWriter()
writer.SetInput(mesh)
writer.SetFileName( opath )
writer.SetDataModeToAscii()
writer.Write()
print "Output mesh file\n"+opath+"\n------------------\nPoints: "+str( mesh.GetNumberOfPoints() )+"\nCells: "+str( mesh.GetNumberOfCells() )
EdgeView(1)
elif key == "L":
EdgeView(0)
## begin main
# check that the required number of parameters were passed
if len(sys.argv) < 2:
print "usage: ShowOBJ.py <OBJ surface file>"
sys.exit(1)
# store the argument
OBJFile = sys.argv[1]
# reader for the OBJ file
surfRead = vtk.vtkOBJReader()
surfRead.SetFileName(OBJFile)
surf = surfRead.GetOutput()
## rendering
# window stuff
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
iren.SetRenderWindow(renWin)
# surface display attr
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# Create the RenderWindow, Renderer and both Actors
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# read data
#
wavefront = vtk.vtkOBJReader()
wavefront.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/Viewpoint/cow.obj")
wavefront.Update()
cone = vtk.vtkConeSource()
cone.SetResolution(6)
cone.SetRadius(0.1)
transform = vtk.vtkTransform()
transform.Translate(0.5, 0.0, 0.0)
transformF = vtk.vtkTransformPolyDataFilter()
transformF.SetInputConnection(cone.GetOutputPort())
transformF.SetTransform(transform)
# we just clean the normals for efficiency (keep down number of cones)
clean = vtk.vtkCleanPolyData()
clean.SetInputConnection(wavefront.GetOutputPort())
glyph = vtk.vtkHedgeHog()
glyph.SetInputConnection(clean.GetOutputPort())
