def OBJtoVTP(self, objPath, mtlPath, texPath):
importer = vtk.vtkOBJImporter()
importer.SetFileName(objPath)
importer.SetFileNameMTL(mtlPath)
importer.SetTexturePath(texPath)
importer.Update()
exporter = vtk.vtkSingleVTPExporter()
exporter.SetRenderWindow(importer.GetRenderWindow())
# exporter.SetFilePrefix(slicer.app.temporaryPath + os.path.splitext(os.path.basename(objPath))[0])
exporter.SetFilePrefix(slicer.app.temporaryPath + os.path.sep +
"multi-texture-temp")
print(slicer.app.temporaryPath + os.path.sep + "multi-texture-temp")
exporter.Write()
# modelNode = slicer.util.loadModel(slicer.app.temporaryPath + os.path.splitext(os.path.basename(objPath))[0] + ".vtp")
modelNode = slicer.util.loadModel(slicer.app.temporaryPath +
os.path.sep +
"multi-texture-temp.vtp")
# textureImageNode = slicer.util.loadVolume(slicer.app.temporaryPath + os.path.splitext(os.path.basename(objPath))[0] + ".png", {'singleFile': True})
textureImageNode = slicer.util.loadVolume(
slicer.app.temporaryPath + os.path.sep + "multi-texture-temp.png",
{'singleFile': True})
return modelNode, textureImageNode
def main():
filename_obj, filename_mtl, texturepath = get_program_parameters()
importer = vtk.vtkOBJImporter()
importer.SetFileName(filename_obj)
importer.SetFileNameMTL(filename_mtl)
importer.SetTexturePath(texturepath)
colors = vtk.vtkNamedColors()
renderer = vtk.vtkRenderer()
render_window = vtk.vtkRenderWindow()
render_window_interactor = vtk.vtkRenderWindowInteractor()
renderer.SetBackground2(colors.GetColor3d("Silver"))
renderer.SetBackground(colors.GetColor3d("Gold"))
renderer.GradientBackgroundOn()
render_window.AddRenderer(renderer)
renderer.UseHiddenLineRemovalOn()
render_window.AddRenderer(renderer)
render_window.SetSize(640, 480)
render_window_interactor.SetRenderWindow(render_window)
importer.SetRenderWindow(render_window)
importer.Update()
actors = vtk.vtkActorCollection()
actors = renderer.GetActors()
actors.InitTraversal()
print("There are", actors.GetNumberOfItems(), "actors")
for a in range(0, actors.GetNumberOfItems()):
print(importer.GetOutputDescription(a))
actor = actors.GetNextActor()
# OBJImporter turns texture interpolation off
if actor.GetTexture():
print("Hastexture\n")
actor.GetTexture().InterpolateOn()
pd = actor.GetMapper().GetInput()
clean = vtk.vtkCleanPolyData()
clean.SetInputData(pd)
clean.Update()
normals = vtk.vtkPolyDataNormals()
normals.SetInputData(pd)
normals.SplittingOff()
normals.ConsistencyOn()
normals.Update()
mapper = actor.GetMapper()
mapper.SetInputData(normals.GetOutput())
mapper.SetInputData(pd)
render_window.Render()
render_window_interactor.Start()
def ReadSurf(fileName):
print("Reading:", fileName)
fname, extension = os.path.splitext(fileName)
extension = extension.lower()
if extension == ".vtk":
reader = vtk.vtkPolyDataReader()
reader.SetFileName(fileName)
reader.Update()
surf = reader.GetOutput()
elif extension == ".stl":
reader = vtk.vtkSTLReader()
reader.SetFileName(fileName)
reader.Update()
surf = reader.GetOutput()
elif extension == ".off":
reader = OFFReader()
reader.SetFileName(fileName)
reader.Update()
surf = reader.GetOutput()
elif extension == ".obj":
if os.path.exists(fname + ".mtl"):
obj_import = vtk.vtkOBJImporter()
obj_import.SetFileName(fileName)
obj_import.SetFileNameMTL(fname + ".mtl")
textures_path = os.path.normpath(
os.path.dirname(fname) + "/../images")
if os.path.exists(textures_path):
obj_import.SetTexturePath(textures_path)
obj_import.Read()
actors = obj_import.GetRenderer().GetActors()
actors.InitTraversal()
append = vtk.vtkAppendPolyData()
for i in range(actors.GetNumberOfItems()):
surfActor = actors.GetNextActor()
append.AddInputData(surfActor.GetMapper().GetInputAsDataSet())
append.Update()
surf = append.GetOutput()
else:
reader = vtk.vtkOBJReader()
reader.SetFileName(fileName)
reader.Update()
surf = reader.GetOutput()
return surf
def importOBJModel(file, texturepath=None):
importer = vtk.vtkOBJImporter()
importer.SetFileName(file)
if texturepath:
path, _ = os.path.split(texturepath)
importer.SetFileNameMTL(texturepath)
importer.SetTexturePath(path)
ren = vtk.vtkRenderer()
renwin = vtk.vtkRenderWindow()
renwin.AddRenderer(ren)
importer.SetRenderWindow(renwin)
importer.Update()
return ren
def importWindow(fileinput, mtlFile=None, texturePath=None):
"""Import a whole scene from a Numpy or OBJ wavefront file.
Return ``Plotter`` instance.
:param str mtlFile: MTL file for OBJ wavefront files.
:param str texturePath: path of the texture files directory.
"""
from vtkplotter import Plotter
if '.npy' in fileinput:
data = np.load(fileinput, allow_pickle=True, encoding="latin1").flatten()[0]
if 'renderPointsAsSpheres' in data.keys():
settings.renderPointsAsSpheres = data['renderPointsAsSpheres']
if 'renderLinesAsTubes' in data.keys():
settings.renderLinesAsTubes = data['renderLinesAsTubes']
if 'hiddenLineRemoval' in data.keys():
settings.hiddenLineRemoval = data['hiddenLineRemoval']
if 'visibleGridEdges' in data.keys():
settings.visibleGridEdges = data['visibleGridEdges']
if 'interactorStyle' in data.keys():
settings.interactorStyle = data['interactorStyle']
if 'useParallelProjection' in data.keys():
settings.useParallelProjection = data['useParallelProjection']
axes = data.pop('axes', 4)
title = data.pop('title', '')
backgrcol = data.pop('backgrcol', "blackboard")
vp = Plotter(size=data['size'], # not necessarily a good idea to set it
#shape=data['shape'],
axes=axes,
title=title,
bg=backgrcol,
)
vp.xtitle = data.pop('xtitle', 'x')
vp.ytitle = data.pop('ytitle', 'y')
vp.ztitle = data.pop('ztitle', 'z')
#print(data.keys())
# print(data['objects'])
# exit()
if 'objects' in data.keys():
objs = loadNumpy(data['objects'])
if not utils.isSequence(objs):
objs = [objs]
else:
colors.printc("Trying to import a that was not exported.", c=1)
colors.printc(" -> try to load a single object with load().", c=1)
return loadNumpy(fileinput)
vp.actors = objs
# if vp.shape==(1,1):
# vp.actors = loadNumpy(data['objects'])
# else:
# print(objs, )
# for a in objs:
# for ar in a.renderedAt:
# print(vp.shape, [a], ar )
# vp.show(a, at=ar)
return vp
elif '.obj' in fileinput.lower():
vp = Plotter()
importer = vtk.vtkOBJImporter()
importer.SetFileName(fileinput)
if mtlFile is not False:
if mtlFile is None:
mtlFile = fileinput.replace('.obj', '.mtl').replace('.OBJ', '.MTL')
importer.SetFileNameMTL(mtlFile)
if texturePath is not False:
if texturePath is None:
texturePath = fileinput.replace('.obj', '.txt').replace('.OBJ', '.TXT')
importer.SetTexturePath(texturePath)
importer.SetRenderWindow(vp.window)
importer.Update()
actors = vp.renderer.GetActors()
actors.InitTraversal()
for i in range(actors.GetNumberOfItems()):
vactor = actors.GetNextActor()
act = Mesh(vactor)
act_tu = vactor.GetTexture()
if act_tu:
act_tu.InterpolateOn()
act.texture(act_tu)
vp.actors.append( act )
return vp
def render_3d_obj_rgb(self, transform_stack, file_name):
write_image_files = self.config['process_3d']['write_renderings']
off_screen_rendering = self.config['process_3d'][
'off_screen_rendering']
n_views = self.config['data_loader']['args']['n_views']
img_size = self.config['data_loader']['args']['image_size']
win_size = img_size
n_channels = 3
image_stack = np.zeros((n_views, win_size, win_size, n_channels),
dtype=np.float32)
mtl_name = os.path.splitext(file_name)[0] + '.mtl'
obj_dir = os.path.dirname(file_name)
obj_in = vtk.vtkOBJImporter()
obj_in.SetFileName(file_name)
obj_in.SetFileNameMTL(mtl_name)
obj_in.SetTexturePath(obj_dir)
obj_in.Update()
# Initialize Camera
ren = vtk.vtkRenderer()
ren.SetBackground(1, 1, 1)
ren.GetActiveCamera().SetPosition(0, 0, 1)
ren.GetActiveCamera().SetFocalPoint(0, 0, 0)
ren.GetActiveCamera().SetViewUp(0, 1, 0)
ren.GetActiveCamera().SetParallelProjection(1)
# Initialize RenderWindow
ren_win = vtk.vtkRenderWindow()
ren_win.AddRenderer(ren)
ren_win.SetSize(win_size, win_size)
ren_win.SetOffScreenRendering(off_screen_rendering)
obj_in.SetRenderWindow(ren_win)
obj_in.Update()
props = vtk.vtkProperty()
props.SetDiffuse(0)
props.SetSpecular(0)
props.SetAmbient(1)
actors = ren.GetActors()
actors.InitTraversal()
actor = actors.GetNextItem()
while actor:
actor.SetProperty(props)
actor = actors.GetNextItem()
del props
t_pre_trans = self.compute_pre_transformation(file_name)
t = vtk.vtkTransform()
t.Identity()
t.Update()
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(ren_win)
writer_png = vtk.vtkPNGWriter()
writer_png.SetInputConnection(w2if.GetOutputPort())
start = time.time()
# for idx in tqdm(range(n_views)):
for idx in range(n_views):
name_rendering = self.config.temp_dir / ('rendering' + str(idx) +
'_RGB.png')
rx, ry, rz, s, tx, ty = transform_stack[idx]
# rx,ry,rz,s,tx,ty = no_transform() # debug
# rx = -20
# ry = 40
# rz = 10
t.Identity()
t.RotateY(ry)
t.RotateX(rx)
t.RotateZ(rz)
t.Concatenate(t_pre_trans)
t.Update()
xmin = -150
xmax = 150
ymin = -150
ymax = 150
xlen = xmax - xmin
ylen = ymax - ymin
cx = 0
cy = 0
# extend_factor = 1.0
s = self.config['pre-align']['scale']
extend_factor = 1.0 / s
# The side length of the view frustrum which is rectangular since we use a parallel projection
side_length = max([xlen, ylen]) * extend_factor
# zoom_factor = win_size / side_length
ren.GetActiveCamera().SetParallelScale(side_length / 2)
ren.GetActiveCamera().SetPosition(cx, cy, 500)
ren.GetActiveCamera().SetFocalPoint(cx, cy, 0)
ren.GetActiveCamera().SetViewUp(0, 1, 0)
ren.GetActiveCamera().ApplyTransform(t.GetInverse())
ren.ResetCameraClippingRange(
) # This approach is not recommended when doing depth rendering
ren_win.Render()
if write_image_files:
w2if.Modified(
) # Needed here else only first rendering is put to file
writer_png.SetFileName(str(name_rendering))
writer_png.Write()
else:
w2if.Modified(
) # Needed here else only first rendering is put to file
w2if.Update()
# add rendering to image stack
im = w2if.GetOutput()
rows, cols, _ = im.GetDimensions()
sc = im.GetPointData().GetScalars()
a = vtk_to_numpy(sc)
components = sc.GetNumberOfComponents()
a = a.reshape(rows, cols, components)
a = np.flipud(a)
image_stack[idx, :, :, :] = a[:, :, :]
end = time.time()
print("Pure RGB rendering time: " + str(end - start))
del obj_in
del writer_png, w2if
del ren, ren_win, t
return image_stack
def visualise_mesh_and_landmarks(mesh_name, landmarks=None):
print(
'################### utils3d/ render3d/ visualise mesh and landmarks ################### \n'
)
file_type = os.path.splitext(mesh_name)[1]
win_size = 512
ren = vtk.vtkRenderer()
ren.SetBackground(1, 1, 1)
# Initialize RenderWindow
ren_win = vtk.vtkRenderWindow()
ren_win.AddRenderer(ren)
ren_win.SetSize(win_size, win_size)
file_read = False
if file_type == ".obj":
#print('############# if file type == .obj ############# \n')
mtl_name = os.path.splitext(mesh_name)[0] + '.mtl'
# only do this for textured files
if os.path.isfile(mtl_name):
obj_dir = os.path.dirname(mesh_name)
obj_in = vtk.vtkOBJImporter()
obj_in.SetFileName(mesh_name)
if os.path.isfile(mtl_name):
obj_in.SetFileNameMTL(mtl_name)
obj_in.SetTexturePath(obj_dir)
obj_in.Update()
obj_in.SetRenderWindow(ren_win)
obj_in.Update()
props = vtk.vtkProperty()
props.SetColor(1, 1, 1)
props.SetDiffuse(0)
props.SetSpecular(0)
props.SetAmbient(1)
actors = ren.GetActors()
actors.InitTraversal()
actor = actors.GetNextItem()
while actor:
actor.SetProperty(props)
actor = actors.GetNextItem()
del props
file_read = True
if not file_read and file_type in [
".vtk", ".stl", ".ply", ".wrl", ".obj"
]:
#print('############## if not file_read and file_type in ############################### \n ')
pd = Utils3D.multi_read_surface(mesh_name)
if pd.GetNumberOfPoints() < 1:
print('Could not read', mesh_name)
return None
texture_img = Utils3D.multi_read_texture(mesh_name)
if texture_img is not None:
#print('################ if texture_img is not None. Set 1 ##################### \n')
pd.GetPointData().SetScalars(None)
texture = vtk.vtkTexture()
texture.SetInterpolate(1)
texture.SetQualityTo32Bit()
texture.SetInputData(texture_img)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(pd)
actor_text = vtk.vtkActor()
actor_text.SetMapper(mapper)
if texture_img is not None:
#print('################ if texture_img is not None. Set 2 ##################### \n')
actor_text.SetTexture(texture)
actor_text.GetProperty().SetColor(1, 1, 1)
actor_text.GetProperty().SetAmbient(1.0)
actor_text.GetProperty().SetSpecular(0)
actor_text.GetProperty().SetDiffuse(0)
ren.AddActor(actor_text)
if landmarks is not None:
#print('########### if landmarks is not None ################ \n')
lm_pd = Render3D.get_landmarks_as_spheres(landmarks)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(lm_pd)
actor_lm = vtk.vtkActor()
actor_lm.SetMapper(mapper)
actor_lm.GetProperty().SetColor(0, 0, 1)
ren.AddActor(actor_lm)
# ren.GetActiveCamera().SetPosition(0, 0, 1)
# ren.GetActiveCamera().SetFocalPoint(0, 0, 0)
# ren.GetActiveCamera().SetViewUp(0, 1, 0)
# ren.GetActiveCamera().SetParallelProjection(1)
iren = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
iren.SetRenderWindow(ren_win)
print(
'############## ren_win.Render & iren.Start ####################### \n '
)
ren_win.Render()
iren.Start()
