def add_stl(input_file1, input_file2, output_file, transform_file, visualize, overwrite, func):
if os.path.isfile(output_file) and not overwrite:
result = input('File \"{}\" already exists. Overwrite? [y/n]: '.format(output_file))
if result.lower() not in ['y', 'yes']:
print('Not overwriting. Exiting...')
os.sys.exit()
im1 = vtk.vtkSTLReader()
im1.SetFileName(input_file1)
im1.Update()
im2 = vtk.vtkSTLReader()
im2.SetFileName(input_file2)
im2.Update()
im2 = applyTransform(transform_file, im2)
if (visualize):
mat4x4 = visualize_actors( im2.GetOutputPort(), im1.GetOutputPort() )
else:
mat4x4 = vtk.vtkMatrix4x4()
transform = vtk.vtkTransform()
transform.SetMatrix(mat4x4)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputConnection( im2.GetOutputPort() )
transformFilter.SetTransform( transform )
transformFilter.Update()
final_image = joinPolyData( transformFilter.GetOutput(), im1.GetOutput() )
write_stl( final_image.GetOutputPort(), output_file, vtk.vtkMatrix4x4() )
def main():
#Read STL
reader1 = vtk.vtkSTLReader()
reader1.SetFileName("leftdoor.stl")
reader2 = vtk.vtkSTLReader()
reader2.SetFileName("rightdoor.stl")
reader3 = vtk.vtkSTLReader()
reader3.SetFileName("doorframe.stl")
#(-6,22.5,0) (-44,22,5,0)
#Create a mapper and actor
mapper1 = vtk.vtkPolyDataMapper()
mapper1.SetInputConnection(reader1.GetOutputPort())
mapper2 = vtk.vtkPolyDataMapper()
mapper2.SetInputConnection(reader2.GetOutputPort())
mapper3 = vtk.vtkPolyDataMapper()
mapper3.SetInputConnection(reader3.GetOutputPort())
actor1 = vtk.vtkActor()
actor1.SetMapper(mapper1)
actor2 = vtk.vtkActor()
actor2.SetMapper(mapper2)
actor3 = vtk.vtkActor()
actor3.SetMapper(mapper3)
# Setup a renderer, render window, and interactor
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer);
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
#Add the actor to the scene
renderer.AddActor(actor1)
renderer.AddActor(actor2)
renderer.AddActor(actor3)
renderer.SetBackground(0,0,0.8) # RGB 0~1
#Render and interact
renderWindow.Render()
# Initialize must be called prior to creating timer events.
renderWindowInteractor.Initialize()
# Sign up to receive TimerEvent
cb = mytimercallback()
cb.actors.append(actor1)
cb.actors.append(actor2)
cb.actors.append(actor3)
renderWindowInteractor.AddObserver('TimerEvent', cb.execute)
timerId = renderWindowInteractor.CreateRepeatingTimer(100);
#start the interaction and timer
renderWindowInteractor.Start()
def SurfaceDistance(threeDRA_path, CBCT_path, output_path):
reader3DRA = vtk.vtkSTLReader()
reader3DRA.SetFileName(threeDRA_path)
reader3DRA.Update()
threeDRA = reader3DRA.GetOutput()
readerCBCT = vtk.vtkSTLReader()
readerCBCT.SetFileName(CBCT_path)
readerCBCT.Update()
CBCT = readerCBCT.GetOutput()
distanceFilter = vtk.vtkDistancePolyDataFilter()
distanceFilter.SetInputData(0, threeDRA)
distanceFilter.SetInputData(1, CBCT)
distanceFilter.Update()
# extract lcc object
connectivityFilter = vtk.vtkPolyDataConnectivityFilter()
connectivityFilter.SetInputData(distanceFilter.GetOutput())
connectivityFilter.Update()
writer = vtk.vtkXMLPolyDataWriter()
writer.SetFileName(output_path)
writer.SetInputData(connectivityFilter.GetOutput())
writer.Update()
def IterativeClosestPoints(stlpath1: str, stlpath2: str, type: int):
# ============ create source points ==============
reader1 = vtk.vtkSTLReader()
reader1.SetFileName(stlpath1)
reader1.Update()
# ============ 对模型进行裁剪，只保留配准点附近的网格 ==============
source = surface_clip(reader1.GetOutput(), type)
# ============ create target points ==============
reader2 = vtk.vtkSTLReader()
reader2.SetFileName(stlpath2)
reader2.Update()
# ============ 对模型进行裁剪，只保留配准点附近的网格 ==============
target = surface_clip(reader2.GetOutput(), type)
# ============ run ICP ==============
icp = vtk.vtkIterativeClosestPointTransform()
icp.SetSource(source)
icp.SetTarget(target)
# icp.GetLandmarkTransform().SetModeToRigidBody()
# icp.GetLandmarkTransform().SetModeToSimilarity()
icp.GetLandmarkTransform().SetModeToAffine() # 当前实验发现仿射配准的效果最好
# icp.DebugOn()
icp.SetMaximumNumberOfIterations(1000)
icp.StartByMatchingCentroidsOn()
icp.Modified()
icp.Update()
icpTransformFilter = vtk.vtkTransformPolyDataFilter()
icpTransformFilter.SetInputData(source)
icpTransformFilter.SetTransform(icp)
icpTransformFilter.Update()
# ============ write the transformed stl ==============
output_path = stlpath1[0:-4] + "transform3.stl"
writer = vtk.vtkSTLWriter()
writer.SetInputConnection(icpTransformFilter.GetOutputPort())
writer.SetFileName(output_path)
writer.SetFileTypeToBinary()
writer.Write()
matrix = icp.GetMatrix()
# nparray = arrayFromVTKMatrix(matrix)
return matrix
def LerSTL(self, path):
mesh= vtk.vtkSTLReader()
mesh.SetFileName(path)
mesh.Update()
#self.pd = mesh.GetOutput()
self.polydata = mesh.GetOutput()
normals = vtk.vtkPolyDataNormals()
#normals.SetInput(polydata)
normals.SetInputData(mesh.GetOutput())
normals.ComputeCellNormalsOn()
normals.Update()
#mudanças para aumentar a normal
self.vertices =pontos(normals.GetOutput())
self.normalsp = get_normals(normals.GetOutput())
stlMapper = vtk.vtkPolyDataMapper()
stlMapper.SetInputConnection(normals.GetOutputPort())
stlActor = vtk.vtkLODActor()
stlActor.SetMapper(stlMapper)
self.renderer.AddActor(stlActor)
self.Interactor.Render()
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.vtkSTLReader()
# ctor for this specific mixin
FilenameViewModuleMixin.__init__(
self,
'Select a filename',
'STL data (*.stl)|*.stl|All files (*)|*',
{'vtkSTLReader': self._reader})
module_utils.setup_vtk_object_progress(self, self._reader,
'Reading STL data')
# set up some defaults
self._config.filename = ''
self.sync_module_logic_with_config()
def view_stl(filename):
"""
http://www.vtk.org/Wiki/VTK/Examples/Python/STLReader
"""
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(reader.GetOutput())
else:
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Create a rendering window and renderer
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
# Create a renderwindowinteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Assign actor to the renderer
ren.AddActor(actor)
# Enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
def readPData(
filename,
verbose=0):
mypy.my_print(verbose, "*** readPData: "+filename+" ***")
assert (os.path.isfile(filename)), "Wrong filename (\""+filename+"\"). Aborting."
if (filename.endswith('vtk')):
pdata_reader = vtk.vtkPolyDataReader()
elif (filename.endswith('vtp')):
pdata_reader = vtk.vtkXMLPolyDataReader()
elif (filename.endswith('stl')):
pdata_reader = vtk.vtkSTLReader()
else:
assert 0, "File must be .vtk, .vtp or .stl. Aborting."
pdata_reader.SetFileName(filename)
pdata_reader.Update()
pdata = pdata_reader.GetOutput()
mypy.my_print(verbose-1, "n_points = "+str(pdata.GetNumberOfPoints()))
mypy.my_print(verbose-1, "n_verts = "+str(pdata.GetNumberOfVerts()))
mypy.my_print(verbose-1, "n_lines = "+str(pdata.GetNumberOfLines()))
mypy.my_print(verbose-1, "n_polys = "+str(pdata.GetNumberOfPolys()))
mypy.my_print(verbose-1, "n_strips = "+str(pdata.GetNumberOfStrips()))
return pdata
def readStlFile(stlfilepath):
stlreader = vtk.vtkSTLReader()
stlreader.SetFileName(stlfilepath)
stlreader.Update()
# 处理stl
polyData = stlreader.GetOutput()
return polyData
def render_view(self):
self.renderer.RemoveAllViewProps()
i = 0
while self.model.item(i):
if self.model.item(i).checkState():
cloud_source = vtk.vtkSTLReader()
cloud_source.SetFileName(self.model.item(i).text())
translation = vtk.vtkTransform()
translation.Scale(1, 1, 1)
transform_filter = vtk.vtkTransformPolyDataFilter()
transform_filter.SetTransform(translation)
transform_filter.SetInputConnection(
cloud_source.GetOutputPort())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(transform_filter.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.SetVisibility(True)
self.renderer.AddActor(actor)
print(self.model.item(i).text())
i += 1
self.vtk_widget.update()
def importSTL(filename):
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
reader.Update()
outputVol = np.zeros((500,500,500))
outputVTK = vtk_import_numpy_array(outputVol)
dataToStencil = vtk.vtkPolyDataToImageStencil()
dataToStencil.SetInputConnection(reader.GetOutputPort())
dataToStencil.SetOutputSpacing(0.5, 0.5, 0.5)
dataToStencil.SetOutputOrigin(0.0, 0.0, 0.0)
dataToStencil.Update()
stencil = vtk.vtkImageStencil()
stencil.SetInput(outputVTK.GetOutput())
stencil.SetStencil(dataToStencil.GetOutput())
stencil.ReverseStencilOn()
stencil.Update()
im = stencil.GetOutput()
rows, cols, lines = im.GetDimensions()
sc = im.GetPointData().GetScalars()
a = vtk_to_numpy(sc)
a = a.reshape((lines,cols,rows))
return a
def load_file(path):
"""from path load stl and voxelize it
Arguments:
path {string} -- file path
Returns:
vtkImageData -- vtk voxel data type
"""
stl_reader = vtk.vtkSTLReader()
stl_reader.SetFileName(path)
stl_reader.Update()
bounds = stl_reader.GetOutput().GetBounds()
vox_modeller = vtk.vtkVoxelModeller()
vox_modeller.SetSampleDimensions(64, 64, 64)
vox_modeller.SetModelBounds(bounds)
vox_modeller.SetScalarTypeToInt()
vox_modeller.SetMaximumDistance(.1)
vox_modeller.SetInputConnection(stl_reader.GetOutputPort())
vox_modeller.Update()
return vox_modeller.GetOutput()
def Read(self, m_forceRead=False):
"""
Initial step, should be performed before everything else starts, considering to add
this into the class constructor so that it is read automatically.
:return:
"""
# Skip redundant read if it is already done
if self._IS_READ_FLAG and not m_forceRead:
return
if self.filename.split(".")[-1] == "vtp" or self.filename.split(".")[-1] == "vtk":
m_reader = vtk.vtkXMLPolyDataReader()
elif self.filename.split(".")[-1] == "stl":
m_reader = vtk.vtkSTLReader()
else:
raise IOError("Input file for arm surface is of incorrect format")
m_reader.SetFileName(self.filename)
m_reader.Update()
m_mapper = vtk.vtkPolyDataMapper()
m_mapper.SetInputConnection(m_reader.GetOutputPort())
m_actor = vtk.vtkActor()
m_actor.SetMapper(m_mapper)
self._reader = m_reader
self._renderer.AddActor(m_actor)
self._data = m_reader.GetOutput()
self._IS_READ_FLAG = True
pass
def __init__(self, parent = None):
QtGui.QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ren = vtk.vtkRenderer()
self.ui.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.ui.vtkWidget.GetRenderWindow().GetInteractor()
filename = "organ.stl"
# Create a reader
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(reader.GetOutput())
else:
mapper.SetInputConnection(reader.GetOutputPort())
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.RotateX(-90)
self.ren.AddActor(actor)
def __init__(self, renderers, isRightHand):
'''
Initialize the user model.
'''
# Call the parent constructor
super(Hand,self).__init__(renderers)
filename = "../scene/media/rhand.stl"
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
# Do the internal transforms to make it look along unit-z, do it with a quick transform
trans = vtk.vtkTransform()
trans.RotateZ(180)
if isRightHand == False: #Flip with a horizontal flip using a -1 scale
trans.Scale([-1, 1, 1])
transF = vtk.vtkTransformPolyDataFilter()
transF.SetInputConnection(reader.GetOutputPort())
transF.SetTransform(trans)
self.__mapper = vtk.vtkPolyDataMapper()
#if vtk.VTK_MAJOR_VERSION <= 5:
# self.__mapper.SetInput(reader.GetOutput())
#else:
self.__mapper.SetInputConnection(transF.GetOutputPort())
self.vtkActor.SetMapper(self.__mapper)
def __init__(self,InputImageFileName ):
print " class constructor called \n\n"
# damage paramters
# open stl and extract VOI for a reference
stlReader = vtk.vtkSTLReader()
stlReader.SetFileName( InputImageFileName )
stlReader.Update()
self.stlData = stlReader.GetOutput()
stlpoints = self.stlData.GetPoints()
# VOI Origin should be at the lower bound
VOIBounds = self.stlData.GetBounds()
self.origin = (VOIBounds[0]-1.,VOIBounds[2]-1.,VOIBounds[4]-1.)
self.dimensions = (256,256,100,1)
self.spacing = ((VOIBounds[1]+1. - self.origin[0])/self.dimensions[0],
(VOIBounds[3]+1. - self.origin[1])/self.dimensions[1],
(VOIBounds[5]+1. - self.origin[2])/self.dimensions[2])
numpyimagesize = self.dimensions[0]*self.dimensions[1]*self.dimensions[2]
# store as double precision
self.ImageFile = numpy.zeros( numpyimagesize, dtype=numpy.float32 )
for ipoint in range(stlpoints.GetNumberOfPoints() ):
CurrentPoint = stlpoints.GetPoint(ipoint)
XIndex = int( ( CurrentPoint[0]-self.origin[0])/ self.spacing[0] )
YIndex = int( ( CurrentPoint[1]-self.origin[1])/ self.spacing[1] )
ZIndex = int( ( CurrentPoint[2]-self.origin[2])/ self.spacing[2] )
CurrentIndex = XIndex \
+ YIndex * self.dimensions[0] \
+ ZIndex * self.dimensions[0] * self.dimensions[1]
self.ImageFile[CurrentIndex ] = 1.
def LoadMesh(filename):
""" Reads mesh from file """
# Check if file exists
if not os.path.isfile(filename):
raise Exception('File {:s} does not exist!'.format(filename))
# Get extension
fext = filename[-3:].lower()
# Select reader
if fext == 'ply':
reader = vtk.vtkPLYReader()
elif fext == 'stl':
reader = vtk.vtkSTLReader()
elif fext == 'vtk':
reader = vtk.vtkXMLPolyDataReader()
else:
raise Exception('Can only import *.ply, *.stl, or *.vtk files!')
# Load file
reader.SetFileName(filename)
reader.Update()
return reader.GetOutput()
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(self):
self.reader = vtk.vtkSTLReader()
self.reader.SetFileName(str(self.filename))
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInputConnection(self.reader.GetOutputPort())
#create model actor
self.actor = vtk.vtkActor()
self.actor.GetProperty().SetColor(1, 1, 1)
self.actor.GetProperty().SetOpacity(1)
self.actor.SetMapper(self.mapper)
#create outline mapper
self.outline = vtk.vtkOutlineFilter()
self.outline.SetInputConnection(self.reader.GetOutputPort())
self.outlineMapper = vtk.vtkPolyDataMapper()
self.outlineMapper.SetInputConnection(self.outline.GetOutputPort())
#create outline actor
self.outlineActor = vtk.vtkActor()
self.outlineActor.SetMapper(self.outlineMapper)
#add actors to parent render window
self.parent.ren.AddActor(self.actor)
self.parent.ren.AddActor(self.outlineActor)
def attach_stl(self, fname, scale=None):
"""Load a given STL file into a vtkPolyData object"""
reader = vtk.vtkSTLReader()
reader.SetFileName(fname)
reader.Update() # polydata
if scale is not None:
trans = vtk.vtkTransform()
trans.Scale(scale)
filt = vtk.vtkTransformFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
filt.SetInputConnection(reader.GetOutputPort)
else:
filt.SetInputConnection(reader.GetOutputPort())
filt.SetTransform(trans)
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(filt.GetOutput())
else:
mapper.SetInputConnection(filt.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self._ren.AddActor(actor)
def _read_polydata(self):
"""
This private method reads the given `filename` and return a vtkPolyData
object containing all informations about file; to avoid useless IO
operation on the same file, it stores polydata of the last file parsed
and if user ask for this file, the polydata previously stored is
returned.
:return: data: polydata containing information about file.
:rtype: vtkPolyData
"""
# Polydata from `filename` is allready loaded; return it
if self._cached_data is not None:
return self._cached_polydata
if not os.path.isfile(self._filename):
raise RuntimeError("{0!s} doesn't exist".format(
os.path.abspath(self._filename)))
reader = vtk.vtkSTLReader()
reader.SetFileName(self._filename)
reader.Update()
data = reader.GetOutput()
self._cached_data = data
return data
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 readMeshFile(filename, verbose=False):
"""Read mesh file.
The input format is determined by file name extension. Degenerate data gets
removed and polygons get split into triangles to support varios restrictive
output formats."""
informat = path.splitext(options.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=='tag':
# reader = vtk.vtkMNITagPointReader()
else:
raise ValueError('cannot read input format' + informat)
reader.SetFileName(filename)
# merge duplicate points, and/or remove unused points and/or remove degenerate cells
clean = vtk.vtkCleanPolyData()
clean.SetInputConnection(reader.GetOutputPort())
# convert input polygons and strips to triangles
triangles = vtk.vtkTriangleFilter()
triangles.SetInputConnection(clean.GetOutputPort())
#triangles = reader.GetOutputPort() # skipping above 'cleaning' doesn't work
if verbose:
print "read", filename
return triangles
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkSTLReader(), 'Reading vtkSTL.',
(), ('vtkSTL',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def attach_stl(self, fname, scale=None):
"""Load a given STL file into a vtkPolyData object"""
reader = vtk.vtkSTLReader()
reader.SetFileName(fname)
reader.Update() # polydata
if scale is not None:
trans = vtk.vtkTransform()
trans.Scale(scale)
filt = vtk.vtkTransformFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
filt.SetInputConnection(reader.GetOutputPort)
else:
filt.SetInputConnection(reader.GetOutputPort())
filt.SetTransform(trans)
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(filt.GetOutput())
else:
mapper.SetInputConnection(filt.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self._ren.AddActor(actor)
def Decimate_mesh(meshvtk,name_vtkmesh,nvertices=2000):
print 'test'
stlWriter = vtk.vtkSTLWriter()
stlWriter.SetFileName('meshdecimated.stl')
stlWriter.SetInputData(meshvtk)
stlWriter.Write()
mesh_om = om.PolyMesh()
Result=om.read_mesh(mesh_om, "meshdecimated.stl")
print Result
deci_om=om.PolyMeshDecimater(mesh_om)
mh=om.PolyMeshModQuadricHandle()
deci_om.add(mh)
deci_om.initialize()
deci_om.decimate_to(nvertices)
mesh_om.garbage_collection()
assert mesh_om.n_vertices()==nvertices, 'vertices goal not acomplished; nvertices={0:d}'.format(mesh_om.n_vertices())
print "Decimation to {0} vertices Sucessful".format(nvertices)
om.write_mesh(mesh_om,'meshdecimated.stl')
stlReader = vtk.vtkSTLReader()
stlReader.SetFileName('meshdecimated.stl')
stlReader.Update()
vtkwrite=vtk.vtkPolyDataWriter()
vtkwrite.SetInputData(stlReader.GetOutput())
vtkwrite.SetFileName(name_vtkmesh)
vtkwrite.Write()
print "enters"
def __init__(self, filename, parent=None):
QtWidgets.QMainWindow.__init__(self, parent)
self.setupUi(self)
self.vl = QtWidgets.QVBoxLayout()
self.vtkWidget = QVTKRenderWindowInteractor(self.frame)
self.vl.addWidget(self.vtkWidget)
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(reader.GetOutput())
else:
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
self.ren.AddActor(actor)
self.ren.ResetCamera()
self.frame.setLayout(self.vl)
self.setCentralWidget(self.frame)
self.show()
self.iren.Initialize()
self.iren.Start()
def _read_polydata(self):
"""
This private method reads the given `filename` and return a vtkPolyData
object containing all informations about file; to avoid useless IO
operation on the same file, it stores polydata of the last file parsed
and if user ask for this file, the polydata previously stored is
returned.
:return: polydata containing information about file.
:rtype: vtkPolyData
"""
# Polydata from `filename` is already loaded; return it
if self._cached_data is not None:
return self._cached_polydata
if not os.path.isfile(self._filename):
raise RuntimeError("{0!s} doesn't exist".format(
os.path.abspath(self._filename)))
reader = vtk.vtkSTLReader()
reader.SetFileName(self._filename)
reader.Update()
data = reader.GetOutput()
self._cached_data = data
return data
def __init__(self):
"""Setup the pipeline.
"""
self.reader = vtkSTLReader()
self.cutter = vtkCutter()
self.cutter.SetInputConnection(self.reader.GetOutputPort())
self.regionPicker = vtkPolyDataConnectivityFilter()
self.regionPicker.SetInputConnection(self.cutter.GetOutputPort())
self.regionPicker.SetExtractionModeToClosestPointRegion()
self.scaler = vtkTransformPolyDataFilter()
self.scaler.SetInputConnection(self.regionPicker.GetOutputPort())
self.GetFileName = self.reader.GetFileName
self.SetFileName = self.reader.SetFileName
self.GetOutputPort = self.scaler.GetOutputPort
self.GetOutput = self.scaler.GetOutput
self.Update = self.scaler.Update
self.iolet = None
self.fileUnitLength = None
return
def read_file(cls, filename, mat=None):
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
base_name = os.path.basename(filename)
name, extension = os.path.splitext(base_name)
surf = cls(name, reader, mat)
return surf
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 SetObjective(self, ApplicatorObjetiveInOpticalCoordinates):
if self.calibrated:
# Save the Transformation Goal
self.ApplicatorObjetiveAxis = ApplicatorObjetiveInOpticalCoordinates.copy()
self.ApplicatorObjetiveAxis = numpy.dot(self.TWorldToOptical,self.ApplicatorObjetiveAxis)
self.ApplicatorObjetive = vtk.vtkTransform()
self.ApplicatorObjetive.SetMatrix([self.ApplicatorObjetiveAxis[0,0],self.ApplicatorObjetiveAxis[0,1],self.ApplicatorObjetiveAxis[0,2],self.ApplicatorObjetiveAxis[0,3],
self.ApplicatorObjetiveAxis[1,0],self.ApplicatorObjetiveAxis[1,1],self.ApplicatorObjetiveAxis[1,2],self.ApplicatorObjetiveAxis[1,3],
self.ApplicatorObjetiveAxis[2,0],self.ApplicatorObjetiveAxis[2,1],self.ApplicatorObjetiveAxis[2,2],self.ApplicatorObjetiveAxis[2,3],
self.ApplicatorObjetiveAxis[3,0],self.ApplicatorObjetiveAxis[3,1],self.ApplicatorObjetiveAxis[3,2],self.ApplicatorObjetiveAxis[3,3]])
self.ApplicatorObjetiveaxes = vtk.vtkAxesActor()
self.ApplicatorObjetiveaxes.SetUserTransform(self.ApplicatorObjetive)
self.ApplicatorObjetiveaxes.SetXAxisLabelText('X App')
self.ApplicatorObjetiveaxes.SetYAxisLabelText('Y App')
self.ApplicatorObjetiveaxes.SetZAxisLabelText('Z App')
self.ApplicatorObjetiveaxes.SetTotalLength(0.2,0.2,0.2)
self.STLReaderApplicator = vtk.vtkSTLReader()
self.STLReaderApplicator.SetFileName(self.pathToModelApplicator)
self.STLReaderApplicator.Update()
self.mapperApplicator = vtk.vtkPolyDataMapper()
self.mapperApplicator.SetInputConnection(self.STLReaderApplicator.GetOutputPort())
self.modelActorApplicator = vtk.vtkActor()
self.modelActorApplicator.SetMapper(self.mapperApplicator)
self.modelActorApplicator.SetUserTransform(self.ApplicatorObjetive)
self.modelActorApplicator.GetProperty().SetColor(0,1,0)
self.modelActorApplicator.GetProperty().SetOpacity(0.5)
self.objetiveFixed = True
def addMeshFromFile(self, name, filename):
"""
Add a mesh shape from a file.
Accepted format : .stl or mesh encoded in VTK .vtp format
"""
if name not in self._ref:
if os.path.splitext(filename)[-1][1:] == 'stl':
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
reader.Update()
with tmpfile() as tmpf:
writer=vtk.vtkXMLPolyDataWriter()
writer.SetInputData(reader.GetOutput())
writer.SetFileName(tmpf[1])
writer.Write()
shape_data = str_of_file(tmpf[1])
else:
assert os.path.splitext(filename)[-1][1:] == 'vtp'
shape_data = str_of_file(filename)
self.addMeshShapeFromString(name, shape_data)
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 loadFromSTL(self, filebasename, z1, z2):
import vtk
reader = vtk.vtkSTLReader()
reader.SetFileName(filebasename + '.stl')
surfacePoly = vtk.vtkPolyData()
#if vtk.VTK_MAJOR_VERSION <= 5:
surfacePoly.SetInput(reader.GetOutput())
#else:
# surfacePoly.SetInputConnection(reader.GetOutputPort())
points = vtk.vtkPoints()
for x in range(1, self.NX + 1):
for y in range(1, self.NY + 1):
for z in range(z1, z2 + 1):
points.InsertNextPoint([x, y, z])
pointsPoly = vtk.vtkPolyData()
pointsPoly.SetPoints(points)
selectEnclosed = vtk.vtkSelectEnclosedPoints()
selectEnclosed.SetInputData(pointsPly)
selectEnclosed.SetSurfaceData(surfacePoly)
selectEnclosed.Update()
for i in points.GetNumberOfPoints():
if selectEnclosed.IsInside(n): self.__addnode(points.GetPoint(n))
def StlReader(StlModelFileName, import_mode = 'vtk'):
"""Function to read an stl file and returns it as a numpy array
Args:
stl_file_path
import_mode (so far only vtk)
"""
if import_mode == 'vtk':
# Load stl file
readerSTL = vtk.vtkSTLReader()
readerSTL.SetFileName(StlModelFileName)
# 'update' the reader i.e. read the .stl file
readerSTL.Update()
polydata = readerSTL.GetOutput()
# If there are no points in 'vtkPolyData' something went wrong
if polydata.GetNumberOfPoints() == 0:
raise ValueError(
"No point data could be loaded from '" + filenameSTL)
return None
return polydata
def view(stlfilename):
reader = vtk.vtkSTLReader()
reader.SetFileName(stlfilename)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Create a rendering window and renderer
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
# Create a renderwindowinteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Assign actor to the renderer
ren.AddActor(actor)
# Enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
def readSTL(filename):
''' Returns a VTK Reader instance for the file type. '''
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
reader.Update()
return reader
def readMeshFile(filename, verbose=False):
"""Read mesh file.
The input format is determined by file name extension. Degenerate data gets
removed and polygons get split into triangles to support varios restrictive
output formats."""
informat = path.splitext(options.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=='tag':
# reader = vtk.vtkMNITagPointReader()
else:
raise ValueError('cannot read input format' + informat)
reader.SetFileName(filename)
# merge duplicate points, and/or remove unused points and/or remove degenerate cells
clean = vtk.vtkCleanPolyData()
clean.SetInputConnection(reader.GetOutputPort())
# convert input polygons and strips to triangles
triangles = vtk.vtkTriangleFilter()
triangles.SetInputConnection(clean.GetOutputPort())
#triangles = reader.GetOutputPort() # skipping above 'cleaning' doesn't work
if verbose:
print "read", filename
return triangles
def createAutoThumb(filename, path):
colors = vtk.vtkNamedColors()
# Set the background color.
colors.SetColor("BkgColor", [26, 51, 102, 255])
# create a rendering window and renderer
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.OffScreenRenderingOn()
# create source
reader = vtk.vtkSTLReader()
reader.SetFileName(path)
# mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
# actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# color the actor
actor.GetProperty().SetColor(colors.GetColor3d("Grey"))
# assign actor to the renderer
ren.AddActor(actor)
ren.SetBackground(colors.GetColor3d("BkgColor"))
renWin.Render()
WriteImage(filename + ".jpg", renWin, rgba=False)
def parse(self, filename):
"""
Method to parse the `filename`. It returns a matrix with all the
coordinates.
:param string filename: name of the input file.
:return: mesh_points: it is a `n_points`-by-3 matrix containing the
coordinates of the points of the mesh
:rtype: numpy.ndarray
"""
self._check_filename_type(filename)
self._check_extension(filename)
self.infile = filename
reader = vtk.vtkSTLReader()
reader.SetFileName(self.infile)
reader.Update()
data = reader.GetOutput()
n_points = data.GetNumberOfPoints()
mesh_points = np.zeros([n_points, 3])
for i in range(n_points):
mesh_points[i][0], mesh_points[i][1], mesh_points[i][
2] = data.GetPoint(i)
return mesh_points
def stltoh5(stlfile, basepath, epsilon_inside, epsilon_outside, lattice=Lattice(), verbosity=0):
if not os.path.exists(stlfile):
if sys.version_info.major == 2:
raise IOError('No such file or directory: {}'.format(stlfile)) # py2
else:
raise FileNotFoundError('No such file or directory: {}'.format(stlfile)) # py3
print('--> timer start')
time_start = time.time()
# read in .stl file
reader = vtk.vtkSTLReader()
reader.SetFileName(stlfile)
reader.Update()
polydata = reader.GetOutput()
# write .vtp file
writer = vtk.vtkXMLPolyDataWriter()
writer.SetInputData(polydata)
writer.SetFileName(basepath + '.' + writer.GetDefaultFileExtension())
writer.Write()
# set up implicit_function
implicit_function = vtk.vtkImplicitPolyDataDistance()
implicit_function.SetInput(polydata)
print("--> Elapsed time: %.4f sec" % (time.time() - time_start))
stl_to_vts_and_h5(implicit_function, basepath, lattice, epsilon_inside, epsilon_outside)
print("--> Elapsed time: %.4f sec" % (time.time() - time_start))
return
def readSTL(self, *args):
reader = vtk.vtkSTLReader()
reader.SetFileName(os.path.join(self.directory, args[0]))
reader.Update()
return reader
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 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 view(stlfilename):
reader = vtk.vtkSTLReader()
reader.SetFileName(stlfilename)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Create a rendering window and renderer
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
# Create a renderwindowinteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Assign actor to the renderer
ren.AddActor(actor)
# Enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
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.vtkSTLReader()
# ctor for this specific mixin
FilenameViewModuleMixin.__init__(
self, 'Select a filename',
'STL data (*.stl)|*.stl|All files (*)|*',
{'vtkSTLReader': self._reader})
module_utils.setup_vtk_object_progress(self, self._reader,
'Reading STL data')
# set up some defaults
self._config.filename = ''
self.sync_module_logic_with_config()
def STLMESH(filename="sample.stl"):
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
reader.Update()
data = reader.GetOutput()
bounds = data.GetBounds()
minPoint = Vector3(bounds[0] + RMAX, bounds[2] + RMAX, bounds[4] + RMAX)
maxPoint = Vector3(bounds[1] - RMAX, bounds[3] - RMAX, bounds[5] - RMAX)
NUMBER_OF_BOUNDARIES = data.GetNumberOfCells()
NUMBER_OF_BOUNDARIES_POINTS = data.GetNumberOfPoints()
pyramidTris = TriPatchSet()
for i in range(0, NUMBER_OF_BOUNDARIES):
cell = data.GetCell(i)
p1_id = cell.GetPointId(0)
p2_id = cell.GetPointId(1)
p3_id = cell.GetPointId(2)
vpoint1 = data.GetPoint(p1_id)
vpoint2 = data.GetPoint(p2_id)
vpoint3 = data.GetPoint(p3_id)
p0 = Vector3(vpoint1[0], vpoint1[1], vpoint1[2])
p1 = Vector3(vpoint2[0], vpoint2[1], vpoint2[2])
p2 = Vector3(vpoint3[0], vpoint3[1], vpoint3[2])
pyramidTris.addTriangle(p0, p1, p2, 2)
pyramid = MeshVolume(Mesh=pyramidTris)
return (pyramid, minPoint, maxPoint)
def parse(self, filename):
"""
Method to parse the `filename`. It returns a matrix with all the
coordinates.
:param string filename: name of the input file.
:return: mesh_points: it is a `n_points`-by-3 matrix containing the
coordinates of the points of the mesh
:rtype: numpy.ndarray
"""
self._check_filename_type(filename)
self._check_extension(filename)
self.infile = filename
reader = vtk.vtkSTLReader()
reader.SetFileName(self.infile)
reader.Update()
data = reader.GetOutput()
n_points = data.GetNumberOfPoints()
mesh_points = np.zeros([n_points, 3])
for i in range(n_points):
mesh_points[i][0], mesh_points[i][1], mesh_points[i][
2] = data.GetPoint(i)
return mesh_points
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 __init__(self):
"""Setup the pipeline.
"""
self.reader = vtkSTLReader()
self.cutter = vtkCutter()
self.cutter.SetInputConnection(self.reader.GetOutputPort())
self.regionPicker = vtkPolyDataConnectivityFilter()
self.regionPicker.SetInputConnection(self.cutter.GetOutputPort())
self.regionPicker.SetExtractionModeToClosestPointRegion()
self.scaler = vtkTransformPolyDataFilter()
self.scaler.SetInputConnection(self.regionPicker.GetOutputPort())
self.GetFileName = self.reader.GetFileName
self.SetFileName = self.reader.SetFileName
self.GetOutputPort = self.scaler.GetOutputPort
self.GetOutput = self.scaler.GetOutput
self.Update = self.scaler.Update
self.iolet = None
self.fileUnitLength = None
return
def __init__(self, renderers, name):
'''
Initialize the bot model.
'''
# Call the parent constructor
super(RoverBot,self).__init__(renderers)
filename = "../scene/media/rover.stl"
self.__name = name
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
# Do the internal transforms to make it look along unit-z, do it with a quick transform
trans = vtk.vtkTransform()
trans.Scale(0.05, 0.05, 0.05)
trans.RotateX(-90)
transF = vtk.vtkTransformPolyDataFilter()
transF.SetInputConnection(reader.GetOutputPort())
transF.SetTransform(trans)
self.__mapper = vtk.vtkPolyDataMapper()
#if vtk.VTK_MAJOR_VERSION <= 5:
# self.__mapper.SetInput(reader.GetOutput())
#else:
self.__mapper.SetInputConnection(transF.GetOutputPort())
self.vtkActor.SetMapper(self.__mapper)
# Set up all the children for this model
self.__setupChildren(renderers)
# Set it to [0,0,0] so that it updates all the children
self.SetSceneObjectPosition([0, 0, 0])
def ReadSTLSurfaceFile(self):
if (self.InputFileName == ''):
self.PrintError('Error: no InputFileName.')
self.PrintLog('Reading STL surface file.')
reader = vtk.vtkSTLReader()
reader.SetFileName(self.InputFileName)
reader.Update()
self.Surface = reader.GetOutput()
def loadStl(fname):
"""Load the given STL file, and return a vtkPolyData object for it."""
reader = vtk.vtkSTLReader()
reader.SetFileName(fname)
reader.Update()
polydata = reader.GetOutput()
return polydata
def load_file(filename):
if filename.endswith('.ply'):
reader = vtk.vtkPLYReader()
else:
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
reader.Update()
return reader.GetOutput()
def _readstls(self):
"""
Reads in all STL files contained in directories indicated by **ref_dir** and **def_dir**.
Also calls **_make3Dmesh()** to create 3-D tetrahedral meshes.
Returns
-------
rsurfs, dsurfs
"""
for fname in sorted(os.listdir(self._ref_dir)):
if '.stl' in fname.lower():
reader = vtk.vtkSTLReader()
reader.SetFileName(
str(os.path.normpath(self._ref_dir + os.sep + fname)))
reader.Update()
triangles = vtk.vtkTriangleFilter()
triangles.SetInputConnection(reader.GetOutputPort())
triangles.Update()
self.rsurfs.append(triangles.GetOutput())
massProps = vtk.vtkMassProperties()
massProps.SetInputData(self.rsurfs[-1])
massProps.Update()
print(("Generating tetrahedral mesh from {:s}".format(fname)))
self._make3Dmesh(
str(os.path.normpath(self._ref_dir + os.sep + fname)),
'MATERIAL', massProps.GetVolume())
for fname in sorted(os.listdir(self._def_dir)):
if '.stl' in fname.lower():
reader = vtk.vtkSTLReader()
reader.SetFileName(
str(os.path.normpath(self._def_dir + os.sep + fname)))
reader.Update()
triangles = vtk.vtkTriangleFilter()
triangles.SetInputConnection(reader.GetOutputPort())
triangles.Update()
self.dsurfs.append(triangles.GetOutput())
massProps = vtk.vtkMassProperties()
massProps.SetInputData(self.dsurfs[-1])
massProps.Update()
print(("Generating tetrahedral mesh from {:s}".format(fname)))
self._make3Dmesh(
str(os.path.normpath(self._def_dir + os.sep + fname)),
'SPATIAL', massProps.GetVolume())
def CentreLinePolyData(self):
"""Compute centrelines based on the profile, reusing our
memoed copy or reading from the cache file if possible.
"""
if (os.path.exists(self.CentreLineFile ) and
os.path.getmtime(self.CentreLineFile ) > os.path.getmtime(self.StlFile) and
os.path.getmtime(self.CentreLineFile ) > os.path.getmtime(self.FileName)):
# Cached!
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(self.CentreLineFile)
reader.Update()
return reader.GetOutput()
# Have to compute it
# Read the STL file
reader = vtk.vtkSTLReader()
reader.SetFileName(profile.StlFile)
# Find the seed points for centreline calculation
# Use points one iolet radius back along the normal.
outletPts = []
def scale(iolet):
pt = (iolet.Centre - iolet.Radius * iolet.Normal)
pt = pt / self.LengthUnit
return pt.magnitude
for iolet in self.Iolets:
if isinstance(iolet._iolet, Inlet):
inletPt = scale(iolet)
else:
outletPts.append(scale(iolet))
pass
continue
srcPts, tgtPts = FindSeeds(reader, inletPt, outletPts)
# Lazy import since it's so slow!
from vmtk import vtkvmtk
centreliner = vtkvmtk.vtkvmtkPolyDataCenterlines()
centreliner.SetInputConnection(reader.GetOutputPort())
centreliner.SetSourceSeedIds(srcPts)
centreliner.SetTargetSeedIds(tgtPts)
centreliner.SetRadiusArrayName("radius")
centreliner.SetCostFunction("1/R")
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(centreliner.GetOutputPort())
writer = vtk.vtkXMLPolyDataWriter()
writer.SetInputConnection(cleaner.GetOutputPort())
writer.SetFileName(self.CentreLineFile)
writer.Write()
return cleaner.GetOutput()
def create_actor_from_stl(path):
assert os.path.exists(path)
reader = vtk.vtkSTLReader()
reader.SetFileName(path)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
return actor
def read_normals(mesh_file):
stl = vtk.vtkSTLReader()
stl.SetFileName(mesh_file)
stl.Update()
normals = vtk.vtkPolyDataNormals()
normals.SetInput(stl.GetOutput())
normals.Update()
output = normals.GetOutput()
a_normals = vn.vtk_to_numpy(output.GetPointData().GetArray("Normals"))
return a_normals / np.linalg.norm(a_normals)
def getPartActor(self,fileName):
reader = vtk.vtkSTLReader()
reader.SetFileName(fileName)
polyDataOutput = reader.GetOutput()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
return actor
