def loadNewMesh(self, filename):
"""
Loads a new mesh and updates self.polydata.
:param filename: mesh to load
"""
# make sure file can be read
if (not vtk.vtkPLYReader().CanReadFile(filename)):
print("ERROR: cannot load " + filename)
return
reader = vtk.vtkPLYReader()
reader.SetFileName(filename)
reader.Update(
) # when this function is called from c++, reader.Update() causes:
# dSpaceX[24453:12650119] dynamic_cast error 1: Both of the following type_info's should have public visibility.
# At least one of them is hidden.
# NSt3__113basic_istreamIcNS_11char_traitsIcEEEE,
# NSt3__114basic_ifstreamIcNS_11char_traitsIcEEEE.
# Super verbose `python -vvv` doesn't produce this error, so something with pybind11? Ignoring for now.
self.polydata.SetPolys(reader.GetOutput().GetPolys())
self.polydata.SetPoints(reader.GetOutput().GetPoints())
# axis-aligned silouette views
if self.plotter.shape == (4, ):
# xz view
self.plotter.subplot(0)
self.plotter.add_mesh(self.polydata,
color=[0, 0, 0],
name="sample")
# xy view
self.plotter.subplot(1)
self.plotter.add_mesh(self.polydata,
color=[0, 0, 0],
name="sample")
# yz view
self.plotter.subplot(2)
self.plotter.add_mesh(self.polydata,
color=[0, 0, 0],
name="sample")
# isometric view
self.plotter.subplot(3)
# NOTE: since it uses smooth shading, it creates a copy of polydata, so
# mesh must be re-added when vertices are updated.
self.plotter.add_mesh(self.polydata,
color=self.color,
specular=0.5,
specular_power=15,
smooth_shading=True,
name="sample")
self.setCameraPos()
def ply2gltf(inname, outname):
reader = vtk.vtkPLYReader()
reader.SetFileName(inname)
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)
# Assign actor to the renderer
ren.AddActor(actor)
# Export the GLTF
writer = vtk.vtkGLTFExporter()
writer.SetFileName(outname)
writer.InlineDataOn()
writer.SetRenderWindow(renWin)
writer.Write()
def main():
colors = vtk.vtkNamedColors()
filename = get_program_parameters()
sphereSource = vtk.vtkSphereSource()
sphereSource.Update()
plyWriter = vtk.vtkPLYWriter()
plyWriter.SetFileName(filename)
plyWriter.SetInputConnection(sphereSource.GetOutputPort())
plyWriter.Write()
# Read and display for verification
reader = vtk.vtkPLYReader()
reader.SetFileName(filename)
reader.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d('cobalt_green'))
renderWindow.Render()
renderWindowInteractor.Start()
def 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 main():
input_file = sys.argv[1]
if input_file.lower().endswith(".stl"):
reader = vtk.vtkSTLReader()
elif input_file.lower().endswith(".ply"):
reader = vtk.vtkPLYReader()
else:
print("File must be STL or PLY")
sys.exit(0)
reader.SetFileName(input_file)
reader.Update()
polydata1 = reader.GetOutput()
polydata1 = fix_polydata(polydata1)
xi, xf, yi, yf, zi, zf = polydata1.GetBounds()
center = ((xf + xi) / 2.0, (yf + yi) / 2.0, (zf + zi) / 2.0)
diagonal_size = ((xf - xi) ** 2 + (yf - yi) ** 2.0 + (zf - zi) ** 2) ** 0.5
polydata2 = create_sphere(center, diagonal_size * 0.23)
polydata3 = apply_boolean_operation(polydata1, polydata2)
show_polydatas(
[polydata3,]
)
def read_ply_to_vtk_poly_data(filename):
ply_reader = vtk.vtkPLYReader()
ply_reader.SetFileName(filename)
ply_reader.Update()
return ply_reader.GetOutput()
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 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 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 ProcessRaw3DClipToFrame(dirToTest):
tname="tire.ply"
tiredirToTest=dirToTest+"\\"+tname
reader = vtk.vtkPLYReader()
reader.SetFileName(tiredirToTest)
reader.Update()
pd = reader.GetOutput()
# clip to the the inside of the code
boundsRawMesh = pd.GetBounds()
# yHigher=0.13
# yLower=0
# heightOfTargetBar=0.010
# depthOfTargetBar=0.010
# # ideally you should go low enough until the mnesh becomes crappy
# maxTreadDepth=0.050
pdLargeComponent=ta.KeepOnlyLargestConnectedComponent1(pd)
filename=dirToTest+ "\\"+"OnlyLargestConnectComp.vtp"
ta.LogVTK(pdLargeComponent, filename)
#(xstartPos,xendPos)=FindXStartEndForClipping(pd)
boundsInsideTargetBar=[ boundsRawMesh[0],boundsRawMesh[1],generate_reportsMSettings.yLower+generate_reportsMSettings.heightOfTargetBar,generate_reportsMSettings.yHigher-generate_reportsMSettings.heightOfTargetBar,boundsRawMesh[5]-generate_reportsMSettings.depthOfTargetBar-generate_reportsMSettings.maxTreadDepth ,boundsRawMesh[5]]
clippedRawTireInsideTargetBar=ta.Clip(pdLargeComponent,boundsInsideTargetBar)
filename=dirToTest+ "\\"+"clippedRawTireInsideTargetBar.vtp"
ta.LogVTK(clippedRawTireInsideTargetBar.GetOutput(), filename)
return(clippedRawTireInsideTargetBar.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 main():
filename = get_program_parameters()
colors = vtk.vtkNamedColors()
reader = vtk.vtkPLYReader()
reader.SetFileName(filename)
# Visualize
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d("SeaGreen"))
render_window.Render()
render_window_interactor.Start()
def make_mesh_watertight(self, hole_size=None, filename=None, write=True):
"""This method reads a ply mesh from an external file and converts it into a watertight mesh
"""
self.to_ply(filename="temp.ply")
logger.info(f"Making the mesh read from {filename} watertight")
reader = vtk.vtkPLYReader()
if filename is None:
filename = Path.cwd() / "output/temp.ply"
reader.SetFileName(str(filename))
reader.Update()
polydata = reader.GetOutput()
fill = vtk.vtkFillHolesFilter()
fill.SetInputData(polydata)
hole_size = hole_size if hole_size else config.stl_from_point_cloud.watertight_mesh.hole_size if config.stl_from_point_cloud.watertight_mesh.hole_size else 1.0
fill.SetHoleSize(hole_size)
fill.Update()
self.vtk_filled = fill.GetOutput()
if write:
writer = vtk.vtkPLYWriter()
writer.SetInputData(self.vtk_filled)
writer.SetFileName(f"temp-watertight.ply")
writer.Write()
self.stl_mesh = o3d.io.read_triangle_mesh("temp-watertight.ply")
print(self.stl_mesh)
# Path.unlink(Path("temp-watertight.ply"))
# Path.unlink(filename)
return fill.GetOutput()
def 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 remesh(surfacefile, numbertriangles=40000, output="remeshed.vtp"):
"""
Remesh a surface mesh using using voronoi clustering. Source and module at https://pypi.org/project/pyacvd/
:param surfacefile: Surfacefile to be remeshed to a uniform triangulation.
:param numbertriangles: Number of triangles that the surface will have after the remeshing. Default:40000
:param output: output file name
:return: Nothing
"""
print("Remeshing surface.")
if surfacefile[-3:] == "vtp":
reader = vtk.vtkXMLPolyDataReader()
elif surfacefile[-3:] == "ply":
reader = vtk.vtkPLYReader()
else:
print("Input is not a ply or vtp file.")
return
reader.SetFileName(surfacefile)
reader.Update()
p = reader.GetOutput()
surf = pyvista.PolyData(p)
clus = pyacvd.Clustering(surf)
clus.subdivide(3)
clus.cluster(numbertriangles)
remesh = clus.create_mesh()
writer = vtk.vtkXMLPolyDataWriter()
writer.SetFileName(output)
writer.SetInputData(remesh)
writer.Write()
def visualize(output_dir, offline):
predicted_boxes = np.load(
os.path.join(output_dir, '000000_pred_confident_nms_bbox.npz'))
input_point_cloud = pc_util.read_ply(
os.path.join(output_dir, '000000_pc.ply'))
bbox_params = predicted_boxes['obbs']
proposal_map = predicted_boxes['proposal_map']
transform_m = np.array([[0, 0, -1], [-1, 0, 0], [0, 1, 0]])
instance_models = []
center_list = []
vector_list = []
for map_data, bbox_param in zip(proposal_map, bbox_params):
mesh_file = os.path.join(output_dir,
'proposal_%d_mesh.ply' % tuple(map_data))
ply_reader = vtk.vtkPLYReader()
ply_reader.SetFileName(mesh_file)
ply_reader.Update()
# get points from object
polydata = ply_reader.GetOutput()
# read points using vtk_to_numpy
obj_points = vtk_to_numpy(polydata.GetPoints().GetData()).astype(
np.float)
'''Fit obj points to bbox'''
center = bbox_param[:3]
orientation = bbox_param[6]
sizes = bbox_param[3:6]
obj_points = obj_points - (obj_points.max(0) + obj_points.min(0)) / 2.
obj_points = obj_points.dot(transform_m.T)
obj_points = obj_points.dot(
np.diag(1 / (obj_points.max(0) - obj_points.min(0)))).dot(
np.diag(sizes))
axis_rectified = np.array(
[[np.cos(orientation), np.sin(orientation), 0],
[-np.sin(orientation),
np.cos(orientation), 0], [0, 0, 1]])
obj_points = obj_points.dot(axis_rectified) + center
points_array = numpy_to_vtk(obj_points[..., :3], deep=True)
polydata.GetPoints().SetData(points_array)
ply_reader.Update()
'''draw bboxes'''
vectors = np.diag(sizes / 2.).dot(axis_rectified)
instance_models.append(ply_reader)
center_list.append(center)
vector_list.append(vectors)
scene = Vis_base(scene_points=input_point_cloud,
instance_models=instance_models,
center_list=center_list,
vector_list=vector_list)
camera_center = np.array([0, -3, 3])
scene.visualize(centroid=camera_center,
offline=offline,
save_path=os.path.join(output_dir, 'pred.png'))
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkPLYReader(), 'Reading vtkPLY.',
(), ('vtkPLY',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def PLYReader(self, currentElement):
reader = vtk.vtkPLYReader()
try:
reader.SetFileName(os.path.join(self.basedir, currentElement.get('SetFileName')))
except:
self.logger.error(' .. <PLYReader> failed to SetFileName')
return reader
def TransformFile(file, transformmatrix):
"""
Transform all points in a vtp file.
This is not the way that paraview does its transformations.
"""
if file[-3:] == "vtp":
reader = vtk.vtkXMLPolyDataReader()
elif file[-3:] == "ply":
reader = vtk.vtkPLYReader()
else:
print("Error: unreadable file.")
return 1
reader.SetFileName(file)
reader.Update()
data = reader.GetOutput()
pos_vtk = reader.GetOutput().GetPoints().GetData()
pos = vtk_to_numpy(pos_vtk)
nodes = vtk.vtkPoints()
for point in pos:
vec = numpy.array([[point[0]], [point[1]], [point[2]], [1]])
position = numpy.dot(transformmatrix, vec)
nodes.InsertNextPoint(position[:-1])
data.SetPoints(nodes)
# export to new file
writer = vtk.vtkXMLPolyDataWriter()
file = "testingtrans.vtp"
writer.SetFileName(file)
writer.SetInputData(data)
writer.Write()
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 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 __init__(self, fileName, iteration, relaxation):
self.reader = vtk.vtkPLYReader()
self.reader.SetFileName(fileName)
self.reader.Update()
self.inputPolyData = self.reader.GetOutput()
self.iter = iteration
self.rela = relaxation
def ply_importer(filepath, asset=None, texture_resolver=None, **kwargs):
ply_importer = vtk.vtkPLYReader()
ply_importer.SetFileName(str(filepath))
ply_importer.Update()
# Get the output
polydata = ply_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 ply_to_polydata(fname):
import vtk
reader = vtk.vtkPLYReader()
reader.SetFileName(fname)
reader.Update()
polydata = reader.GetOutput()
return polydata
def ReadPLYSurfaceFile(self):
if (self.InputFileName == ''):
self.PrintError('Error: no InputFileName.')
self.PrintLog('Reading PLY surface file.')
reader = vtk.vtkPLYReader()
reader.SetFileName(self.InputFileName)
reader.Update()
self.Surface = reader.GetOutput()
def load_file(filename):
if filename.endswith('.ply'):
reader = vtk.vtkPLYReader()
else:
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
reader.Update()
return reader.GetOutput()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkPLYReader(),
'Reading vtkPLY.', (), ('vtkPLY', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def load_file(filename):
if filename.endswith('.ply'):
reader = vtk.vtkPLYReader()
else:
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
reader.Update()
return reader.GetOutput()
def ReadPLYSurfaceFile(self):
if (self.InputFileName == ''):
self.PrintError('Error: no InputFileName.')
self.PrintLog('Reading PLY surface file.')
reader = vtk.vtkPLYReader()
reader.SetFileName(self.InputFileName)
reader.Update()
self.Surface = reader.GetOutput()
def add_newData(self,path):
print("get ply")
reader=vtk.vtkPLYReader()
#reader.SetDuplicatePointsForFaceTexture(False)
reader.SetFileName(path)
reader.Update()
self.plyReader = reader
self.__addActor()
def make_actor(mesh_path, diffuse_path, normal_path ):
if diffuse_path!="none":
albedo = GetTexture(diffuse_path)
albedo.UseSRGBColorSpaceOn()
normal = GetTexture(normal_path)
# reader = vtk.vtkOBJReader()
reader = vtk.vtkPLYReader()
reader.SetFileName(mesh_path)
reader.Update()
polydata=reader.GetOutputDataObject(0)
# #make it into triangles
# triangulator=vtk.vtkTriangleFilter()
# triangulator.SetInputData(polydata)
# triangulator.Update()
# polydata=triangulator.GetOutput()
#compute tangents
if diffuse_path!="none":
tangents=vtk.vtkPolyDataTangents()
tangents.SetInputData(polydata)
tangents.Update()
polydata=tangents.GetOutput()
mapper = vtk.vtkPolyDataMapper()
# mapper.SetInputConnection(reader.GetOutputPort())
mapper.SetInputData(polydata)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetInterpolationToPBR()
colors = vtk.vtkNamedColors()
actor.GetProperty().SetColor(colors.GetColor3d('White'))
actor.GetProperty().SetMetallic(0.0)
actor.GetProperty().SetRoughness(0.5)
# configure textures (needs tcoords on the mesh)
if diffuse_path!="none":
actor.GetProperty().SetBaseColorTexture(albedo)
# help(actor.GetProperty())
# exit(1)
# actor.GetProperty().SetORMTexture(material)
# actor.GetProperty().SetOcclusionStrength(occlusionStrength)
# actor.GetProperty().SetEmissiveTexture(emissive)
# actor.GetProperty().SetEmissiveFactor(emissiveFactor)
# needs tcoords, normals and tangents on the mesh
if diffuse_path!="none":
actor.GetProperty().SetNormalTexture(normal)
actor.GetProperty().BackfaceCullingOn()
return actor
def smooth(path,
iterations=100,
relaxation=0.1,
edgesmoothing=True,
savepath=None):
""" Edit a mesh file (ply format) applying iterative Laplacian smoothing """
# source https://vtk.org/Wiki/VTK/Examples/Cxx/PolyData/SmoothPolyDataFilter
# read Ply file
reader = vtkPLYReader()
reader.SetFileName(path)
reader.Update()
# create Poly data
inputPoly = vtkPolyData()
inputPoly.ShallowCopy(reader.GetOutput())
# Smooth mesh with Laplacian Smoothing
smooth = vtkSmoothPolyDataFilter()
smooth.SetInputData(inputPoly)
smooth.SetRelaxationFactor(relaxation)
smooth.SetNumberOfIterations(iterations)
if edgesmoothing:
smooth.FeatureEdgeSmoothingOn()
else:
smooth.FeatureEdgeSmoothingOff()
smooth.BoundarySmoothingOn()
smooth.Update()
smoothPoly = vtkPolyData()
smoothPoly.ShallowCopy(smooth.GetOutput())
# Find mesh normals (Not sure why)
normal = vtkPolyDataNormals()
normal.SetInputData(smoothPoly)
normal.ComputePointNormalsOn()
normal.ComputeCellNormalsOn()
normal.Update()
normalPoly = vtkPolyData()
normalPoly.ShallowCopy(normal.GetOutput())
# write results on output file
if savepath is None:
outfile_path = os.path.splitext(path)[0]
outfile_path = f"{outfile_path}_smooth_{iterations}.ply"
else:
outfile_path = os.path.splitext(path)[0]
outfile_path = f"{os.path.basename(outfile_path)}_smooth_{iterations}.ply"
outfile_path = os.path.join(savepath, outfile_path)
writer = vtkPLYWriter()
writer.SetInputData(normalPoly)
writer.SetFileName(outfile_path)
writer.Write()
print(f" -> Saving file at: {outfile_path}")
return outfile_path
def cutter(filename):
reader = vtk.vtkPLYReader()
reader.SetFileName(filename)
reader.Update()
reader.GetOutput().GetPointData().SetActiveScalars("Intensity")
plane = vtk.vtkPlane()
bounds = [0] * 6
reader.GetOutput().GetBounds(bounds)
# origin = [(bounds[0] + bounds[1]) / 10, (bounds[2] + bounds[3]) / 10, (bounds[4] + bounds[5]) / 10]
# plane.SetOrigin(reader.GetOutput().GetCenter())
# plane.SetOrigin(origin)
plane.SetOrigin(0, 0, -30)
plane.SetNormal(0, 0, 1)
high = plane.EvaluateFunction([(bounds[1] + bounds[0]) / 2.0,
(bounds[3] + bounds[2]) / 2.0, bounds[5]])
planeCut = vtk.vtkCutter()
planeCut.SetInputConnection(reader.GetOutputPort())
planeCut.SetCutFunction(plane)
numberOfCuts = 10
planeCut.GenerateValues(numberOfCuts, 0.99, 0.99 * high)
# THIS GIVES THE 3D COORDINATES OF THE POINTS OF THE CUT PLANE
# print(planeCut.GetOutput().GetPoints())
# THIS GIVES THE DATA ASSOCIATED WITH EACH OF THE POINTS
planeCut.GetOutput().GetPointData().GetAttribute(0)
cutMapper = vtk.vtkPolyDataMapper()
cutMapper.SetInputConnection(planeCut.GetOutputPort())
cutActor = vtk.vtkActor()
cutActor.SetMapper(cutMapper)
# 渲染器和窗口
colors = vtk.vtkNamedColors()
renderer = vtk.vtkRenderer()
renderer.AddActor(cutActor)
renderer.SetBackground(colors.GetColor3d("MidnightBlue"))
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
# 交互器
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
# 渲染一副图像（光照和相机自动创建）
renderWindow.SetWindowName("OctreeVisualize")
renderWindow.SetSize(600, 600)
renderWindow.Render()
# 开启鼠标和键盘的交互模式
renderWindowInteractor.Start()
def ply_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
ply_importer = vtk.vtkPLYReader()
ply_importer.SetFileName(str(filepath))
ply_importer.Update()
# Get the output
polydata = ply_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 ply_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
ply_importer = vtk.vtkPLYReader()
ply_importer.SetFileName(str(filepath))
ply_importer.Update()
# Get the output
polydata = ply_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 load_ply(self, ply_file):
reader = vtk.vtkPLYReader()
reader.SetFileName(ply_file)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
return self._add_mesh_actor(actor)
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 ply2vtk(filename1,filename2):
"""Read a ply file and save as vtk ascii."""
reader = vtk.vtkPLYReader()
reader.SetFileName(filename1)
reader.Update()
writer = vtk.vtkPolyDataWriter()
writer.SetInputConnection(reader.GetOutputPort())
writer.SetFileTypeToASCII()
writer.SetFileName(filename2)
writer.Write()
def _get_vtk_reader(cls, mimetype: str) -> "vtkAbstractPolyDataReader":
if mimetype in [mapping.mimetype for mapping in cls.STL_MIMETYPES_MAPPING]:
return vtkSTLReader()
elif mimetype in [mapping.mimetype for mapping in cls.OBJ_MIMETYPES_MAPPING]:
return vtkOBJReader()
elif mimetype in [mapping.mimetype for mapping in cls.PLY_MIMETYPES_MAPPING]:
return vtkPLYReader()
elif mimetype in [mapping.mimetype for mapping in cls.GLTF_MIMETYPES_MAPPING]:
return vtkGLTFReader()
else:
raise UnsupportedMimeType("Unsupported mimetype: {}".format(mimetype))
def __get_reader(self, file_extension):
'''Returns a reader that can read the file type having the provided extension. Returns None if no such reader.'''
lower_file_ext = file_extension.lower()
#if (lower_file_ext == ".tiff" or lower_file_ext == ".tif"):
# return vtk.vtkTIFFReader()
if (lower_file_ext == ".vtk"):
return vtk.vtkPolyDataReader()
if (lower_file_ext == ".ply"):
return vtk.vtkPLYReader()
if (lower_file_ext == ".obj"):
return OBJReader()
return None
def load_ply(ply_file):
""" Loads a ply file and returns an actor """
reader = vtk.vtkPLYReader()
reader.SetFileName(ply_file)
reader.Update()
ply_mapper = vtk.vtkPolyDataMapper()
ply_mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(ply_mapper)
return actor
def readPLY(self, filename=None):
if filename is not None:
self.filename = filename
r = vtk.vtkPLYReader()
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 chooseReader(self, file_format, vtk_dataset_type=None):
"""
Return a reader based on file_format and possibly vtk_dataset_type.
@param vtk_dataset_type, None or one of the VTK_DATASET_TYPES
"""
# Handle .ply files.
if file_format == 'ply':
return vtk.vtkPLYReader()
# Handle .vtk files.
if vtk_dataset_type == 'STRUCTURED_GRID':
return vtk.vtkStructuredGridReader()
elif vtk_dataset_type == 'POLYDATA':
return vtk.vtkPolyDataReader()
elif vtk_dataset_type == 'UNSTRUCTURED_GRID':
return vtk.vtkUnstructuredGridReader()
def readPLY(name):
try:
reader = vtk.vtkPLYReader()
reader.SetFileName( name )
reader.Update()
print "Input mesh:", name
mesh = reader.GetOutput()
del reader
reader = None
return mesh
except:
print "PLY Mesh reader failed"
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout)
return None
def main():
files = glob.glob(os.path.join(sys.argv[1], '*'))
for f in sorted(files):
ply_reader = vtk.vtkPLYReader()
ply_reader.SetFileName(f)
ply_reader.Update()
nc = test_connectivity(ply_reader.GetOutput())
print f, nc
clean = vtk.vtkCleanPolyData()
clean.SetInput(ply_reader.GetOutput())
clean.Update()
print clean.GetOutput().GetNumberOfPoints(), clean.GetOutput().GetNumberOfCells()
def __init__(self, nbunnies=1):
VTKPythonAlgorithmBase.__init__(self,
nInputPorts=0,
nOutputPorts=1, outputType='vtkPolyData')
self._bunny_ply_file = os.path.join(os.path.dirname(__file__),
'stanford_bunny.ply')
self._nbunnies = nbunnies
dis = 1.5
ytrans = -0.2
if nbunnies is 1:
trans = [(0.0, ytrans, 0.0)]
elif nbunnies is 2:
trans = [(-dis, ytrans, 0.0),
(dis, ytrans, 0.0)]
elif nbunnies is 3:
trans = [(-dis, ytrans, 0.0),
(0.0, ytrans, 0.0),
(dis, ytrans, 0.0)]
elif nbunnies is 4:
trans = [(-dis, ytrans, 0.0),
(0.0, ytrans, dis),
(dis, ytrans, 0.0),
(0.0, ytrans, -dis)]
self.objects = {'bunny_' + str(x): True for x in range(nbunnies)}
self._polydata = {'bunny_'+str(x): vtk.vtkTransformPolyDataFilter() for x in range(nbunnies)}
self._keys = self.objects.keys()
for i, (key, tfilter) in enumerate(self._polydata.iteritems()):
reader = vtk.vtkPLYReader()
reader.SetFileName(self._bunny_ply_file)
transform = vtk.vtkTransform()
# transform.Scale(10.0, 10.0, 10.0)
transform.Translate(trans[i])
tfilter.SetInputConnection(reader.GetOutputPort())
tfilter.SetTransform(transform)
self._floor = True
self._floor_polydata = None
def show_ply(ply_file):
r = vtk.vtkPLYReader()
r.SetFileName(ply_file)
r.Update()
mapper = vtk.vtkDataSetMapper()
mapper.SetInput(r.GetOutput())
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.Render()
iren.Start()
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;
def main(filename):
# Read and display
reader = vtk.vtkPLYReader()
reader.SetFileName(filename)
reader.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
renderer.AddActor(actor)
renderer.SetBackground(0.1804, 0.5451, 0.3412)
renderer.SetBackground(0.1804, 0.5451, 0.3412)
render_window.Render()
render_window_interactor.Start()
def __init__(self, module_manager):
# call parent constructor
ModuleBase.__init__(self, module_manager)
self._reader = vtk.vtkPLYReader()
# ctor for this specific mixin
FilenameViewModuleMixin.__init__(
self,
'Select a filename',
'(Stanford) Polygon File Format (*.ply)|*.ply|All files (*)|*',
{'vtkPLYReader': self._reader,
'Module (self)' : self})
module_utils.setup_vtk_object_progress(
self, self._reader,
'Reading PLY PolyData')
# set up some defaults
self._config.filename = ''
# there is no view yet...
self._module_manager.sync_module_logic_with_config(self)
def readFile(self, fileName):
self.reader = vtk.vtkPLYReader()
self.reader.SetFileName(fileName)
self.reader.Update()
self.bounds = range(6)
self.inputPolyData = self.reader.GetOutput()
# In[32]: rdm = vtk.vtkDataSetReader() rdm.SetFileName(mesh_filename) rdm.Update() mesh = rdm.GetOutput() # In[33]: rdp = vtk.vtkPLYReader() rdp.SetFileName(points_filename) rdp.Update() pts = rdp.GetOutput() # In[34]: loc = vtk.vtkPointLocator() loc.SetDataSet(mesh) loc.BuildLocator() #subdivide the index array (not continuous) indices = list(range(pts.GetNumberOfPoints()))
xmins = [0,.5,0,.5] xmaxs = [0.5,1,0.5,1] #ymins = [0,0,.5,.5] ymins = [0.5,0,0,.5] #ymaxs = [0.5,0.5,1,1] ymaxs = [1,0.5,0.5,1] i=0 ren1 = vtk.vtkRenderer() ren1.SetViewport(xmins[i],ymins[i],xmaxs[i],ymaxs[i]) renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) reader = vtk.vtkPLYReader() reader.SetFileName(fname + '.ply') mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(reader.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) #actor.RotateY(rot); #actor.RotateZ(45); xform = vtk.vtkTransform() xform.PostMultiply() sf = 5.2 xform.Scale(sf,sf,sf) #xform.Translate(10.0, 0.0, 0.0)
def addColors(infilename, outfilename, colorfilename=None, colorstring=None,
binary=True, verbose=False):
"""add color array"""
outformat = path.splitext(outfilename)[1].strip('.')
if outformat!='ply':
raise ValueError('colors are only supported for PLY format')
informat = path.splitext(infilename)[1].strip('.')
# set reader based on filename extension
if informat=='stl':
reader = vtk.vtkSTLReader()
elif informat=='vtk':
reader = vtk.vtkPolyDataReader()
elif informat=='obj':
reader = vtk.vtkMNIObjectReader()
elif informat=='ply':
reader = vtk.vtkPLYReader()
elif informat=='vtp':
reader = vtk.vtkXMLPolyDataReader()
else:
raise ValueError('cannot read input format: ' + informat)
reader.SetFileName(infilename)
reader.Update()
#N = reader.GetOutput().GetNumberOfPolys()
N = reader.GetOutput().GetNumberOfPoints()
if verbose:
print("read %i points (vertices)" % (N,))
if colorfilename:
colorar = readColorFile(colorfilename)
if N != colorar.shape[0]:
raise ValueError('number of rows in color file does not match' +
'number of points in mesh file')
elif colorstring:
color = [int(i) for i in colorstring.split()]
colorar = np.ones((N,3)) * np.array(color)
Colors = vtk.vtkUnsignedCharArray()
Colors.SetNumberOfComponents(3)
Colors.SetName("Colors")
for i in range(0,N):
Colors.InsertNextTuple3(*colorar[i,:])
polydata = vtk.vtkPolyData()
polydata = reader.GetOutput()
polydata.GetPointData().SetScalars(Colors)
polydata.Modified()
writer = vtk.vtkPLYWriter()
writer.SetArrayName("Colors")
writer.SetInputData(polydata)
writer.SetFileName(outfilename)
if binary:
if verbose: print('setting output to binary')
writer.SetFileTypeToBinary()
else:
if verbose: print('setting output to ascii')
writer.SetFileTypeToASCII()
err = writer.Write()
def readMeshFile(filename, clean=True, verbose=False, recompute_normals=True):
"""Read mesh file.
The input format is determined by file name extension.
Polygons get split into triangles to support various restrictive output
formats.
If clean, degenerate data gets removed."""
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=='ply':
reader = vtk.vtkPLYReader()
elif informat=='vtp':
reader = vtk.vtkXMLPolyDataReader()
#elif informat=='tag':
# reader = vtk.vtkMNITagPointReader()
else:
raise ValueError('cannot read input format: ' + informat)
reader.SetFileName(filename)
reader.Update()
if verbose:
print("read %i polygons from file %s" % \
(reader.GetOutput().GetNumberOfPolys(), filename))
# merge duplicate points, and/or remove unused points and/or remove degenerate cells
if clean:
polydata = vtk.vtkCleanPolyData()
polydata.SetInputConnection(reader.GetOutputPort())
poly_data_algo = polydata
if verbose:
print("cleaned poly data")
else:
poly_data_algo = reader
# convert input polygons and strips to triangles
triangles = vtk.vtkTriangleFilter()
triangles.SetInputConnection(poly_data_algo.GetOutputPort())
if recompute_normals:
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(triangles.GetOutputPort())
normals.SplittingOff()
normals.ComputePointNormalsOn()
normals.AutoOrientNormalsOn()
normals.ConsistencyOn()
normals.NonManifoldTraversalOn()
if verbose:
print("recomputed normals")
print("finished reading", filename)
return normals
else:
if verbose:
print("finished reading", filename)
return triangles
def load_file(filename):
reader = vtk.vtkPLYReader()
reader.SetFileName(filename)
reader.Update()
return reader.GetOutput()
ele.SetInputConnection(ss.GetOutputPort())
pd2cd = vtk.vtkPointDataToCellData()
pd2cd.SetInputConnection(ele.GetOutputPort())
# First way or writing
w = vtk.vtkPLYWriter()
w.SetInputConnection(pd2cd.GetOutputPort())
w.SetFileName(filename)
w.SetFileTypeToBinary()
w.SetDataByteOrderToLittleEndian()
w.SetColorModeToUniformCellColor()
w.SetColor(255, 0, 0)
w.Write()
r = vtk.vtkPLYReader()
r.SetFileName(filename)
r.Update()
# cleanup
#
try:
os.remove(filename)
except OSError:
pass
plyMapper = vtk.vtkPolyDataMapper()
plyMapper.SetInputConnection(r.GetOutputPort())
plyActor = vtk.vtkActor()
plyActor.SetMapper(plyMapper)
def _update(self):
reader = vtkPLYReader()
reader.SetFileName(self.filename_)
reader.Update()
self._polydata = reader.GetOutput()
if program is not None:
diffuseColor = [0.4, 0.7, 0.6]
program.SetUniform3f("diffuseColorUniform", diffuseColor)
renWin = vtk.vtkRenderWindow()
renWin.SetSize(400, 400)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
ren = vtk.vtkRenderer()
ren.SetBackground(0.0, 0.0, 0.0)
ren.GradientBackgroundOn()
renWin.AddRenderer(ren)
actor = vtk.vtkActor()
ren.AddActor(actor)
reader = vtk.vtkPLYReader()
reader.SetFileName("" + str(vtkGetDataRoot()) + "/Data/dragon.ply")
norms = vtk.vtkTriangleMeshPointNormals()
norms.SetInputConnection(reader.GetOutputPort())
mapper = vtk.vtkOpenGLPolyDataMapper()
mapper.SetInputConnection(norms.GetOutputPort())
actor.SetMapper(mapper)
actor.GetProperty().SetAmbientColor(0.2, 0.2, 1.0)
actor.GetProperty().SetDiffuseColor(1.0, 0.65, 0.7)
actor.GetProperty().SetSpecularColor(1.0, 1.0, 1.0)
actor.GetProperty().SetSpecular(0.5)
actor.GetProperty().SetDiffuse(0.7)
actor.GetProperty().SetAmbient(0.5)
actor.GetProperty().SetSpecularPower(20.0)
actor.GetProperty().SetOpacity(1.0)
