def PlotAntsPlane(): """ Demonstrate how to create a plot class to plot multiple meshes while adding scalars and text. Plot two ants and airplane """ # load and shrink airplane airplane = vtkInterface.PolyData(planefile) airplane.points /= 10 # pts = airplane.GetNumpyPoints() # gets pointer to array # pts /= 10 # shrink # rotate and translate ant so it is on the plane ant = vtkInterface.PolyData(antfile) ant.RotateX(90) ant.Translate([90, 60, 15]) # Make a copy and add another ant ant_copy = ant.Copy() ant_copy.Translate([30, 0, -10]) # Create plotting object plobj = vtkInterface.PlotClass() plobj.AddMesh(ant, 'r') plobj.AddMesh(ant_copy, 'b') # Add airplane mesh and make the color equal to the Y position plane_scalars = airplane.points[:, 1] plobj.AddMesh(airplane, scalars=plane_scalars, stitle='Plane Y\nLocation') plobj.AddText('Ants and Plane Example') plobj.Plot()
def MakeLine(points): """ Generates line from points. Assumes points are ordered as line segments. Parameters ---------- points : np.ndarray Points representing line segments. For example, two line segments would be represented as: np.array([[0, 0, 0], [1, 0, 0], [1, 0, 0], [1, 1, 0]]) Returns ------- lines : vtki.PolyData PolyData with lines and cells. Examples -------- This example plots two line segments at right angles to each other line. >>> import vtkInterface as vtki >>> points = np.array([[0, 0, 0], [1, 0, 0], [1, 0, 0], [1, 1, 0]]) >>> lines = vtki.MakeLine(points) >>> lines.Plot() """ # Assuming ordered points, create array defining line order npoints = points.shape[0] - 1 lines = np.vstack((2 * np.ones(npoints, np.int), np.arange(npoints), np.arange(1, npoints + 1))).T.ravel() return vtkInterface.PolyData(points, lines)
def MakePointMesh(points, deep=True): """ Convert numpy points to vtkPoints """ # Data checking if not points.flags['C_CONTIGUOUS']: points = np.ascontiguousarray(points) # Convert to vtk objects vtkpoints = vtk.vtkPoints() vtkpoints.SetData(numpy_to_vtk(points, deep=True)) npoints = points.shape[0] pcell = np.vstack((np.ones(npoints, dtype=np.int64), np.arange(npoints, dtype=np.int64))).ravel('F') # Convert to a vtk array vtkcells = vtk.vtkCellArray() vtkcells.SetCells(npoints, numpy_to_vtkIdTypeArray(pcell, deep=True)) # Create polydata object mesh = vtkInterface.PolyData() mesh.SetPoints(vtkpoints) mesh.SetPolys(vtkcells) # return cleaned mesh return mesh
def MeshfromVF(points, triangles_in, clean=True, deep_points=True): """ Generates mesh from points and triangles """ # Add face padding if necessary if triangles_in.shape[1] == 3: triangles = np.empty((triangles_in.shape[0], 4), dtype=np.int64) triangles[:, -3:] = triangles_in triangles[:, 0] = 3 else: triangles = triangles_in # Data checking if not points.flags['C_CONTIGUOUS']: points = np.ascontiguousarray(points) if not triangles.flags['C_CONTIGUOUS'] or triangles.dtype != 'int64': triangles = np.ascontiguousarray(triangles, 'int64') # Convert to vtk objects vtkpoints = MakevtkPoints(points, deep=deep_points) # Convert to a vtk array vtkcells = vtk.vtkCellArray() vtkcells.SetCells(triangles.shape[0], numpy_to_vtkIdTypeArray(triangles, deep=True)) mesh = vtkInterface.PolyData() mesh.SetPoints(vtkpoints) mesh.SetPolys(vtkcells) if clean: mesh.Clean() return mesh
def ExtractSurface(self, pass_pointid=True, pass_cellid=True): """ Extract surface mesh of the grid Parameters ---------- pass_pointid : bool, optional Adds a point scalar "vtkOriginalPointIds" that idenfities which original points these surface points correspond to pass_cellid : bool, optional Adds a cell scalar "vtkOriginalPointIds" that idenfities which original cells these surface cells correspond to Returns ------- extsurf : vtki.PolyData Surface mesh of the grid """ surf_filter = vtk.vtkDataSetSurfaceFilter() surf_filter.SetInputData(self) if pass_pointid: surf_filter.PassThroughCellIdsOn() if pass_cellid: surf_filter.PassThroughPointIdsOn() surf_filter.Update() return vtki.PolyData(surf_filter.GetOutput())
class TestPolyData(object): sphere = vtki.PolyData(spherefile) def test_loadfromfile(self): sphere = vtki.PolyData(spherefile) assert sphere.GetNumberOfPoints() assert sphere.GetNumberOfCells() assert hasattr(sphere, 'points')
def test_tetrahedralize(): sphere = vtki.PolyData(examples.spherefile) tet = tetgen.TetGen(sphere) tet.Tetrahedralize(order=1, mindihedral=20, minratio=1.5) grid = tet.grid assert grid.GetNumberOfCells() assert grid.GetNumberOfPoints() assert np.all(grid.quality > 0) return grid
def reada4db(): with open("WS_neu_mitMPCundMasse_v9_500kg__Traegheit_3Contact.inp") as f: bodyText = f.read() # node_search = re.compile('*NODE\n( +[0-9\.\+e\-,]+\n*){202,2500}', re.S) node_search = re.compile('\*NODE\n( +[0-9\.\+e\-, ]+\n){202,25000}', re.S) cell_search = re.compile( '\*ELEMENT[, A-Z=;0-9_]*\n( +[0-9\.\+e\-, ]+\n*){3,150000}', re.S) locationOfNodes = re.finditer(node_search, bodyText) locationOfCells = re.finditer(cell_search, bodyText) vertices = [ list(map(float, item.split(",")[1:])) for item in next(locationOfNodes)[0].split("\n") ][:-1] cellPoints = None cellIds = None for items in locationOfCells: if cellPoints is None: cellPoints = [ list(map(float, item.split(",")[1:])) for item in items[0].split("\n")[1:] ][:-1] # print(len(cellPoints)) cellPoints = [[len(item)] + item for item in cellPoints] cellIds = [ item.split(",")[0] for item in items[0].split("\n")[1:] ][:-1] else: newCellPoints = [ list(map(float, item.split(",")[1:])) for item in items[0].split("\n")[1:] ][:-1] newCellPoints = [[len(item)] + item for item in newCellPoints] cellPoints = cellPoints + newCellPoints cellIds = cellIds + [ item.split(",")[0] for item in items[0].split("\n")[1:] ][:-1] cellPoints = np.hstack(cellPoints) cellIds = np.array(cellIds) vertices[0] = [0, 0, 0] vertices = np.array(vertices) # print(cellIds.shape) surf = vtkInterface.PolyData(vertices, cellPoints) # surf.Plot() surf.Write("sample.vtk")
def MakeLine(points): """ Generates line from points. Assumes points are ordered """ # Assuming ordered points, create array defining line order npoints = points.shape[0] - 1 lines = np.vstack((2 * np.ones(npoints, np.int), np.arange(npoints), np.arange(1, npoints + 1))).T.ravel() # Create polydata object return vtkInterface.PolyData(points, lines)
def CreateVectorPolyData(orig, vec): """ Creates a vtkPolyData object composed of vectors """ # shape, dimention checking if not isinstance(orig, np.ndarray): orig = np.asarray(orig) if not isinstance(vec, np.ndarray): vec = np.asarray(vec) if orig.ndim != 2: orig = orig.reshape((-1, 3)) elif orig.shape[1] != 3: raise Exception('orig array must be 3D') if vec.ndim != 2: vec = vec.reshape((-1, 3)) elif vec.shape[1] != 3: raise Exception('vec array must be 3D') # Create vtk points and cells objects vpts = vtk.vtkPoints() vpts.SetData(numpy_to_vtk(np.ascontiguousarray(orig), deep=True)) npts = orig.shape[0] cells = np.hstack((np.ones((npts, 1), 'int'), np.arange(npts).reshape( (-1, 1)))) if cells.dtype != ctypes.c_int64 or cells.flags.c_contiguous: cells = np.ascontiguousarray(cells, ctypes.c_int64) vcells = vtk.vtkCellArray() vcells.SetCells(npts, numpy_to_vtkIdTypeArray(cells, deep=True)) # Create vtkPolyData object pdata = vtk.vtkPolyData() pdata.SetPoints(vpts) pdata.SetVerts(vcells) # Add vectors to polydata name = 'vectors' vtkfloat = numpy_to_vtk(np.ascontiguousarray(vec), deep=True) vtkfloat.SetName(name) pdata.GetPointData().AddArray(vtkfloat) pdata.GetPointData().SetActiveVectors(name) # Add magnitude of vectors to polydata name = 'mag' scalars = (vec * vec).sum(1)**0.5 vtkfloat = numpy_to_vtk(np.ascontiguousarray(scalars), deep=True) vtkfloat.SetName(name) pdata.GetPointData().AddArray(vtkfloat) pdata.GetPointData().SetActiveScalars(name) return vtkInterface.PolyData(pdata)
def WithVTK(plot=True): """ Tests VTK interface and mesh repair of Stanford Bunny Mesh """ mesh = vtki.PolyData(bunny_scan) meshfix = pymeshfix.MeshFix(mesh) if plot: print('Plotting input mesh') meshfix.Plot() meshfix.Repair() if plot: print('Plotting repaired mesh') meshfix.Plot() return meshfix.mesh
def PlotBoundaries(mesh, **args): """ Plots boundaries of a mesh """ featureEdges = vtk.vtkFeatureEdges() featureEdges.SetInputData(mesh) featureEdges.FeatureEdgesOff() featureEdges.BoundaryEdgesOn() featureEdges.NonManifoldEdgesOn() featureEdges.ManifoldEdgesOff() featureEdges.Update() edges = vtkInterface.PolyData(featureEdges.GetOutput()) plobj = PlotClass() plobj.AddMesh(edges, 'r', style='wireframe') plobj.AddMesh(mesh) plobj.Plot()
def test_repairVTK(): meshin = vtki.PolyData(bunny_scan) meshfix = pymeshfix.MeshFix(meshin) meshfix.Repair() # check arrays and output mesh assert np.any(meshfix.v) assert np.any(meshfix.f) meshout = meshfix.mesh assert meshfix.mesh.GetNumberOfPoints() # test for any holes pdata = meshout.ExtractEdges(non_manifold_edges=False, feature_edges=False, manifold_edges=False) assert pdata.GetNumberOfPoints() == 0
def test_native(): out_file = 'repaired.ply' # test write permissions curdir = os.getcwd() if not os.access(curdir, os.W_OK): raise Exception('Cannot write output mesh here at %s' % curdir) pymeshfix._meshfix.CleanFromFile(bunny_scan, out_file, verbose=False) outmesh = vtki.PolyData(out_file) os.remove(out_file) assert outmesh.GetNumberOfPoints() # test for any holes pdata = outmesh.ExtractEdges(non_manifold_edges=False, feature_edges=False, manifold_edges=False) assert pdata.GetNumberOfPoints() == 0
def MakeVTKPointsMesh(points): """ Create a PolyData object from a numpy array containing just points """ if points.ndim != 2: points = points.reshape((-1, 3)) npoints = points.shape[0] # Make VTK cells array cells = np.hstack((np.ones( (npoints, 1)), np.arange(npoints).reshape(-1, 1))) cells = np.ascontiguousarray(cells, dtype=np.int64) vtkcells = vtk.vtkCellArray() vtkcells.SetCells(npoints, numpy_to_vtkIdTypeArray(cells, deep=True)) # Convert points to vtk object vtkPoints = vtkInterface.MakevtkPoints(points) # Create polydata pdata = vtkInterface.PolyData() pdata.SetPoints(vtkPoints) pdata.SetVerts(vtkcells) return pdata
def CreateVectorPolyData(orig, vec): """ Creates a vtkPolyData object composed of vectors """ # Create vtk points and cells objects vpts = vtk.vtkPoints() vpts.SetData(numpy_to_vtk(np.ascontiguousarray(orig), deep=True)) npts = orig.shape[0] cells = np.hstack((np.ones((npts, 1), 'int'), np.arange(npts).reshape( (-1, 1)))) if cells.dtype != np.int64 or cells.flags.c_contiguous: cells = np.ascontiguousarray(cells, np.int64) vcells = vtk.vtkCellArray() vcells.SetCells(npts, numpy_to_vtkIdTypeArray(cells, deep=True)) # Create vtkPolyData object pdata = vtk.vtkPolyData() pdata.SetPoints(vpts) pdata.SetVerts(vcells) # Add vectors to polydata name = 'vectors' vtkfloat = numpy_to_vtk(np.ascontiguousarray(vec), deep=True) vtkfloat.SetName(name) pdata.GetPointData().AddArray(vtkfloat) pdata.GetPointData().SetActiveVectors(name) # Add magnitude of vectors to polydata name = 'mag' scalars = (vec * vec).sum(1)**0.5 vtkfloat = numpy_to_vtk(np.ascontiguousarray(scalars), deep=True) vtkfloat.SetName(name) pdata.GetPointData().AddArray(vtkfloat) pdata.GetPointData().SetActiveScalars(name) return vtkInterface.PolyData(pdata)
# contour = mp.fill_contour(contour, fill_xy=True) # pl.PlotImage(data, res=resolution) ################################################################################ ''' Run MarchingCubes in skimage and convert to VTK format ''' # contour = contour[:46] xyzres = resolution A.contour = contour verts, faces, normals, values = measure.marching_cubes_lewiner( A.contour, 0, spacing=list(resolution / np.min(resolution)), step_size=1, allow_degenerate=False) faces = np.hstack(np.c_[np.full(faces.shape[0], 3), faces]) A.mesh = vi.PolyData(verts, faces) del faces, verts, normals, values ''' Process mesh ''' bounds = A.mesh.GetBounds() A.mesh.ClipPlane([np.ceil(bounds[0]), 0, 0], [(xyzres[0] + 0.0001), 0, 0]) A.mesh.ClipPlane([np.floor(bounds[1]), 0, 0], [-(xyzres[0] + 0.0001), 0, 0]) A.mesh.ClipPlane([0, np.ceil(bounds[2]), 0], [0, (xyzres[1] + 0.0001), 0]) A.mesh.ClipPlane([0, np.floor(bounds[3]), 0], [0, -(xyzres[1] + 0.0001), 0]) A.mesh.ClipPlane([0, 0, np.ceil(bounds[4])], [0, 0, (xyzres[2] + 0.0001)]) A.mesh.ClipPlane([0, 0, np.floor(bounds[5])], [0, 0, -(xyzres[2] + 0.0001)]) A.mesh = mp.ECFT(A.mesh, 100) A.mesh = mp.correct_bad_mesh(A.mesh) A.mesh = mp.ECFT(A.mesh, 100)
if plot: print('Plotting input mesh') meshfix.Plot() meshfix.Repair() if plot: print('Plotting repaired mesh') meshfix.Plot() return meshfix.mesh if __name__ == '__main__': """ Functional Test: vtk and native """ out_file = 'repaired.ply' Native() outmesh = vtki.PolyData(out_file) os.remove(out_file) assert outmesh.GetNumberOfPoints() # test for any holes pdata = outmesh.ExtractEdges(non_manifold_edges=False, feature_edges=False, manifold_edges=False) assert pdata.GetNumberOfPoints() == 0 # test vtk meshin = vtki.PolyData(bunny_scan) meshfix = pymeshfix.MeshFix(meshin) meshfix.Repair() # check arrays and output mesh
def LoadSphere(): """ Loads sphere ply mesh """ return vtkInterface.PolyData(spherefile)
def LoadAnt(): """ Load ply ant mesh """ return vtkInterface.PolyData(antfile)
def PlotAnt(): """ Plot a red ant in wireframe""" ant = vtkInterface.PolyData(antfile) ant.Plot(color='r', style='wireframe')
def PlotAirplane(): """ Plot a white airplane """ airplane = vtkInterface.PolyData(planefile) airplane.Plot()
def PlotSphere(): """ Plot a white airplane """ sphere = vtkInterface.PolyData(spherefile) sphere.Plot()
def test_loadfromfile(): sphere = vtki.PolyData(spherefile) assert sphere.GetNumberOfPoints() assert sphere.GetNumberOfCells() assert hasattr(sphere, 'points')
def LoadAirplane(): """ Load ply airplane mesh """ return vtkInterface.PolyData(planefile)