def OnExportSurface(self, pubsub_evt): filename, filetype = pubsub_evt.data if (filetype == const.FILETYPE_STL) or\ (filetype == const.FILETYPE_VTP) or\ (filetype == const.FILETYPE_PLY) or\ (filetype == const.FILETYPE_STL_ASCII): # First we identify all surfaces that are selected # (if any) proj = prj.Project() polydata_list = [] for index in proj.surface_dict: surface = proj.surface_dict[index] if surface.is_shown: polydata_list.append(surface.polydata) if len(polydata_list) == 0: utl.debug("oops - no polydata") return elif len(polydata_list) == 1: polydata = polydata_list[0] else: polydata = pu.Merge(polydata_list) # Having a polydata that represents all surfaces # selected, we write it, according to filetype if filetype == const.FILETYPE_STL: writer = vtk.vtkSTLWriter() writer.SetFileTypeToBinary() elif filetype == const.FILETYPE_STL_ASCII: writer = vtk.vtkSTLWriter() writer.SetFileTypeToASCII() elif filetype == const.FILETYPE_VTP: writer = vtk.vtkXMLPolyDataWriter() #elif filetype == const.FILETYPE_IV: # writer = vtk.vtkIVWriter() elif filetype == const.FILETYPE_PLY: writer = vtk.vtkPLYWriter() writer.SetFileTypeToASCII() writer.SetColorModeToOff() #writer.SetDataByteOrderToLittleEndian() #writer.SetColorModeToUniformCellColor() #writer.SetColor(255, 0, 0) if filetype in (const.FILETYPE_STL, const.FILETYPE_PLY): # Invert normals normals = vtk.vtkPolyDataNormals() normals.SetInputData(polydata) normals.SetFeatureAngle(80) normals.AutoOrientNormalsOn() # normals.GetOutput().ReleaseDataFlagOn() normals.UpdateInformation() normals.Update() polydata = normals.GetOutput() filename = filename.encode(wx.GetDefaultPyEncoding()) writer.SetFileName(filename) writer.SetInputData(polydata) writer.Write()
def marching_cubes(grid_fname_vtk, mesh_filename_ply, value=0.5): """ read in a grid in vtk format, run marching cubes, save the result as ply mesh Parameters ---------- grid_fname_vtk : str The file name of the grid in vtk format mesh_filename_ply : str The file name to save the ply mesh results value : float, optional The value """ reader = vtk.vtkStructuredPointsReader() reader.SetFileName(grid_fname_vtk) reader.Update() points = reader.GetOutput() mcubes = vtk.vtkMarchingCubes() mcubes.SetInput(points) mcubes.SetValue(0, value) mcubes.Update() mesh = mcubes.GetOutput() writer = vtk.vtkPLYWriter() writer.SetInput(mesh) writer.SetFileName(mesh_filename_ply) writer.Update() writer.Write()
def create_ply(savepath, vtkPoly): # write results to output file writer = vtkPLYWriter() writer.SetInputData(vtkPoly) writer.SetFileName(savepath) writer.Write()
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 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 write(self, file_name): writer = vtk.vtkPLYWriter() writer.SetFileName(file_name) writer.SetInputData(self.vtk_poly_data) if self.is_color_mode_height: # set lookup tbale for depth values to colors lut = vtk.vtkLookupTable() lut.SetTableRange(self.height_min, self.height_max) lut.Build() # in order to be convertable to pcd, use lut to generate colors. # THIS IS A DIRTY HACK BUT NEEDED SINCE PCL IS STUPID # writer.SetLookupTable(lut) only works for meshlab cur_color_data = vtk.vtkUnsignedCharArray() cur_color_data.SetNumberOfComponents(3) for id in self.color_ids: val = self.color_data.GetValue(id) col = [0., 0., 0.] lut.GetColor(val, col) col = [int(c * 255) for c in col] cur_color_data.InsertNextTuple3(col[0], col[1], col[2]) self.color_data = cur_color_data self.color_data.SetName("Colors") self.vtk_poly_data.GetPointData().SetActiveScalars('Colors') self.vtk_poly_data.GetPointData().SetScalars(self.color_data) writer.SetArrayName("Colors") writer.Write()
def WriteMesh(filename, mesh, binary=True): """ Writes a VTK mesh to one of the following formats: ply, stl, vtk """ # Get extention ftype = filename[-3:] # Get filetype if ftype == 'ply': writer = vtk.vtkPLYWriter() elif ftype == 'stl': writer = vtk.vtkSTLWriter() elif ftype == 'vtk': writer = vtk.vtkPolyDataWriter() else: raise Exception('Unknown file type') # Write writer.SetFileName(filename) SetVTKInput(writer, mesh) if binary: writer.SetFileTypeToBinary() else: writer.SetFileTypeToASCII() writer.Write()
def save_polys(output_dir, variables, key, output_filename, index_list): poly_name = key[0] poly_faces = key[1] verts = deepnet.utils.unwrapped(variables[poly_name]) faces = deepnet.utils.unwrapped(variables[poly_faces]) for i in range(verts.shape[0]): case_name = variables['case_name'][i] variables['__index__'] = index_list[case_name] index_list[case_name] += 1 # make output dir current_output_dir = os.path.join(output_dir, case_name) os.makedirs(current_output_dir, exist_ok=True) # save polys current_output_filename = os.path.join( current_output_dir, output_filename.format(**variables)) surface = convert_poly_numpy_to_vtk(verts[i], faces[i]) writer = vtk.vtkPLYWriter() writer.SetInputData(surface) writer.SetFileName(output_filename.format( **variables)) writer.Update()
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkPLYWriter(), 'Writing vtkPLY.', ('vtkPLY',), (), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def save_polydata(polydata, file_name, binary=False, color_array_name=None): # get file extension (type) file_extension = file_name.split(".")[-1].lower() if file_extension == "vtk": writer = vtk.vtkPolyDataWriter() elif file_extension == "vtp": writer = vtk.vtkPolyDataWriter() elif file_extension == "fib": writer = vtk.vtkPolyDataWriter() elif file_extension == "ply": writer = vtk.vtkPLYWriter() elif file_extension == "stl": writer = vtk.vtkSTLWriter() elif file_extension == "xml": writer = vtk.vtkXMLPolyDataWriter() elif file_extension == "obj": raise "mni obj or Wavefront obj ?" # writer = set_input(vtk.vtkMNIObjectWriter(), polydata) writer.SetFileName(file_name) writer = set_input(writer, polydata) if color_array_name is not None: writer.SetArrayName(color_array_name) if binary: writer.SetFileTypeToBinary() writer.Update() writer.Write()
def writeply(surface,filename): """Write mesh as ply file.""" writer = vtk.vtkPLYWriter() writer.SetInputData(surface) writer.SetFileTypeToASCII() writer.SetFileName(filename) writer.Write()
def save_polydata(mesh: vtk.vtkPolyData, filename: str): """Saves a mesh as a vtkPolyData file. Parameters ---------- mesh : vtkPolyData Input mesh filename : str File path where the mesh will be saved output_type : vtk or ply Format of output polydata file """ # Output file format output_type = filename.split(".")[-1] if output_type not in ["vtk", "ply"]: raise ValueError( f"Output format {output_type} not supported. Please use vtk or ply." ) if output_type == "vtk": writer = vtk.vtkPolyDataWriter() else: writer = vtk.vtkPLYWriter() writer.SetInputData(mesh) writer.SetFileName(filename) writer.Write()
def write(obj, fileoutput): ''' Write 3D object to file. Possile extensions are: .vtk, .ply, .obj, .stl, .byu, .vtp ''' fr = fileoutput.lower() if '.vtk' in fr: w = vtk.vtkPolyDataWriter() elif '.ply' in fr: w = vtk.vtkPLYWriter() elif '.obj' in fr: w = vtk.vtkOBJExporter() w.SetFilePrefix(fileoutput.replace('.obj', '')) vc.printc('Please use write(vp.renderWin)', 3) w.SetInput(obj) w.Update() vc.printc("Saved file: " + fileoutput, 'g') return elif '.stl' in fr: w = vtk.vtkSTLWriter() elif '.byu' in fr or '.g' in fr: w = vtk.vtkBYUWriter() elif '.vtp' in fr: w = vtk.vtkXMLPolyDataWriter() else: vc.printc('Unavailable format in file ' + fileoutput, c='r') exit(1) try: vu.setInput(w, vu.polydata(obj, True)) w.SetFileName(fileoutput) w.Write() vc.printc("Saved file: " + fileoutput, 'g') except: vc.printc("Error saving: " + fileoutput, 'r')
def save_polydata(polydata, file_name, binary=False, color_array_name=None): # get file extension (type) file_extension = file_name.split(".")[-1].lower() # todo better generic load # todo test all if file_extension == "vtk": writer = vtk.vtkPolyDataWriter() elif file_extension == "vtp": writer = vtk.vtkPolyDataWriter() elif file_extension == "fib": writer = vtk.vtkPolyDataWriter() elif file_extension == "ply": writer = vtk.vtkPLYWriter() elif file_extension == "stl": writer = vtk.vtkSTLWriter() elif file_extension == "xml": writer = vtk.vtkXMLPolyDataWriter() elif file_extension == "obj": raise "mni obj or Wavefront obj ?" # writer = set_input(vtk.vtkMNIObjectWriter(), polydata) writer.SetFileName(file_name) writer = set_input(writer, polydata) if color_array_name is not None: writer.SetArrayName(color_array_name); if binary : writer.SetFileTypeToBinary() writer.Update() writer.Write()
def vtk_export(polydata, filename, method='vtk'): """Export VTK polyData object to different file formats. polydata (vtk.vtkPolyData): ytk object containing vertices and simplices filename (string): path and filename without extension method (string): one of the following options vtk: VTK legacy file version 4.2 (e.g. for import into ParaView) ply: Stanford University ".ply" file (e.g. for import into MeshLab) iv: OpenInventor 2.0 file (e.g. for import into METRO) """ # TODO: Binary ASCII stuff if method == 'vtk': export = vtkPolyDataWriter() export.SetInputDataObject(polydata) export.SetFileName(filename + '.vtk') export.Write() elif method == 'ply': export = vtkPLYWriter() export.SetInputDataObject(polydata) export.SetFileName(filename + '.ply') export.Write() elif method == 'iv': export = vtkIVWriter() export.SetInputDataObject(polydata) export.SetFileName(filename + '.iv') export.Write() else: print('File format unknown!')
def writePLYfile(vtkPoly, savepath = None): # write results to output file writer = vtkPLYWriter() writer.SetInputData(vtkPoly) writer.SetFileName(savepath) writer.Write() return 1
def WritePLYSurfaceFile(self): if (self.OutputFileName == ''): self.PrintError('Error: no OutputFileName.') self.PrintLog('Writing PLY surface file.') writer = vtk.vtkPLYWriter() writer.SetInput(self.Surface) writer.SetFileName(self.OutputFileName) writer.Write()
def write_vtk_poly_data_to_ply_file(filename, vtk_poly_data): ply_writer = vtk.vtkPLYWriter() ply_writer.SetFileTypeToASCII() ply_writer.SetFileName(filename) ply_writer.SetInputData(vtk_poly_data) ply_writer.SetArrayName("Colors") ply_writer.Write()
def createMeshFromPolyDataTetGen(self, inputPolyData, outputMeshNode, additionalParameters=""): self.abortRequested = False tempDir = self.createTempDirectory() self.addLog('Mesh generation is started in working directory: ' + tempDir) # Write inputs qt.QDir().mkpath(tempDir) inputSurfaceMeshFilePath = os.path.join(tempDir, "mesh.ply") inputWriter = vtk.vtkPLYWriter() inputWriter.SetInputData(inputPolyData) inputWriter.SetFileName(inputSurfaceMeshFilePath) inputWriter.SetFileTypeToASCII() inputWriter.Write() inputParamsTetGen = [] inputParamsTetGen.append("-k" + additionalParameters) inputParamsTetGen.append(inputSurfaceMeshFilePath) # Run tetgen ep = self.startMesher(inputParamsTetGen, self.getTetGenPath()) self.logProcessOutput(ep, self.tetGenFilename) # Read results if not self.abortRequested: outputVolumetricMeshPath = os.path.join(tempDir, "mesh.1.vtk") outputReader = vtk.vtkUnstructuredGridReader() outputReader.SetFileName(outputVolumetricMeshPath) outputReader.ReadAllScalarsOn() outputReader.ReadAllVectorsOn() outputReader.ReadAllNormalsOn() outputReader.ReadAllTensorsOn() outputReader.ReadAllColorScalarsOn() outputReader.ReadAllTCoordsOn() outputReader.ReadAllFieldsOn() outputReader.Update() outputMeshNode.SetUnstructuredGridConnection( outputReader.GetOutputPort()) outputMeshDisplayNode = outputMeshNode.GetDisplayNode() if not outputMeshDisplayNode: # Initial setup of display node outputMeshNode.CreateDefaultDisplayNodes() outputMeshDisplayNode = outputMeshNode.GetDisplayNode() outputMeshDisplayNode.SetEdgeVisibility(True) outputMeshDisplayNode.SetClipping(True) # Clean up if self.deleteTemporaryFiles: import shutil shutil.rmtree(tempDir) self.addLog("Model generation is completed")
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 save(self, filename, binary=True): """Write a surface mesh to disk. Written file may be an ASCII or binary ply, stl, or vtk mesh file. If ply or stl format is chosen, the face normals are computed in place to ensure the mesh is properly saved. Parameters ---------- filename : str Filename of mesh to be written. File type is inferred from the extension of the filename unless overridden with ftype. Can be one of the following types (.ply, .stl, .vtk) binary : bool, optional Writes the file as binary when True and ASCII when False. Notes ----- Binary files write much faster than ASCII and have a smaller file size. """ filename = os.path.abspath(os.path.expanduser(filename)) file_mode = True # Check filetype ftype = filename[-3:] if ftype == 'ply': writer = vtk.vtkPLYWriter() elif ftype == 'vtp': writer = vtk.vtkXMLPolyDataWriter() file_mode = False if binary: writer.SetDataModeToBinary() else: writer.SetDataModeToAscii() elif ftype == 'stl': writer = vtk.vtkSTLWriter() elif ftype == 'vtk': writer = vtk.vtkPolyDataWriter() else: raise Exception('Filetype must be either "ply", "stl", or "vtk"') # Recompute normals prior to save. Corrects a bug were some # triangular meshes are not saved correctly if ftype in ['stl', 'ply']: self.compute_normals(inplace=True) writer.SetFileName(filename) writer.SetInputData(self) if binary and file_mode: writer.SetFileTypeToBinary() elif file_mode: writer.SetFileTypeToASCII() writer.Write()
def from_polydata(polydata, output_filename): writerPLY = vtkPLYWriter() if not output_filename.endswith(".ply"): output_filename += ".ply" writerPLY.SetFileName(output_filename) writerPLY.SetInput(polydata) writerPLY.SetFileTypeToASCII() writerPLY.Write()
def save_polydata(polydata, filename): if filename.lower().endswith(".stl"): writer = vtk.vtkSTLWriter() elif filename.lower().endswith(".ply"): writer = vtk.vtkPLYWriter() else: print("File must be STL or PLY") sys.exit(0) writer.SetInputData(polydata) writer.SetFileName(filename) writer.Write()
def writePLY(model, file): file = file.with_suffix('.ply') print(f'Writing File : {file}') writer = vtk.vtkPLYWriter() writer.SetEnableAlpha(True) writer.SetInputData(model) writer.SetArrayName('color') writer.SetFileName(str(file)) writer.SetFileTypeToBinary() writer.Write()
def salva_vertixOsso(self, path): assembly = self.assemblagem(self.ListaOssos) polidata = vtk.vtkPolyData() polidata.SetPoints(assembly.GetOutput().GetPoints()) write = vtk.vtkPLYWriter() write.SetInputData(polidata) write.SetFileTypeToBinary() write.SetFileName(path) write.Write() write.Update()
def main(): filename_input, filename_output = get_program_parameters() reader = vtk.vtkXMLPolyDataReader() reader.SetFileName(filename_input) reader.Update() writer = vtk.vtkPLYWriter() writer.SetFileName(filename_output) writer.SetInputConnection(reader.GetOutputPort()) writer.Update()
def write_ply(pd, filename): f = vtk.vtkTriangleFilter() f.SetInputData(pd) f.Update() w = vtk.vtkPLYWriter() w.SetFileName(filename) w.SetInputData(f.GetOutput()) w.SetArrayName("colors") w.SetFileTypeToASCII() w.Update()
def saveMeshAsPly(mesh, name): channel = open(name, 'wb') channel.close() w = vtk.vtkPLYWriter() w.SetInputConnection(mesh.GetOutputPort()) w.SetFileName(name) w.SetFileTypeToBinary() w.SetDataByteOrderToLittleEndian() w.SetColorModeToUniformCellColor() w.SetColor(255, 255, 255) w.Write() print name + 'saved ...'
def niftiMask2Surface(img_path, surf_name, smooth_iter=10, filetype="vtk"): # import the binary nifti image reader = vtk.vtkNIFTIImageReader() reader.SetFileName(img_path) reader.Update() # do marching cubes to create a surface surface = vtk.vtkDiscreteMarchingCubes() surface.SetInputConnection(reader.GetOutputPort()) # GenerateValues(number of surfaces, label range start, label range end) surface.GenerateValues(1, 1, 1) surface.Update() smoother = vtk.vtkWindowedSincPolyDataFilter() smoother.SetInputConnection(surface.GetOutputPort()) smoother.SetNumberOfIterations(smooth_iter) smoother.NonManifoldSmoothingOn() smoother.NormalizeCoordinatesOn() smoother.Update() connectivityFilter = vtk.vtkPolyDataConnectivityFilter() connectivityFilter.SetInputConnection(smoother.GetOutputPort()) connectivityFilter.SetExtractionModeToLargestRegion() connectivityFilter.Update() cleaned = vtk.vtkCleanPolyData() cleaned.SetInputConnection(connectivityFilter.GetOutputPort()) cleaned.Update() # doesn't work, but may need in future # close_holes = vtk.vtkFillHolesFilter() # close_holes.SetInputConnection(smoother.GetOutputPort()) # close_holes.SetHoleSize(10) # close_holes.Update() if filetype == "stl": writer = vtk.vtkSTLWriter() writer.SetInputConnection(cleaned.GetOutputPort()) writer.SetFileTypeToASCII() writer.SetFileName(surf_name) writer.Write() if filetype == "ply": writer = vtk.vtkPLYWriter() writer.SetInputConnection(cleaned.GetOutputPort()) writer.SetFileTypeToASCII() writer.SetFileName(surf_name) writer.Write() if filetype == "vtk": writer = vtk.vtkPolyDataWriter() #writer = vtk.vtkDataSetWriter() writer.SetInputConnection(cleaned.GetOutputPort()) writer.SetFileName(surf_name) writer.Write()
def WritePLYSurfaceFile(self): if (self.OutputFileName == ''): self.PrintError('Error: no OutputFileName.') self.PrintLog('Writing PLY surface file.') writer = vtk.vtkPLYWriter() writer.SetInputData(self.Surface) writer.SetFileName(self.OutputFileName) if self.Mode == "binary": writer.SetFileTypeToBinary() elif self.Mode == "ascii": writer.SetFileTypeToASCII() writer.Write()
def save_mesh_ply(polydata, fn, color=(255, 255, 255)): # Export to rgb PLY file (STL file can not have color info) # https://github.com/Kitware/VTK/blob/master/IO/PLY/Testing/Python/TestPLYReadWrite.py#L31 # http://www.vtk.org/doc/nightly/html/classvtkPLYWriter.html#aa7f0bdbb2decdc7a7360a890a6c10e8b writer = vtk.vtkPLYWriter() writer.SetFileName(fn) writer.SetInputData(polydata) writer.SetColorModeToUniformColor() writer.SetColor(color[0], color[1], color[2]) writer.SetFileTypeToASCII() writer.Write()
def ply_exporter(mesh, file_path, binary=False, **kwargs): r""" Given a file path to write in to write out the mesh data. No value is returned. Only file paths are supported and if a file handle is passed it will be ignored and a warning will be raised. Note that this does not save out textures of textured images, and so should not be used in isolation. Parameters ---------- file_path : `str` The full path where the obj will be saved out. mesh : :map:`TriMesh` Any subclass of :map:`TriMesh`. If :map:`TexturedTriMesh` texture coordinates will be saved out. Note that :map:`ColouredTriMesh` will only have shape data saved out, as .PLY doesn't robustly support per-vertex colour information. binary: `bool`, optional Specify whether to format output in binary or ascii, defaults to False """ import vtk from vtk.util.numpy_support import numpy_to_vtk, numpy_to_vtkIdTypeArray file_path = _enforce_only_paths_supported(file_path, 'PLY') polydata = vtk.vtkPolyData() points = vtk.vtkPoints() points.SetData(numpy_to_vtk(mesh.points)) polydata.SetPoints(points) cells = vtk.vtkCellArray() counts = np.empty((mesh.trilist.shape[0], 1), dtype=np.int) counts.fill(3) tris = np.concatenate((counts, mesh.trilist), axis=1) cells.SetCells(mesh.trilist.shape[0], numpy_to_vtkIdTypeArray(tris)) polydata.SetPolys(cells) if isinstance(mesh, TexturedTriMesh): pointdata = polydata.GetPointData() pointdata.SetTCoords(numpy_to_vtk(mesh.tcoords.points)) ply_writer = vtk.vtkPLYWriter() ply_writer.SetFileName(str(file_path)) ply_writer.SetInputData(polydata) if not binary: ply_writer.SetFileTypeToASCII() else: ply_writer.SetFileTypeToBinary() ply_writer.Update() ply_writer.Write()
def chooseWriter(self, file_format, vtk_dataset_type): """ Return a writer based on file_format and possibly vtk_dataset_type. @param vtk_dataset_type, None or one of the VTK_DATASET_TYPES """ if file_format == 'ply': return vtk.vtkPLYWriter() # For now we'll just return the POLYDATA writer since methods work # only with that vtk_dataset_type. return vtk.vtkPolyDataWriter() if vtk_dataset_type == 'STRUCTURED_GRID': return vtk.vtkStructuredGridWriter() elif vtk_dataset_type == 'POLYDATA': return vtk.vtkPolyDataWriter() elif vtk_dataset_type == 'UNSTRUCTURED_GRID': return vtk.vtkUnstructuredGridWriter()
def writePLY(mesh, name): try: writer = vtk.vtkPLYWriter() if vtk.vtkVersion.GetVTKMajorVersion() >= 6: writer.SetInputData( mesh ) else: writer.SetInput( mesh ) writer.SetFileTypeToBinary() writer.SetFileName( name ) writer.Write() print "Output mesh:", name writer = None except: print "PLY mesh writer 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 getWriter(self,polyData): writer = None; if self.destFormat == "ply": writer = vtk.vtkPLYWriter(); writer.SetFileTypeToBinary(); elif self.destFormat == "stl": writer = vtk.vtkSTLWriter(); writer.SetFileTypeToBinary(); elif self.destFormat == "vtp": writer = vtk.vtkXMLPolyDataWriter(); writer.SetDataModeToBinary(); elif self.destFormat == "obj": writer = VTKOBJWriter(); elif self.destFormat == "json": writer = my_vtkGeoJSONWriter(); else: raise IOError("Export {} is not supported currently".format(self.destFormat)); writer.SetFileName(self.dest); writer.SetInputData(polyData); return writer;
def writeMeshFile(triangles, filename, binary=True, verbose=False): """Write mesh file. The output format is determined by file name extension. Files can be written in binary (default) and ASCII format.""" outformat = path.splitext(options.outfilename)[1].strip('.') # set writer based on filename extension if outformat=='stl': write = vtk.vtkSTLWriter() elif outformat=='vtk': write = vtk.vtkPolyDataWriter() elif outformat=='obj': write = vtk.vtkMNIObjectWriter() elif outformat=='ply': write = vtk.vtkPLYWriter() elif outformat=='vtp': write = vtk.vtkXMLPolyDataWriter() elif outformat=='tag': write = vtk.vtkMNITagPointWriter() else: raise ValueError('cannot write output format' + outformat) write.SetInputConnection(triangles.GetOutputPort()) if outformat!='tag': if binary: if verbose: print('setting ouptut to binary') write.SetFileTypeToBinary() else: if verbose: print('setting ouptut to ascii') write.SetFileTypeToASCII() write.SetFileName(filename) err = write.Write() if err != 1: raise IOError('failed to write') if verbose: print("wrote", filename) pass
# Check if the input directory exists if not os.path.isdir(input_folder_name): print("Error: input directory '" + input_folder_name + "' does not exist") exit() # Check if the output directory exists if not os.path.isdir(output_folder_name): print("Error: output directory '" + output_folder_name + "' does not exist") exit() print("\nthe .ply meshes will be saved in " + output_folder_name) # The IO objects obj_reader = OBJReader() ply_writer = vtk.vtkPLYWriter() ply_writer.SetFileTypeToBinary() # First of all, we collect the names of the OBJ files obj_file_names = list() # Get the file names of the OBJ meshes in the provided folder for file_name in os.listdir(input_folder_name): full_file_name = os.path.join(input_folder_name, file_name) # We want files only if not os.path.isfile(full_file_name): continue # Get the file extension (in lower case) file_ext = os.path.splitext(file_name)[1].lower() # We want OBJ files only if file_ext != ".obj":
filename = "plyWriter.ply" channel = open(filename, "wb") channel.close() ss = vtk.vtkSphereSource() ss.SetPhiResolution(10) ss.SetThetaResolution(20) ele = vtk.vtkSimpleElevationFilter() 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:
import vtk filename = "writeply.ply" sphereSource = vtk.vtkSphereSource() sphereSource.Update() plyWriter = vtk.vtkPLYWriter() plyWriter.SetFileName(filename) plyWriter.SetInputConnection(sphereSource.GetOutputPort()) plyWriter.Write() #Read and display for verication 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(.3, .6, .3) #Background color green
def write_poly(polygons, filename): plyWriter = vtkPLYWriter() plyWriter.SetFileName(filename) plyWriter.SetInputConnection(polygons.GetOutputPort()) plyWriter.Write()
def run(self): logging.info('') # self.iren.Start() if self._output['movie_preflight']: create_survey_movie(self, survey_mesh=False, nsteps=self._output['preflight_nsteps'], fps=self._output['preflight_fps']) if self._output['movie']: pp = mabdi.PostProcess( movie={'scenario': True, 'depth_images': True, 'plots': True, 'param_fps': self._output['movie_fps']}, scenario_render_window=self.renWin, filter_classifier=self.classifier, length_of_path=len(self.position), global_mesh=self.mesh, file_prefix=self._file_prefix, savefig_at_frame=self._output['movie_savefig_at_frame']) # if a dynamic environment, set the initial state deintst = self._sim_param['dynamic_environment_init_state'] if deintst: for i, obj_state in enumerate(deintst): self.source.set_object_state(object_id=i, state=obj_state) self.source.Update() # dynamic environment controls de = self._sim_param['dynamic_environment'] # dynamic environment defn, deobjn = zip(*de) # frame number, objnumber for i, (pos, lka) in enumerate(zip(self.position, self.lookat)): logging.debug('START MAIN LOOP') start = timer() self.di.set_sensor_orientation(pos, lka) self.sdi.set_sensor_orientation(pos, lka) if i in defn: ind = defn.index(i) self.source.set_object_state(object_id=deobjn[ind], state=True) self.source.Update() logging.debug('di.Modified()') self.di.Modified() logging.debug('sdi.Modified()') self.sdi.Modified() logging.debug('classifier.Update()') self.classifier.Update() logging.debug('mesh.Update()') self.mesh.Update() logging.debug('iren.Render()') self.iren.Render() if self._output['movie']: pp.collect_info() if self._sim_param['interactive']: self.iren.Start() end = timer() logging.debug('END MAIN LOOP time {:.4f} seconds'.format(end - start)) if self._output['movie']: pp.save_movie() if self._output['movie_postflight']: create_survey_movie(self, survey_mesh=True, nsteps=self._output['postflight_nsteps'], fps=self._output['postflight_fps']) # mabdi.MovieNamesList.write_movie_list(self._file_prefix) # has a bug if self._output['save_global_mesh']: plywriter = vtk.vtkPLYWriter() plywriter.SetFileName(self._file_prefix + 'global_mesh.ply') plywriter.SetInputConnection(self.mesh.GetOutputPort()) plywriter.Write() pp.save_plots() """ Exit gracefully """ self.di.kill_render_window() self.sdi.kill_render_window() self.iren.GetRenderWindow().Finalize() self.iren.TerminateApp() del self.renWin, self.iren
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()
import sys import vtk import ca_smoothing stl = vtk.vtkSTLReader() stl.SetFileName(sys.argv[1]) stl.Update() normals = vtk.vtkPolyDataNormals() normals.SetInput(stl.GetOutput()) normals.ComputeCellNormalsOn() normals.Update() clean = vtk.vtkCleanPolyData() clean.SetInput(normals.GetOutput()) clean.Update() pd = clean.GetOutput() pd.BuildLinks() tpd = ca_smoothing.ca_smoothing(pd, 0.7, 3, 0.2, 10) ply = vtk.vtkPLYWriter() ply.SetFileName(sys.argv[2]) ply.SetInput(tpd) ply.Write()
# Very important! The following values are for the virtual fish project voxel_size = [0.798, 0.798, 2.0] print("\nIMPORTANT: using the following voxel size: " + str(voxel_size[0]) + ", " + str(voxel_size[1]) + ", " + str(voxel_size[2])) print("the meshes will be saved in " + output_folder_name) # The VTK stuff img_reader = vtk.vtkTIFFReader() # Gaussian image filter img_smoother = vtk.vtkImageGaussianSmooth() img_smoother.SetDimensionality(3) img_smoother.SetRadiusFactor(3) # Marching cubes marching_cubes = vtk.vtkImageMarchingCubes() marching_cubes.SetValue(0, 128) # Mesh writer mesh_writer = vtk.vtkPLYWriter() # First of all, we collect the names of the tiff files tiff_file_names = list() # Get the file names of the tif images in the provided folder for file_name in os.listdir(input_folder_name): full_file_name = os.path.join(input_folder_name, file_name) # We want files only if not os.path.isfile(full_file_name): continue # Get the file extension (in lower case) file_ext = os.path.splitext(file_name)[1].lower()
def AddNewActor(self, pubsub_evt): """ Create surface actor, save into project and send it to viewer. """ slice_, mask, surface_parameters = pubsub_evt.data matrix = slice_.matrix filename_img = slice_.matrix_filename spacing = slice_.spacing algorithm = surface_parameters['method']['algorithm'] options = surface_parameters['method']['options'] surface_name = surface_parameters['options']['name'] quality = surface_parameters['options']['quality'] fill_holes = surface_parameters['options']['fill'] keep_largest = surface_parameters['options']['keep_largest'] mode = 'CONTOUR' # 'GRAYSCALE' min_value, max_value = mask.threshold_range colour = mask.colour try: overwrite = surface_parameters['options']['overwrite'] except KeyError: overwrite = False mask.matrix.flush() if quality in const.SURFACE_QUALITY.keys(): imagedata_resolution = const.SURFACE_QUALITY[quality][0] smooth_iterations = const.SURFACE_QUALITY[quality][1] smooth_relaxation_factor = const.SURFACE_QUALITY[quality][2] decimate_reduction = const.SURFACE_QUALITY[quality][3] #if imagedata_resolution: #imagedata = iu.ResampleImage3D(imagedata, imagedata_resolution) pipeline_size = 4 if decimate_reduction: pipeline_size += 1 if (smooth_iterations and smooth_relaxation_factor): pipeline_size += 1 if fill_holes: pipeline_size += 1 if keep_largest: pipeline_size += 1 ## Update progress value in GUI UpdateProgress = vu.ShowProgress(pipeline_size) UpdateProgress(0, _("Creating 3D surface...")) language = ses.Session().language if (prj.Project().original_orientation == const.CORONAL): flip_image = False else: flip_image = True n_processors = multiprocessing.cpu_count() pipe_in, pipe_out = multiprocessing.Pipe() o_piece = 1 piece_size = 2000 n_pieces = int(round(matrix.shape[0] / piece_size + 0.5, 0)) q_in = multiprocessing.Queue() q_out = multiprocessing.Queue() p = [] for i in xrange(n_processors): sp = surface_process.SurfaceProcess(pipe_in, filename_img, matrix.shape, matrix.dtype, mask.temp_file, mask.matrix.shape, mask.matrix.dtype, spacing, mode, min_value, max_value, decimate_reduction, smooth_relaxation_factor, smooth_iterations, language, flip_image, q_in, q_out, algorithm != 'Default', algorithm, imagedata_resolution) p.append(sp) sp.start() for i in xrange(n_pieces): init = i * piece_size end = init + piece_size + o_piece roi = slice(init, end) q_in.put(roi) print "new_piece", roi for i in p: q_in.put(None) none_count = 1 while 1: msg = pipe_out.recv() if(msg is None): none_count += 1 else: UpdateProgress(msg[0]/(n_pieces * pipeline_size), msg[1]) if none_count > n_pieces: break polydata_append = vtk.vtkAppendPolyData() # polydata_append.ReleaseDataFlagOn() t = n_pieces while t: filename_polydata = q_out.get() reader = vtk.vtkXMLPolyDataReader() reader.SetFileName(filename_polydata) # reader.ReleaseDataFlagOn() reader.Update() # reader.GetOutput().ReleaseDataFlagOn() polydata = reader.GetOutput() # polydata.SetSource(None) polydata_append.AddInputData(polydata) del reader del polydata t -= 1 polydata_append.Update() # polydata_append.GetOutput().ReleaseDataFlagOn() polydata = polydata_append.GetOutput() #polydata.Register(None) # polydata.SetSource(None) del polydata_append if algorithm == 'ca_smoothing': normals = vtk.vtkPolyDataNormals() normals_ref = weakref.ref(normals) normals_ref().AddObserver("ProgressEvent", lambda obj,evt: UpdateProgress(normals_ref(), _("Creating 3D surface..."))) normals.SetInputData(polydata) # normals.ReleaseDataFlagOn() #normals.SetFeatureAngle(80) #normals.AutoOrientNormalsOn() normals.ComputeCellNormalsOn() # normals.GetOutput().ReleaseDataFlagOn() normals.Update() del polydata polydata = normals.GetOutput() # polydata.SetSource(None) del normals clean = vtk.vtkCleanPolyData() # clean.ReleaseDataFlagOn() # clean.GetOutput().ReleaseDataFlagOn() clean_ref = weakref.ref(clean) clean_ref().AddObserver("ProgressEvent", lambda obj,evt: UpdateProgress(clean_ref(), _("Creating 3D surface..."))) clean.SetInputData(polydata) clean.PointMergingOn() clean.Update() del polydata polydata = clean.GetOutput() # polydata.SetSource(None) del clean # try: # polydata.BuildLinks() # except TypeError: # polydata.BuildLinks(0) # polydata = ca_smoothing.ca_smoothing(polydata, options['angle'], # options['max distance'], # options['min weight'], # options['steps']) mesh = cy_mesh.Mesh(polydata) cy_mesh.ca_smoothing(mesh, options['angle'], options['max distance'], options['min weight'], options['steps']) # polydata = mesh.to_vtk() # polydata.SetSource(None) # polydata.DebugOn() w = vtk.vtkPLYWriter() w.SetInputData(polydata) w.SetFileName('/tmp/ca_smoothing_inv.ply') w.Write() else: #smoother = vtk.vtkWindowedSincPolyDataFilter() smoother = vtk.vtkSmoothPolyDataFilter() smoother_ref = weakref.ref(smoother) smoother_ref().AddObserver("ProgressEvent", lambda obj,evt: UpdateProgress(smoother_ref(), _("Creating 3D surface..."))) smoother.SetInputData(polydata) smoother.SetNumberOfIterations(smooth_iterations) smoother.SetRelaxationFactor(smooth_relaxation_factor) smoother.SetFeatureAngle(80) #smoother.SetEdgeAngle(90.0) #smoother.SetPassBand(0.1) smoother.BoundarySmoothingOn() smoother.FeatureEdgeSmoothingOn() #smoother.NormalizeCoordinatesOn() #smoother.NonManifoldSmoothingOn() # smoother.ReleaseDataFlagOn() # smoother.GetOutput().ReleaseDataFlagOn() smoother.Update() del polydata polydata = smoother.GetOutput() #polydata.Register(None) # polydata.SetSource(None) del smoother if decimate_reduction: print "Decimating", decimate_reduction decimation = vtk.vtkQuadricDecimation() # decimation.ReleaseDataFlagOn() decimation.SetInputData(polydata) decimation.SetTargetReduction(decimate_reduction) decimation_ref = weakref.ref(decimation) decimation_ref().AddObserver("ProgressEvent", lambda obj,evt: UpdateProgress(decimation_ref(), _("Creating 3D surface..."))) #decimation.PreserveTopologyOn() #decimation.SplittingOff() #decimation.BoundaryVertexDeletionOff() # decimation.GetOutput().ReleaseDataFlagOn() decimation.Update() del polydata polydata = decimation.GetOutput() #polydata.Register(None) # polydata.SetSource(None) del decimation to_measure = polydata #to_measure.Register(None) # to_measure.SetSource(None) if keep_largest: conn = vtk.vtkPolyDataConnectivityFilter() conn.SetInputData(polydata) conn.SetExtractionModeToLargestRegion() conn_ref = weakref.ref(conn) conn_ref().AddObserver("ProgressEvent", lambda obj,evt: UpdateProgress(conn_ref(), _("Creating 3D surface..."))) conn.Update() # conn.GetOutput().ReleaseDataFlagOn() del polydata polydata = conn.GetOutput() #polydata.Register(None) # polydata.SetSource(None) del conn #Filter used to detect and fill holes. Only fill boundary edges holes. #TODO: Hey! This piece of code is the same from #polydata_utils.FillSurfaceHole, we need to review this. if fill_holes: filled_polydata = vtk.vtkFillHolesFilter() # filled_polydata.ReleaseDataFlagOn() filled_polydata.SetInputData(polydata) filled_polydata.SetHoleSize(300) filled_polydata_ref = weakref.ref(filled_polydata) filled_polydata_ref().AddObserver("ProgressEvent", lambda obj,evt: UpdateProgress(filled_polydata_ref(), _("Creating 3D surface..."))) filled_polydata.Update() # filled_polydata.GetOutput().ReleaseDataFlagOn() del polydata polydata = filled_polydata.GetOutput() #polydata.Register(None) # polydata.SetSource(None) # polydata.DebugOn() del filled_polydata normals = vtk.vtkPolyDataNormals() # normals.ReleaseDataFlagOn() normals_ref = weakref.ref(normals) normals_ref().AddObserver("ProgressEvent", lambda obj,evt: UpdateProgress(normals_ref(), _("Creating 3D surface..."))) normals.SetInputData(polydata) normals.SetFeatureAngle(80) normals.AutoOrientNormalsOn() # normals.GetOutput().ReleaseDataFlagOn() normals.Update() del polydata polydata = normals.GetOutput() #polydata.Register(None) # polydata.SetSource(None) del normals # Improve performance stripper = vtk.vtkStripper() # stripper.ReleaseDataFlagOn() stripper_ref = weakref.ref(stripper) stripper_ref().AddObserver("ProgressEvent", lambda obj,evt: UpdateProgress(stripper_ref(), _("Creating 3D surface..."))) stripper.SetInputData(polydata) stripper.PassThroughCellIdsOn() stripper.PassThroughPointIdsOn() # stripper.GetOutput().ReleaseDataFlagOn() stripper.Update() del polydata polydata = stripper.GetOutput() #polydata.Register(None) # polydata.SetSource(None) del stripper # Map polygonal data (vtkPolyData) to graphics primitives. mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(polydata) mapper.ScalarVisibilityOff() # mapper.ReleaseDataFlagOn() mapper.ImmediateModeRenderingOn() # improve performance # Represent an object (geometry & properties) in the rendered scene actor = vtk.vtkActor() actor.SetMapper(mapper) del mapper #Create Surface instance if overwrite: surface = Surface(index = self.last_surface_index) else: surface = Surface(name=surface_name) surface.colour = colour surface.polydata = polydata del polydata # Set actor colour and transparency actor.GetProperty().SetColor(colour) actor.GetProperty().SetOpacity(1-surface.transparency) prop = actor.GetProperty() interpolation = int(ses.Session().surface_interpolation) prop.SetInterpolation(interpolation) proj = prj.Project() if overwrite: proj.ChangeSurface(surface) else: index = proj.AddSurface(surface) surface.index = index self.last_surface_index = index session = ses.Session() session.ChangeProject() # The following lines have to be here, otherwise all volumes disappear measured_polydata = vtk.vtkMassProperties() # measured_polydata.ReleaseDataFlagOn() measured_polydata.SetInputData(to_measure) volume = float(measured_polydata.GetVolume()) area = float(measured_polydata.GetSurfaceArea()) surface.volume = volume surface.area = area self.last_surface_index = surface.index del measured_polydata del to_measure Publisher.sendMessage('Load surface actor into viewer', actor) # Send actor by pubsub to viewer's render if overwrite and self.actors_dict.keys(): old_actor = self.actors_dict[self.last_surface_index] Publisher.sendMessage('Remove surface actor from viewer', old_actor) # Save actor for future management tasks self.actors_dict[surface.index] = actor Publisher.sendMessage('Update surface info in GUI', (surface.index, surface.name, surface.colour, surface.volume, surface.area, surface.transparency)) #When you finalize the progress. The bar is cleaned. UpdateProgress = vu.ShowProgress(1) UpdateProgress(0, _("Ready")) Publisher.sendMessage('Update status text in GUI', _("Ready")) Publisher.sendMessage('End busy cursor') del actor
def abs2asc(abs_file, tex_file,output): ftex = Image.open(tex_file) f = open(abs_file) rows = int(f.readline().split()[0]) cols = int(f.readline().split()[0]) values = [] # Reading the junk line f.readline() numbers = f.read().split() #flags fl = numbers[0: rows * cols] #X coordinates x = numbers[rows * cols: rows * cols * 2] # Y coordinates y = numbers[rows * cols * 2: rows * cols * 3] # Z coordinates z = numbers[rows * cols * 3: rows * cols * 4] for i in xrange(len(fl)): if fl[i] == '1': data.append([x[i], y[i], z[i]]) px = i%cols py = i/cols color_pixel = ftex.getpixel((px,py)) point_colors.append(color_pixel) pointSource.SetExecuteMethod(readPoints) pointSource.GetOutput().GetCellData().SetScalars(colors) pointSource.GetOutput().Update() delaunay = vtk.vtkDelaunay2D() #delaunay.SetTolerance(0.5) delaunay.SetAlpha(2.0) delaunay.SetInput(pointSource.GetOutput()) delaunay.Update() poly = delaunay.GetOutput() w = vtk.vtkPLYWriter() w.SetInput(poly) w.SetFileName(output + ".ply") w.SetFileTypeToASCII() w.SetDataByteOrderToLittleEndian() #w.SetColorModeToUniformPointColor() #w.SetScalarsName("aaa") w.Write() lnumber = 1 count = 0 max_points = len(point_colors) #print max_points for line in fileinput.input(output + ".ply", inplace=1): if lnumber > 11 and count <= max_points - 1: r, g, b = point_colors[count] new_line = line.replace("\n", "") print new_line, r, g, b count += 1 elif(lnumber == 8): print line, "property uchar red\n", "property uchar green\n", "property uchar blue" else: new_line = line.replace("\n", "") print new_line lnumber += 1 print "Terminou >> ", abs_file, ">>" , output + ".ply"