def obj_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 obj_importer = vtk.vtkOBJReader() obj_importer.SetFileName(str(filepath)) obj_importer.Update() # Get the output polydata = obj_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 ReadOBJFile(self, filename): ''' @param filename: str @rtype: None ''' reader = vtk.vtkOBJReader() reader.SetFileName(filename) try: reader.Update() cleanFilter = vtk.vtkCleanPolyData() cleanFilter.SetInput(reader.GetOutput()) cleanFilter.ConvertLinesToPointsOn() cleanFilter.ConvertPolysToLinesOn() cleanFilter.ConvertStripsToPolysOn() cleanFilter.PointMergingOn() cleanFilter.Update() surfaceFilter = vtk.vtkDataSetSurfaceFilter() surfaceFilter.SetInput(cleanFilter.GetOutput()) surfaceFilter.Update() self.setDataSet(surfaceFilter.GetOutput()) del cleanFilter del surfaceFilter except Exception, e: # del reader print e raise IOError, "Could not read the OBJ file! "
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 __init__(self, initial_pos, is_right): # source = vtk.vtkSphereSource() # source.SetRadius(3.0) # cube = vtk.vtkCubeSource() # cube.SetXLength(5) # cube.SetYLength(4) # cube.SetZLength(3) self.reader = vtk.vtkOBJReader() self.reader.SetFileName("shoes.obj") self.vtkPolyData = vtk.vtkPolyData() self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInputConnection(self.reader.GetOutputPort()) self.vtkActor = vtk.vtkActor() self.vtkActor.SetMapper(self.mapper) self.vtkActor.SetPosition(initial_pos) if (is_right): self.vtkActor.SetScale(0.008) self.vtkActor.RotateZ(90) else: self.vtkActor.SetScale(-0.008) self.vtkActor.RotateZ(90) self.vtkActor.RotateX(180)
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkOBJReader(), 'Reading vtkOBJ.', (), ('vtkOBJ',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def addModel(self, modelFilePath: QUrl) -> Model: qDebug('ProcessingEngine::addModel()') modelFilePathExtension = QFileInfo( modelFilePath).suffix().lower() # returns QString objReader = vtk.vtkOBJReader() stlReader = vtk.vtkSTLReader() inputData = None # vtkPolyData if modelFilePathExtension == 'obj': #* Read OBJ file objReader.SetFileName(modelFilePath) objReader.Update() inputData = objReader.GetOutput() else: #* Read STL file stlReader.SetFileName(modelFilePath) stlReader.Update() inputData = stlReader.GetOutput() #* Preprocess the polydata preprocessedPolydata = self.preprocessPolydata( inputData) # vtkPolyData #* Create Model instance and insert it into the vector model = Model(preprocessedPolydata) self.__m_models.append(model) return self.__m_models[-1]
def main(): global INPUT_MODEL, POINTS, KDTREE INPUT_MODEL = vtk.vtkOBJReader() INPUT_MODEL.SetFileName(input_filename) INPUT_MODEL.Update() v_mapper = vtk.vtkPolyDataMapper() v_mapper.SetInputConnection(INPUT_MODEL.GetOutputPort()) v_actor = vtk.vtkActor() v_actor.SetMapper(v_mapper) # get points p = [0.0, 0.0, 0.0] for i in range(INPUT_MODEL.GetOutput().GetNumberOfPoints()): INPUT_MODEL.GetOutput().GetPoint(i, p) POINTS.append(tuple(p)) KDTREE = ss.KDTree(POINTS) ren = vtk.vtkRenderer() ren.AddActor(v_actor) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) style = MouseInteractorPickingActor() style.SetDefaultRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetInteractorStyle(style) iren.SetRenderWindow(renWin) iren.Initialize() iren.Start()
def read_obj_files( number_of_buildings, begin_building_index, end_building_index, lod, files, file_offset): """ Builds a multiblock dataset (similar with one built by the CityGML reader) from a list of OBJ files. """ if number_of_buildings == UNINITIALIZED and begin_building_index != UNINITIALIZED and end_building_index != UNINITIALIZED: building_range = range(begin_building_index, end_building_index) else: building_range = range(0, min(len(files), number_of_buildings)) root = vtk.vtkMultiBlockDataSet() for i in building_range: reader = vtk.vtkOBJReader() reader.SetFileName(files[i]) reader.Update() if i == 0: gdal_utils.read_offset(files[i], file_offset) polydata = reader.GetOutput() if (polydata.GetNumberOfPoints() == 0): logging.warning("Empty OBJ file: {}".format(files[i])) continue texture_file = get_obj_texture_file_name(files[i]) set_field(polydata, "texture_uri", texture_file) building = vtk.vtkMultiBlockDataSet() building.SetBlock(0, polydata) root.SetBlock(root.GetNumberOfBlocks(), building) return root
def read_obj(filename): """Test to read and display a wavefront OBJ """ reader = vtk.vtkOBJReader() reader.SetFileName(filename) mapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: mapper.SetInput(reader.GetOutput()) else: mapper.SetInputConnection(reader.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.AddActor(actor) iren.Initialize() renWin.Render() iren.Start()
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 load_polydata(file_name): # get file extension (type) file_extension = file_name.split(".")[-1].lower() # todo better generic load if file_extension == "vtk": reader = vtk.vtkPolyDataReader() elif file_extension == "vtp": reader = vtk.vtkPolyDataReader() elif file_extension == "fib": reader = vtk.vtkPolyDataReader() elif file_extension == "ply": reader = vtk.vtkPLYReader() elif file_extension == "stl": reader = vtk.vtkSTLReader() elif file_extension == "xml": reader = vtk.vtkXMLPolyDataReader() elif file_extension == "obj": reader = vtk.vtkOBJReader() #try: # try to read as a normal obj # reader = vtk.vtkOBJReader() #except: # than try load a MNI obj format # reader = vtk.vtkMNIObjectReader() else: raise "polydata " + file_extension + " is not suported" reader.SetFileName(file_name) reader.Update() print file_name, " Mesh ", file_extension, "Loaded" return reader.GetOutput()
def load_points_from_file(filename): """ Extract vtk mesh from input file. :returns: Vtk mesh. """ if not os.path.exists(filename): raise ValueError(f'File {filename} does not exist') fileType = filename[-4:].lower() if fileType == ".stl": reader = vtk.vtkSTLReader() elif fileType == ".obj": reader = vtk.vtkOBJReader() elif fileType == ".vtk": reader = vtk.vtkPolyDataReader() elif fileType == ".vtu": reader = vtk.vtkXMLUnstructuredGridReader() elif fileType == ".vtp": reader = vtk.vtkXMLPolyDataReader() else: raise IOError( "Mesh should be .vtk, .vtu, .vtp, .obj, .stl file!") reader.SetFileName(filename) reader.Update() mesh = reader.GetOutput() return mesh
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 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 loadMesh(path, scale): # Read in STL meshPath = cleanResourcePath(path) extension = os.path.splitext(path)[1] if extension == ".stl" or extension == ".STL": meshInput = vtk.vtkSTLReader() meshInput.SetFileName(path) meshReader = vtk.vtkTextureMapToPlane() meshReader.SetInputConnection(meshInput.GetOutputPort()) elif extension == ".obj" or extension == ".OBJ": meshReader = vtk.vtkOBJReader() meshReader.SetFileName(path) else: ROS_FATAL("Mesh file has invalid extension (" + extension + ")") # Scale STL transform = vtk.vtkTransform() transform.Scale(scale, scale, scale) # transform.RotateWXYZ(rot[1], rot[2], rot[3], rot[0]) # transform.Translate(pos[0],pos[1], pos[2]) transformFilter = vtk.vtkTransformFilter() transformFilter.SetTransform(transform) transformFilter.SetInputConnection(meshReader.GetOutputPort()) transformFilter.Update() return transformFilter.GetOutput()
def setMeshPath(self, meshPath, scale): self.meshPath = meshPath self.scale = scale # Set up 3D actor for organ meshPath = cleanResourcePath(self.meshPath) extension = os.path.splitext(meshPath)[1] if extension == ".stl" or extension == ".STL": meshReader = vtk.vtkSTLReader() elif extension == ".obj" or extension == ".OBJ": meshReader = vtk.vtkOBJReader() else: ROS_FATAL("Mesh file has invalid extension (" + extension + ")") meshReader.SetFileName(meshPath) # Scale STL transform = vtk.vtkTransform() transform.Scale(scale, scale, scale) transformFilter = vtk.vtkTransformFilter() transformFilter.SetTransform(transform) transformFilter.SetInputConnection(meshReader.GetOutputPort()) transformFilter.Update() color = (0,0,1) self._updateActorPolydata(self.actor_moving, polydata=transformFilter.GetOutput(), color = color) if image is not None: # Set texture to default image = cv2.imread(cleanResourcePath(self.texturePath)) self.actor_moving.setTexture(image) self.actor_moving.textureOnOff(True)
def write_obj(infile='./data/itokawa_low.obj', outfile='./data/point_clouds/itokawa_low_vtkwriter'): """Read from a OBJ and then write to a different one """ reader = vtk.vtkOBJReader() reader.SetFileName(infile) # write the stl file to a disk objWriter = vtk.vtkOBJExporter() objWriter.SetFilePrefix(outfile) mapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: mapper.SetInput(reader.GetOutput()) else: mapper.SetInputConnection(reader.GetOutputPort()) 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.Initialize() renWin.Render() iren.Start() objWriter.SetRenderWindow(renWin) objWriter.Write()
def get_polydata(self): if not self.enabled: return None if self.polydata is None: if self.parent.status_callback is not None: self.parent.status_callback( 'Loading mesh file: {:s}...'.format( os.path.split(self.filename)[1])) if self.filetype == 'stl': reader = vtk.vtkSTLReader() elif self.filetype == 'obj': reader = vtk.vtkOBJReader() reader.SetFileName(self.filename) reader.Update() scaler = vtk.vtkTransformPolyDataFilter() scale_transform = vtk.vtkTransform() scale_transform.Scale(self.scale, self.scale, self.scale) scaler.SetInputData(reader.GetOutput()) scaler.SetTransform(scale_transform) scaler.Update() self.polydata = scaler.GetOutput() if self.parent.status_callback is not None: self.parent.status_callback(None) return self.polydata
def 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 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 unpack_sdf_vtk_samples(filename, num_points=1000): reader = vtk.vtkOBJReader() reader.SetFileName(filename) reader.Update() polydata = reader.GetOutput() pdd = vtk.vtkImplicitPolyDataDistance() pdd.SetInput(polydata) sdf = [] closestPoints = [] vectors = [] F=3 V = np.random.uniform(-1,1,(int(num_points),F)) for i in range(int(num_points)): closestPoint = np.zeros(3) distance = pdd.EvaluateFunctionAndGetClosestPoint(V[i,:],closestPoint) sdf.append(distance) vector_gt = np.subtract(V[i,:],closestPoint) closestPoints.append(closestPoint) vectors.append(vector_gt) vectors = np.stack(vectors) vectors = np.reshape(vectors,(vectors.shape[0],-1)) sdf = np.stack(sdf) sdf = np.reshape(sdf,(sdf.shape[0],-1)) samples = np.concatenate((V,sdf,vectors),axis=1) samples = torch.from_numpy(samples).float() return samples
def __init__(self, module_manager): """Constructor (initialiser) for the PD reader. This is almost standard code for most of the modules making use of the FilenameViewModuleMixin mixin. """ # call the constructor in the "base" ModuleBase.__init__(self, module_manager) # setup necessary VTK objects self._reader = vtk.vtkOBJReader() # ctor for this specific mixin FilenameViewModuleMixin.__init__( self, 'Select a filename', 'Wavefront OBJ data (*.obj)|*.obj|All files (*)|*', {'vtkOBJReader': self._reader}) module_utils.setup_vtk_object_progress(self, self._reader, 'Reading Wavefront OBJ data') # set up some defaults self._config.filename = '' self.sync_module_logic_with_config()
def obj_importer(filepath, asset=None, texture_resolver=None, **kwargs): obj_importer = vtk.vtkOBJReader() obj_importer.SetFileName(str(filepath)) obj_importer.Update() # Get the output polydata = obj_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 obj_to_numpy(filename): """Convert OBJ to a numpy array https://stackoverflow.com/questions/23138112/vtk-to-maplotlib-using-numpy """ reader = vtk.vtkOBJReader() reader.SetFileName(filename) reader.Update() output = reader.GetOutput() points = output.GetPoints() verts = numpy_support.vtk_to_numpy(points.GetData()) mapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: mapper.SetInput(reader.GetOutput()) else: mapper.SetInputConnection(reader.GetOutputPort()) 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.Initialize() renWin.Render() iren.Start() return verts
def load_OBJ(filename): """Loads Wavefront OBJ file format. It relies on the reader from the VTK library. Parameters ---------- filename: str name of the mesh file on disk Returns ------- vertices: ndarray numpy array of the coordinates of the mesh's nodes faces: ndarray numpy array of the faces' nodes connectivities Note ---- VTU files have a 0-indexing """ _check_file(filename) from vtk import vtkOBJReader reader = vtkOBJReader() reader.SetFileName(filename) reader.Update() vtk_mesh = reader.GetOutput() vertices, faces = _dump_vtk(vtk_mesh) return vertices, faces
def Model(model_path, model_image_path=None): if model_path[-4:].lower() == '.obj': reader = vtk.vtkOBJReader() reader.SetFileName(model_path) reader.Update() polyData = reader.GetOutput() mapper = vtk.vtkPolyDataMapper() mapper.SetInput(polyData) objActor = vtk.vtkActor() objActor.SetMapper(mapper) # texture from image if model_image_path is not None: texture = vtk.vtkTexture() if model_image_path[-4:].lower( ) == '.jpg' or model_image_path[-4:].lower() == '.jpeg': jpgReader = vtk.vtkJPEGReader() jpgReader.SetFileName(model_image_path) jpgReader.Update() texture.SetInputConnection(jpgReader.GetOutputPort()) elif model_image_path[-4:].lower() == '.png': pngReader = vtk.vtkPNGReader() pngReader.SetFileName(model_image_path) pngReader.Update() texture.SetInputConnection(pngReader.GetOutputPort()) objActor.SetTexture(texture) return objActor
def CanReadFile(self, filename): ''' Static methods for I/O @param filename: str @rtype: unsigned int ''' if self.IsMeshExtension(os.path.splitext(filename)[1]): return self.FILE_IS_VTK if self.IsOBJExtension(os.path.splitext(filename)[1]): reader = vtk.vtkOBJReader() reader.SetFileName(filename) try: reader.Update() except: # del reader return 0 # del reader return self.FILE_IS_OBJ if not self.IsVtkExtension(os.path.splitext(filename)[1]): return 0 try: reader = vtk.vtkPolyDataReader() reader.SetFileName(filename) if reader.IsFilePolyData(): # del reader return self.FILE_IS_VTK # del reader except: pass return 0
def load_vtk_mesh(fileName): """ Loads surface/volume mesh to VTK """ if (fileName == ''): return 0 fn_dir, fn_ext = os.path.splitext(fileName) if (fn_ext == '.vtk'): print('Reading vtk with name: ', fileName) reader = vtk.vtkPolyDataReader() elif (fn_ext == '.vtp'): print('Reading vtp with name: ', fileName) reader = vtk.vtkXMLPolyDataReader() elif (fn_ext == '.stl'): print('Reading stl with name: ', fileName) reader = vtk.vtkSTLReader() elif (fn_ext == '.obj'): print('Reading obj with name: ', fileName) reader = vtk.vtkOBJReader() elif (fn_ext == '.vtu'): print('Reading vtu with name: ', fileName) reader = vtk.vtkXMLUnstructuredGridReader() elif (fn_ext == '.pvtu'): print('Reading pvtu with name: ', fileName) reader = vtk.vtkXMLPUnstructuredGridReader() else: print(fn_ext) raise ValueError('File extension not supported') reader.SetFileName(fileName) reader.Update() return reader.GetOutput()
def makeTexturedObjData(objPath, scale=1): """ Loads .obj into VTK polyData optimized for searching texture space. Args: objPath (string): File path to .obj file to load Returns: polyData (vtk.vtkPolyData): VTK polyData object optimized for finding mapping from 2D texture coordinates to 3D world coordinates """ meshReader = vtk.vtkOBJReader() meshReader.SetFileName(objPath) triFilter = vtk.vtkTriangleFilter() if vtk.VTK_MAJOR_VERSION <= 5: triFilter.SetInput(meshReader.GetOutput()) else: triFilter.SetInputConnection(meshReader.GetOutputPort()) transform = vtk.vtkTransform() transform.Scale(scale,scale,scale) transformFilter=vtk.vtkTransformPolyDataFilter() transformFilter.SetTransform(transform) if vtk.VTK_MAJOR_VERSION <= 5: triFilter.SetInput(meshReader.GetOutput()) else: transformFilter.SetInputConnection(triFilter.GetOutputPort()) normalGenerator = vtk.vtkPolyDataNormals() normalGenerator.ComputePointNormalsOn() normalGenerator.ComputeCellNormalsOn() if vtk.VTK_MAJOR_VERSION <= 5: normalGenerator.SetInput(transformFilter.GetOutput()) else: normalGenerator.SetInputConnection(transformFilter.GetOutputPort()) normalGenerator.Update() polyData = normalGenerator.GetOutput() return polyData
def vtk_read(path): reader = vtk.vtkOBJReader() reader.SetFileName(path) reader.Update() pdata = reader.GetOutput() # check if the stl file is closed featureEdge = vtk.vtkFeatureEdges() featureEdge.FeatureEdgesOff() featureEdge.BoundaryEdgesOn() featureEdge.NonManifoldEdgesOn() featureEdge.SetInputData(pdata) featureEdge.Update() # pass pdata through a triangle filter tr = vtk.vtkTriangleFilter() tr.SetInputData(pdata) tr.PassVertsOff() tr.PassLinesOff() tr.Update() # normals filter pnormal = vtk.vtkPolyDataNormals() pnormal.SetInputData(tr.GetOutput()) pnormal.AutoOrientNormalsOff() pnormal.ComputePointNormalsOn() pnormal.ComputeCellNormalsOff() pnormal.SplittingOff() pnormal.ConsistencyOn() pnormal.FlipNormalsOn() pnormal.Update() pdata = pnormal.GetOutput() # create a vtkSelectEnclosedPoints filter filter = vtk.vtkSelectEnclosedPoints() filter.SetSurfaceData(pdata) print(pdata.GetNumberOfPoints()) print(pdata.GetPointData().GetNumberOfTuples()) # print(pdata) obj_points = np.zeros([pdata.GetNumberOfPoints(), 3]) obj_normals = np.zeros([pdata.GetNumberOfPoints(), 3]) polydata = vtk.vtkPolyData() polydata.ShallowCopy(pdata) for i in range(pdata.GetNumberOfPoints()): obj_points[i, :] = pdata.GetPoint(i) obj_normals[i, :] = pdata.GetPointData().GetNormals().GetTuple(i) obj_polygons = numpy.zeros([pdata.GetNumberOfCells(), 3]).astype(np.int) for i in range(pdata.GetNumberOfCells()): cell = vtk.vtkIdList() pdata.GetCellPoints(i, cell) for j in range(3): obj_polygons[i, j] = cell.GetId(j) # print(cell.GetId(j) ) return (obj_points, obj_normals, obj_polygons)
def readOBJECT(self, *args): # create reader reader = vtk.vtkOBJReader() reader.SetFileName(os.path.join(self.directory, args[0])) reader.Update() return reader
def ReadOBJSurfaceFile(self): if (self.InputFileName == ''): self.PrintError('Error: no InputFileName.') self.PrintLog('Reading wavefront surface file.') reader = vtk.vtkOBJReader() reader.SetFileName(self.InputFileName) reader.Update() self.Surface = reader.GetOutput()
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__(self, module_manager, vtk.vtkOBJReader(), 'Reading vtkOBJ.', (), ('vtkOBJ', ), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def loadOBJ(self): """ 初始化,加载模型.obj格式文件 """ self.reader = vtk.vtkOBJReader() self.reader.SetFileName(self.filename) self.reader.Update() self.data = self.reader.GetOutput()
def load_obj(self, obj_file): reader = vtk.vtkOBJReader() reader.SetFileName(obj_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 obj_to_vtk(in_filename, out_filename): # Read the obj file reader = vtk.vtkOBJReader() reader.SetFileName(in_filename) reader.Update() # Write the vtk file writer = vtk.vtkPolyDataWriter() writer.SetFileName(out_filename) writer.SetInputConnection(reader.GetOutputPort()) writer.Write()
def loadOBJforVTK(filenameOBJ): readerOBJ = vtk.vtkOBJReader() readerOBJ.SetFileName(filenameOBJ) # 'update' the reader i.e. read the .stl file readerOBJ.Update() polydata = readerOBJ.GetOutput() # If there are no points in 'vtkPolyData' something went wrong if polydata.GetNumberOfPoints() == 0: raise ValueError( "No point data could be loaded from '" + filenameOBJ) return None return polydata
def readOBJ(self, filename=None): if filename is not None: self.filename = filename r = vtk.vtkOBJReader() 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 CreateCoilReference(self): #SILVER COIL self.coil_reference = vtk.vtkOBJReader() #self.coil_reference.SetFileName(os.path.realpath(os.path.join('..', # 'models', # 'coil_cti_2_scale10.obj'))) self.coil_reference.SetFileName('C:\Users\Biomag\Desktop\invesalius_navigator\icons\coil_cti_2_scale10.obj') ##self.coil_reference.Update() coilMapper = vtk.vtkPolyDataMapper() coilMapper.SetInputConnection(self.coil_reference.GetOutputPort()) self.coilActor = vtk.vtkActor() self.coilActor.SetMapper(coilMapper)
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;
(options, args) = parser.parse_args() assert(len(options.ModelFilename) > 0 ) assert(len(options.TraySizeInMM) == 2 ) TraySizeInMM = [float(sz) for sz in options.TraySizeInMM] assert(len(options.WindowSize) == 2 ) WindowSize = [int(sz) for sz in options.WindowSize] if '.STL' in options.ModelFilename.upper(): Model = vtk.vtkSTLReader() elif '.OBJ' in options.ModelFilename.upper(): Model = vtk.vtkOBJReader() else: raise Exception('Unknown file type for model: %s'%options.ModelFilename) Model.SetFileName(options.ModelFilename) Model.Update() ModelOutput = Model.GetOutput() BoundingBox = ModelOutput.GetBounds() Mapper = vtk.vtkPolyDataMapper() Mapper.SetInputConnection(Model.GetOutputPort()) Actor = vtk.vtkLODActor() Actor.SetMapper(Mapper)
def CurvaturesDemo(self, filePath, nominalRadius): sphere = Sphere(filePath, nominalRadius, False) errors = np.abs(sphere.fittingError()) print sphere.curvature.max() print sphere.curvature.argmax() reader = vtk.vtkOBJReader() reader.SetFileName(sys.argv[1]) reader.Update() # Colour transfer function. ctf = vtk.vtkColorTransferFunction() ctf.SetColorSpaceToDiverging() ctf.AddRGBPoint(0.0, 0.230, 0.299, 0.754) ctf.AddRGBPoint(0.5, 1.0, 1.0, 1.0) ctf.AddRGBPoint(1.0, 0.706, 0.016, 0.150) cc = list() for i in range(256): cc.append(ctf.GetColor(float(i) / 255.0)) scalars = vtk.vtkFloatArray() scalars.SetNumberOfComponents(1) for errorVal in errors: scalars.InsertNextTuple([errorVal]) mean = np.mean(errors) std = np.std(errors) min3 = mean - std max3 = mean + std # Now we have the sources, lets put them into a list. sources = list() sources.append(reader) sources.append(reader) sources.append(sphere.polyData) sources.append(sphere.polyData) curvatures = list() for idx in range(2): curvatures.append(vtk.vtkCurvatures()) curvatures[idx].SetInputConnection(sources[idx].GetOutputPort()) if idx % 2 == 0: curvatures[idx].SetCurvatureTypeToGaussian() curvatures[idx].Update() npcurv1 = numpy_support.vtk_to_numpy(curvatures[idx].GetOutput().GetPointData().GetScalars()) mean = np.mean(npcurv1) std = np.std(npcurv1) min1 = 0.01*(mean - std) max1 = 0.01*(mean + std) else: curvatures[idx].SetCurvatureTypeToMean() curvatures[idx].Update() npcurv2 = np.abs(numpy_support.vtk_to_numpy(curvatures[idx].GetOutput().GetPointData().GetScalars())) mean = np.mean(npcurv2) std = np.std(npcurv2) #print 'Curvature (min / max / mean / total): ' + str(np.min(npcurv2)) + ' / ' + str(np.max(npcurv2)) + ' / ' + str(np.mean(npcurv2)) + ' / ' + str(np.sum(npcurv2)) min2 = mean - std max2 = mean + std fig = plt.figure() xa = np.arange(-0.1, 0.1,0.001) #plt.hist(npcurv1, bins=xa) plt.hist(npcurv2/npcurv2.max(), bins=xa) print 'By vtk:' print npcurv2.max() print npcurv2.argmax() plt.gca().set_yscale('log') plt.show() # Lookup table. lut = list() for idx in range(len(sources)): lut.append(vtk.vtkLookupTable()) lut[idx].SetNumberOfColors(256) for i, item in enumerate(cc): lut[idx].SetTableValue(i, item[0], item[1], item[2], 1.0) if idx == 0: lut[idx].SetRange(min1, max1) if idx == 1: lut[idx].SetRange(min2, max2) if idx == 2: lut[idx].SetRange(min3, max3) lut[idx].Build() renderers = list() mappers = list() actors = list() textmappers = list() textactors = list() scalarbars = list() # Create a common text property. textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(16) textProperty.SetJustificationToCentered() names = ['Sphere - Gaussian Curvature', 'Sphere - Mean Curvature', 'Sphere - Residuals to fitted sphere', 'Sphere - Residuals to fitted sphere'] # Link the pipeline together. for idx, item in enumerate(sources): #sources[idx].Update() mappers.append(vtk.vtkPolyDataMapper()) mappers[idx].SetUseLookupTableScalarRange(1) if idx < 2: #print npcurv.min(), npcurv.max() #print npcurv mappers[idx].SetInputConnection(curvatures[idx].GetOutputPort()) mappers[idx].SetLookupTable(lut[idx]) else: #mappers[idx].SetInputConnection(sources[idx].GetOutputPort()) mappers[idx].SetInputData(sources[idx]) mappers[idx].SetColorModeToMapScalars() #mappers[idx].GetPointData().SetScalars(scalars) mappers[idx].SetLookupTable(lut[idx]) actors.append(vtk.vtkActor()) actors[idx].SetMapper(mappers[idx]) if idx == 3: actors[idx].GetProperty().SetEdgeVisibility(1) actors[idx].GetProperty().SetEdgeColor(0.5, 0.5, 0.5); actors[idx].GetProperty().SetLineWidth(0.5) textmappers.append(vtk.vtkTextMapper()) textmappers[idx].SetInput(names[idx]) textmappers[idx].SetTextProperty(textProperty) textactors.append(vtk.vtkActor2D()) textactors[idx].SetMapper(textmappers[idx]) textactors[idx].SetPosition(150, 16) scalarbars.append(vtk.vtkScalarBarActor()) scalarbars[idx].SetLookupTable(lut[idx]) renderers.append(vtk.vtkRenderer()) gridDimensions = 2 for idx in range(len(sources)): if idx < gridDimensions * gridDimensions: renderers.append(vtk.vtkRenderer) rendererSize = 300 # Create the RenderWindow # renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(rendererSize * gridDimensions, 0) # Add and position the renders to the render window. viewport = list() for row in range(gridDimensions): for col in range(gridDimensions): idx = row * gridDimensions + col viewport[:] = [] viewport.append(float(col) * rendererSize / (gridDimensions * rendererSize)) viewport.append(float(gridDimensions - (row+1)) * rendererSize / (gridDimensions * rendererSize)) viewport.append(float(col+1)*rendererSize / (gridDimensions * rendererSize)) viewport.append(float(gridDimensions - row) * rendererSize / (gridDimensions * rendererSize)) if idx > (len(sources) - 1): continue renderers[idx].SetViewport(viewport) renderWindow.AddRenderer(renderers[idx]) renderers[idx].AddActor(actors[idx]) renderers[idx].AddActor(textactors[idx]) renderers[idx].AddActor(scalarbars[idx]) renderers[idx].SetBackground(0.5,0.5,0.5) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
# read polydata file # poly = vtk.vtkPolyDataReader() poly.SetFileName(poly_filename) polyMapper = vtk.vtkPolyDataMapper() polyMapper.SetInputConnection(poly.GetOutputPort()) polyActor = vtk.vtkActor() polyActor.SetMapper(polyMapper) #polyActor.GetProperty().SetRepresentationToWireframe(); #polyActor.GetProperty().SetColor(1.0, 0.2, 0.2) ############################################################################### # read obj file # object = vtk.vtkOBJReader() object.SetFileName(obj_filename) objectMapper = vtk.vtkPolyDataMapper() objectMapper.SetInputConnection(object.GetOutputPort()) objectActor = vtk.vtkActor() objectActor.SetMapper(objectMapper) objectActor.GetProperty().SetRepresentationToWireframe(); objectActor.GetProperty().SetColor(1.0, 0.2, 0.2) ############################################################################### # read second obj file # object2 = vtk.vtkOBJReader() object2.SetFileName(obj2_filename) object2Mapper = vtk.vtkPolyDataMapper()
# transform = vtk.vtkTransform() transform.RotateWXYZ(180, 1, 0, 0) move = [0, 0, 0] transform.Translate(move) #transformFilter = vtk.vtkTransformPolyDataFilter() #transformFilter.SetTransform(transform) transforms = [] transforms_filter = [] ############################################################################### # read obj file # obj_filename = '/mnt/data1/StandardBrain/SB/SB256.obj' object = vtk.vtkOBJReader() object.SetFileName(obj_filename) objectSmoother = vtk.vtkSmoothPolyDataFilter() objectSmoother.SetInputConnection(object.GetOutputPort()) objectSmoother.SetNumberOfIterations(100) transforms_filter.append(vtk.vtkTransformPolyDataFilter()) transforms_filter[-1].SetTransform(transform) transforms_filter[-1].SetInputConnection(objectSmoother.GetOutputPort()) transforms_filter[-1].Update() objectMapper = vtk.vtkPolyDataMapper() objectMapper.SetInputConnection(transforms_filter[-1].GetOutputPort()) objectActor = vtk.vtkActor() objectActor.SetMapper(objectMapper)
#!/usr/bin/env python import sys import vtk if (len(sys.argv) == 1): print "This script should at least contain 1 argument.\nUsage: vtkpython ImportObj.py $inputFile" sys.exit() path = sys.argv[1] opath = "/tmp/tmp.vtp" if len(sys.argv) > 2: opath = sys.argv[3] reader = vtk.vtkOBJReader() reader.SetFileName(path) reader.Update() mesh = reader.GetOutput() print "Input mesh file:\n"+path+"\n------------------\nnp:"+str(mesh.GetNumberOfPoints())+"\tnc:"+str(mesh.GetNumberOfCells())+"\n------------------\n" writer = vtk.vtkXMLPolyDataWriter() writer.SetInput(mesh) writer.SetFileName( opath ) writer.SetDataModeToAscii() writer.Write() print "Output mesh file\n"+opath+"\n------------------\nPoints: "+str( mesh.GetNumberOfPoints() )+"\nCells: "+str( mesh.GetNumberOfCells() )
EdgeView(1) elif key == "L": EdgeView(0) ## begin main # check that the required number of parameters were passed if len(sys.argv) < 2: print "usage: ShowOBJ.py <OBJ surface file>" sys.exit(1) # store the argument OBJFile = sys.argv[1] # reader for the OBJ file surfRead = vtk.vtkOBJReader() surfRead.SetFileName(OBJFile) surf = surfRead.GetOutput() ## rendering # window stuff ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) iren.SetRenderWindow(renWin) # surface display attr
import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Create the RenderWindow, Renderer and both Actors # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # read data # wavefront = vtk.vtkOBJReader() wavefront.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/Viewpoint/cow.obj") wavefront.Update() cone = vtk.vtkConeSource() cone.SetResolution(6) cone.SetRadius(0.1) transform = vtk.vtkTransform() transform.Translate(0.5, 0.0, 0.0) transformF = vtk.vtkTransformPolyDataFilter() transformF.SetInputConnection(cone.GetOutputPort()) transformF.SetTransform(transform) # we just clean the normals for efficiency (keep down number of cones) clean = vtk.vtkCleanPolyData() clean.SetInputConnection(wavefront.GetOutputPort()) glyph = vtk.vtkHedgeHog() glyph.SetInputConnection(clean.GetOutputPort())