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 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 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)