def CalculateDistance(mito_surface_name, cell_surface_name): #Open the surface of Mito SurfaceMito = LegacyVTKReader(FileNames=[mito_surface_name]) SurfaceMito = GetActiveSource() SurfaceMito = servermanager.Fetch(SurfaceMito) #Open the surface of Cell SurfaceCell = LegacyVTKReader(FileNames=[cell_surface_name]) SurfaceCell = GetActiveSource() SurfaceCell = servermanager.Fetch(SurfaceCell) #Get the bounds of the cell(xmin,xmax,ymin,ymax,zmin,zmax) bounds = [0] * 6 SurfaceCell.GetBounds(bounds) #Creating the point locator LocatorMito = vtk.vtkPointLocator() LocatorMito.SetDataSet(SurfaceMito) LocatorMito.BuildLocator() #Vector to store the distance from foci to mito Distances = [] #Now you can calculate the distance between the #foci (x,y,z) and the Surface: for randomNumber in range(100): x = random.uniform(bounds[0], bounds[1]) y = random.uniform(bounds[2], bounds[3]) z = random.uniform(bounds[4], bounds[5]) selectEnclosedPointsCell = vtk.vtkSelectEnclosedPoints() selectEnclosedPointsCell.Initialize(SurfaceCell) insideCell = selectEnclosedPointsCell.IsInsideSurface(x, y, z) #Check to see if the random foci is inside the cell if insideCell: selectEnclosedPointsMito = vtk.vtkSelectEnclosedPoints() selectEnclosedPointsMito.Initialize(SurfaceMito) insideMito = selectEnclosedPointsMito.IsInsideSurface(x, y, z) #Check to see if the random foci is inside the mitochroniral if insideMito: continue else: r = [x, y, z] ptId = LocatorMito.FindClosestPoint(r) u = SurfaceMito.GetPoints().GetPoint(ptId) distance = math.sqrt((r[0] - u[0])**2 + (r[1] - u[1])**2 + (r[2] - u[2])**2) Distances.append(distance) else: continue Delete(GetActiveSource()) del SurfaceMito del SurfaceCell #del LocatorCell del LocatorMito return Distances
def signedDistance(self, mean, exploration_points): colors = vtk.vtkFloatArray() colors.SetName("Distance") colors.SetNumberOfComponents(1) max_inside = self.colormodeparam2 max_outside = self.colormodeparam1 red = np.array([max_outside]) white = np.array([(-max_inside + max_outside) / 2.0]) blue = np.array([-max_inside]) color = np.array([50]) select_enclosed_points = vtk.vtkSelectEnclosedPoints() select_enclosed_points.SetInputData(self.polydataExploration) select_enclosed_points.SetSurfaceData(self.polydataMean) select_enclosed_points.SetTolerance(0.000001) select_enclosed_points.Update() for i in range(0, len(mean), 3): point = exploration_points[i:i + 3] meanpoint = mean[i:i + 3] distance = np.linalg.norm(point - meanpoint) if select_enclosed_points.IsInside(int(i / 3)) == 1: ratio = distance / max_inside color = ratio * blue + (1 - ratio) * white else: ratio = distance / max_outside color = ratio * red + (1 - ratio) * white colors.InsertNextTuple(color) colors.Modified() return colors
def select_point_cloud(self): if not self.scene.get_active_point_cloud(): return self.unselect_point_cloud() transform = vtk.vtkTransform() transform.SetMatrix(self.actor.GetMatrix()) transform_filter = vtk.vtkTransformPolyDataFilter() transform_filter.SetInputConnection(self.src.GetOutputPort()) transform_filter.SetTransform(transform) enclosed_pts = vtk.vtkSelectEnclosedPoints() if USING_VTK6: enclosed_pts.SetInputData(self.scene.get_active_point_cloud().polydata) enclosed_pts.SetSurfaceConnection(transform_filter.GetOutputPort()) else: enclosed_pts.SetInput(self.scene.get_active_point_cloud().polydata) enclosed_pts.SetSurface(transform_filter.GetOutput()) enclosed_pts.Update() inside_arr = enclosed_pts.GetOutput().GetPointData().\ GetArray('SelectedPoints') self.selected_pts = [] for i in range(inside_arr.GetNumberOfTuples()): if inside_arr.GetComponent(i, 0): self.scene.get_active_point_cloud().colors.\ SetTuple3(i, *name_to_rgb('blue')) self.selected_pts.append(i) self.scene.get_active_point_cloud().selected_pts[i] += 1 self.scene.get_active_point_cloud().colors.Modified() self.frame.ren_win.Render()
def findPointsInCell(points, cell, verbose=1): ugrid_cell = vtk.vtkUnstructuredGrid() ugrid_cell.SetPoints(cell.GetPoints()) cell = vtk.vtkHexahedron() for k_point in xrange(8): cell.GetPointIds().SetId(k_point, k_point) cell_array_cell = vtk.vtkCellArray() cell_array_cell.InsertNextCell(cell) ugrid_cell.SetCells(vtk.VTK_HEXAHEDRON, cell_array_cell) geometry_filter = vtk.vtkGeometryFilter() geometry_filter.SetInputData(ugrid_cell) geometry_filter.Update() cell_boundary = geometry_filter.GetOutput() pdata_points = vtk.vtkPolyData() pdata_points.SetPoints(points) enclosed_points_filter = vtk.vtkSelectEnclosedPoints() enclosed_points_filter.SetSurfaceData(cell_boundary) enclosed_points_filter.SetInputData(pdata_points) enclosed_points_filter.Update() points_in_cell = [k_point for k_point in xrange(points.GetNumberOfPoints()) if enclosed_points_filter.GetOutput().GetPointData().GetArray('SelectedPoints').GetTuple(k_point)[0]] return points_in_cell
def loadFromSTL(self, filebasename, z1, z2): import vtk reader = vtk.vtkSTLReader() reader.SetFileName(filebasename + '.stl') surfacePoly = vtk.vtkPolyData() #if vtk.VTK_MAJOR_VERSION <= 5: surfacePoly.SetInput(reader.GetOutput()) #else: # surfacePoly.SetInputConnection(reader.GetOutputPort()) points = vtk.vtkPoints() for x in range(1, self.NX + 1): for y in range(1, self.NY + 1): for z in range(z1, z2 + 1): points.InsertNextPoint([x, y, z]) pointsPoly = vtk.vtkPolyData() pointsPoly.SetPoints(points) selectEnclosed = vtk.vtkSelectEnclosedPoints() selectEnclosed.SetInputData(pointsPly) selectEnclosed.SetSurfaceData(surfacePoly) selectEnclosed.Update() for i in points.GetNumberOfPoints(): if selectEnclosed.IsInside(n): self.__addnode(points.GetPoint(n))
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 SetAnatomy( self, role, node ): if ( role == "Tissue" and node.GetPolyData() != None ): self.tissueNode = node self.enclosedFilter = vtk.vtkSelectEnclosedPoints() self.enclosedFilter.Initialize( self.tissueNode.GetPolyData() ) return True return False
def insidepoints(points, surface, tolerance=1e-4): """Mark points as to whether they are inside a closed surface""" marker = vtk.vtkSelectEnclosedPoints() marker.SetInput(points) marker.SetSurface(surface) marker.SetTolerance(tolerance) marker.Update() return marker.GetOutput()
def arePointsPenetrating(vtkData, vtkPoints): pointChecker = vtk.vtkSelectEnclosedPoints() pointChecker.SetInput(vtkPoints) pointChecker.SetSurface(vtkData) pointChecker.SetCheckSurface(1) pointChecker.SetTolerance(0) pointChecker.Update() insideArr = v2n( pointChecker.GetOutput().GetPointData().GetArray('SelectedPoints')) penetration = (insideArr.sum() > 0) return penetration
def non_overlapping_segmentation(meshfiles, reffile, resolve): refnii = radiological.load(reffile) meshes = [loadmesh(mf) for mf in meshfiles] allmasks = np.zeros(refnii.shape + (len(meshes), )) for i, mesh in enumerate(meshes): imd = vtk.vtkImageData() imd.SetExtent(0, refnii.shape[0] - 1, 0, refnii.shape[1] - 1, 0, refnii.shape[2] - 1) imd.SetSpacing(*refnii.get_header().get_zooms()) filt = vtk.vtkSelectEnclosedPoints() filt.SetInputData(imd) filt.SetSurfaceData(mesh) filt.SetTolerance(0.00001) filt.Update() mask = np.reshape(vtknp.vtk_to_numpy( filt.GetOutput().GetPointData().GetArray('SelectedPoints')).copy(), refnii.shape, order='F') allmasks[..., i] = mask labels = (allmasks * np.arange(1, 1 + len(meshes))).sum(axis=3) contested = np.transpose(np.nonzero(allmasks.sum(axis=3) > 1)) if resolve: ipdds = list() for mesh in meshes: ipdd = vtk.vtkImplicitPolyDataDistance() ipdd.SetInput(mesh) ipdds.append(ipdd) for voxel in contested: # NB: This also includes the meshes that do not include the point, but those meshes will have higher distances # and will not influence the result dists = [ ipdd.FunctionValue(*(voxel * refnii.get_header().get_zooms())) for ipdd in ipdds ] labels[voxel[0], voxel[1], voxel[2]] = np.argmin(np.array(dists)) + 1 else: for voxel in contested: labels[voxel[0], voxel[1], voxel[2]] = 0 result = nii.Nifti1Image(labels, refnii.affine) result.set_qform(refnii.affine) return result
def IsInsideCheck(pX, pY, pZ, mesh): select = vtk.vtkSelectEnclosedPoints() select.SetSurface(mesh) select.SetTolerance(.00001) pts = vtk.vtkPoints() pts.InsertNextPoint((pX), (pY), (pZ)) pts_pd = vtk.vtkPolyData() pts_pd.SetPoints(pts) select.SetInput(pts_pd) select.Update() # print pX,pY,pZ,select.IsInside(0) return select.IsInside(0)
def IsInsideCheck(pX,pY,pZ,mesh): select = vtk.vtkSelectEnclosedPoints() select.SetSurface(mesh) select.SetTolerance(.00001) pts = vtk.vtkPoints() pts.InsertNextPoint((pX),(pY),(pZ)) pts_pd = vtk.vtkPolyData() pts_pd.SetPoints(pts) select.SetInput(pts_pd) select.Update() # print pX,pY,pZ,select.IsInside(0) return select.IsInside(0)
def voxelize(self, shape, tol=0): """ Compute the enclosed points of the TriSurface. This code uses vtk. Parameters ---------- shape: 3-uplet the image shape. Returns ------- inside_array: array a mask array with the enclosed voxels. """ # Import here since vtk is not required by the package import vtk from vtk.util.numpy_support import vtk_to_numpy # Construct the mesh grid from shape nx, ny, nz = shape gridx, gridy, gridz = numpy.meshgrid(numpy.linspace(0, nx - 1, nx), numpy.linspace(0, ny - 1, ny), numpy.linspace(0, nz - 1, nz)) # Create polydata vtk_points = vtk.vtkPoints() for point in zip(gridx.flatten(), gridy.flatten(), gridz.flatten()): vtk_points.InsertNextPoint(point) points_polydata = vtk.vtkPolyData() points_polydata.SetPoints(vtk_points) surf_polydata = self._polydata() # Compute enclosed points enclosed_pts = vtk.vtkSelectEnclosedPoints() enclosed_pts.SetInput(points_polydata) enclosed_pts.SetTolerance(tol) enclosed_pts.SetSurface(surf_polydata) enclosed_pts.SetCheckSurface(1) enclosed_pts.Update() inside_points = enclosed_pts.GetOutput().GetPointData().GetArray( "SelectedPoints") enclosed_pts.ReleaseDataFlagOn() enclosed_pts.Complete() # Convert result as a numpy array inside_array = vtk_to_numpy(inside_points).reshape(ny, nx, nz) inside_array = numpy.swapaxes(inside_array, 1, 0) return inside_array
def distanceField(surfaceMesh, targetGrid, targetArrayName: str, signed=False): """Create a distance field between a vtkStructuredGrid and a surface. :param surfaceMesh: Outer polygonal surface :param targetGrid: Grid array of points :type targetGrid: vtk.vtkStructuredGrid :param targetArrayName: The distance field values will be stored in the \ target grid, with this array name. :type targetArrayName: str :param signed: Signed/unsigned distance field, defaults to False (unsigned) :type signed: bool, optional """ # Initialize distance field: df = vtk.vtkDoubleArray() df.SetNumberOfTuples(targetGrid.GetNumberOfPoints()) df.SetName(targetArrayName) # Data structure to quickly find cells: cellLocator = vtk.vtkCellLocator() cellLocator.SetDataSet(surfaceMesh) cellLocator.BuildLocator() for i in range(0, targetGrid.GetNumberOfPoints()): # Take a point from the target... testPoint = [0] * 3 targetGrid.GetPoint(i, testPoint) # ... find the point in the surface closest to it cID, subID, dist2 = vtk.mutable(0), vtk.mutable(0), vtk.mutable(0.0) closestPoint = [0] * 3 cellLocator.FindClosestPoint( testPoint, closestPoint, cID, subID, dist2) dist = math.sqrt(dist2) df.SetTuple1(i, dist) if signed: pts = vtk.vtkPolyData() pts.SetPoints(targetGrid.GetPoints()) enclosedPointSelector = vtk.vtkSelectEnclosedPoints() enclosedPointSelector.CheckSurfaceOn() enclosedPointSelector.SetInputData(pts) enclosedPointSelector.SetSurfaceData(surfaceMesh) enclosedPointSelector.SetTolerance(1e-9) enclosedPointSelector.Update() enclosedPoints = enclosedPointSelector.GetOutput() for i in range(0, targetGrid.GetNumberOfPoints()): if enclosedPointSelector.IsInside(i): df.SetTuple1(i, -df.GetTuple1(i)) # invert sign targetGrid.GetPointData().AddArray(df)
def isInside(actor, point, tol=0.0001): """Return True if point is inside a polydata closed surface""" poly = polydata(actor, True) points = vtk.vtkPoints() points.InsertNextPoint(point) pointsPolydata = vtk.vtkPolyData() pointsPolydata.SetPoints(points) sep = vtk.vtkSelectEnclosedPoints() sep.SetTolerance(tol) sep.CheckSurfaceOff() setInput(sep, pointsPolydata) if vtkMV: sep.SetSurfaceData(poly) else: sep.SetSurface(poly) sep.Update() return sep.IsInside(0)
def point_inside_cell(self, point, cell_idx, tolerance=1e-8): """Determines whether point is inside cell or not. Returns ------- inside : bool Notes ----- Result might be inconsistent due to the stochastic nature of the algorithm. Decreasing the tolerance might help. """ x = self.xyz[cell_idx[0], cell_idx[1], cell_idx[2]].copy() x[[2, 3]] = x[[3, 2]] x[[6, 7]] = x[[7, 6]] pts = [(0, 1, 2, 3), (4, 5, 6, 7), (0, 1, 5, 4), (1, 2, 6, 5), (2, 3, 7, 6), (3, 0, 4, 7)] cube = vtk.vtkPolyData() points = vtk.vtkPoints() points.SetDataTypeToDouble() polys = vtk.vtkCellArray() for i in range(8): points.InsertPoint(i, x[i]) for i in range(6): polys.InsertNextCell(mk_vtk_id_list(pts[i])) cube.SetPoints(points) cube.SetPolys(polys) points = np.array([point]) vtk_pts = vtk.vtkPoints() vtk_pts.SetDataTypeToDouble() vtk_pts.SetData(numpy_support.numpy_to_vtk(points, deep=1)) # Make the poly data poly_pts_vtp = vtk.vtkPolyData() poly_pts_vtp.SetPoints(vtk_pts) enclosed_points_filter = vtk.vtkSelectEnclosedPoints() enclosed_points_filter.SetTolerance(tolerance) enclosed_points_filter.SetSurfaceData(cube) enclosed_points_filter.SetInputData(poly_pts_vtp) enclosed_points_filter.Update() return enclosed_points_filter.IsInside(0)
def is_inside_mesh(triangles2, point): selectEnclosedPoints=vtk.vtkSelectEnclosedPoints() selectEnclosedPoints.SetSurfaceData(triangles2) selectEnclosedPoints.CheckSurfaceOn() selectEnclosedPoints.SetTolerance(0.001) testpt=vtk.vtkPoints() pointpoly=vtk.vtkPolyData() testpt.InsertNextPoint(point) pointpoly.SetPoints(testpt) selectEnclosedPoints.SetInputData(pointpoly) selectEnclosedPoints.Update() _is_inside = selectEnclosedPoints.IsInside(0) selectEnclosedPoints.Update() return _is_inside
def IsEncapsulated(poly1,poly2): pointsPolydata = vtk.vtkPolyData() pointsPolydata.SetPoints( poly2.GetPoints() ) selectEnclosedPoints = vtk.vtkSelectEnclosedPoints() if vtk.VTK_MAJOR_VERSION <= 5: selectEnclosedPoints.SetInput(pointsPolydata); else: selectEnclosedPoints.SetInputData(pointsPolydata); if vtk.VTK_MAJOR_VERSION <= 5: selectEnclosedPoints.SetSurface(poly1) else: selectEnclosedPoints.SetSurfaceData(poly1) selectEnclosedPoints.Update(); return selectEnclosedPoints.IsInside(0)
def ProcessThisPlane(mask, z): for i in range(n_verts): xypts.SetPoint(i, [x[i], y[i], z]) plane = vtk.vtkPolyData() plane.SetPoints(xypts) plane.Modified() encPoints = vtk.vtkSelectEnclosedPoints() encPoints.SetTolerance(1e-6) encPoints.SetInputData(plane) encPoints.SetSurfaceData(polydata) encPoints.Update() for i in range(n_verts): vert_is_inside[i] = encPoints.IsInside(i) mask[z, y, x] = 255 * vert_is_inside
def points_in_geo(self, geo, points): vtkpoints = vtk.vtkPoints() for point in points: vtkpoints.InsertNextPoint(point) vtkpolydata = vtk.vtkPolyData() vtkpolydata.SetPoints(vtkpoints) enclosed_points = vtk.vtkSelectEnclosedPoints() enclosed_points.SetInputData(vtkpolydata) enclosed_points.SetSurfaceData( self.vtk_widget.get_input_data(geo).GetOutput()) enclosed_points.Update() for i in range(len(points)): if enclosed_points.IsInside(i): yield points[i]
def vtkPointInsideObject(S,P,tol=0.): """vtk function to test which of the points P are inside surface S""" from vtk import vtkSelectEnclosedPoints vpp = convert2VPD(P) vps =convert2VPD(S,clean=False) enclosed_pts = vtkSelectEnclosedPoints() enclosed_pts.SetInput(vpp) enclosed_pts.SetTolerance(tol) enclosed_pts.SetSurface(vps) enclosed_pts.SetCheckSurface(1) enclosed_pts.Update() inside_arr = enclosed_pts.GetOutput().GetPointData().GetArray('SelectedPoints') enclosed_pts.ReleaseDataFlagOn() enclosed_pts.Complete() del enclosed_pts return asarray(v2n(inside_arr),'bool')
def vtkPointInsideObject(S, P, tol=0.): """vtk function to test which of the points P are inside surface S""" from vtk import vtkSelectEnclosedPoints vpp = convert2VPD(P) vps = convert2VPD(S, clean=False) enclosed_pts = vtkSelectEnclosedPoints() enclosed_pts.SetInput(vpp) enclosed_pts.SetTolerance(tol) enclosed_pts.SetSurface(vps) enclosed_pts.SetCheckSurface(1) enclosed_pts.Update() inside_arr = enclosed_pts.GetOutput().GetPointData().GetArray( 'SelectedPoints') enclosed_pts.ReleaseDataFlagOn() enclosed_pts.Complete() del enclosed_pts return asarray(v2n(inside_arr), 'bool')
def CorrespondenceDistance(self,signed=False,inverse=False,tolerance=0.000000001): A = self.getPolydata('A') A = A.GetPoints() A = A.GetData() A = vtk_to_numpy(A) B = self.getPolydata('B') B = B.GetPoints() B = B.GetData() B = vtk_to_numpy(B) dist = A-B dist = np.linalg.norm(dist,axis=1) if not signed: return dist.tolist() else: enclosed_points=vtk.vtkSelectEnclosedPoints() if inverse: enclosed_points.SetInputData(self.getPolydata('B')) enclosed_points.SetSurfaceData(self.getPolydata('A')) else: enclosed_points.SetInputData(self.getPolydata('A')) enclosed_points.SetSurfaceData(self.getPolydata('B')) enclosed_points.SetTolerance(tolerance) enclosed_points.Update() for i in range(len(dist)): if enclosed_points.IsInside(i): dist[i]=-dist[i] return dist.tolist()
def getPointsInCell(points, cell, verbose=0): mypy.my_print(verbose, "*** getPointsInCell ***") ugrid_cell = vtk.vtkUnstructuredGrid() ugrid_cell.SetPoints(cell.GetPoints()) cell = vtk.vtkHexahedron() for k_point in range(8): cell.GetPointIds().SetId(k_point, k_point) cell_array_cell = vtk.vtkCellArray() cell_array_cell.InsertNextCell(cell) ugrid_cell.SetCells(vtk.VTK_HEXAHEDRON, cell_array_cell) geometry_filter = vtk.vtkGeometryFilter() if (vtk.vtkVersion.GetVTKMajorVersion() >= 6): geometry_filter.SetInputData(ugrid_cell) else: geometry_filter.SetInput(ugrid_cell) geometry_filter.Update() cell_boundary = geometry_filter.GetOutput() pdata_points = vtk.vtkPolyData() pdata_points.SetPoints(points) enclosed_points_filter = vtk.vtkSelectEnclosedPoints() enclosed_points_filter.SetSurfaceData(cell_boundary) if (vtk.vtkVersion.GetVTKMajorVersion() >= 6): enclosed_points_filter.SetInputData(pdata_points) else: enclosed_points_filter.SetInput(pdata_points) enclosed_points_filter.Update() points_in_cell = [ k_point for k_point in range(points.GetNumberOfPoints()) if enclosed_points_filter.GetOutput().GetPointData().GetArray( "SelectedPoints").GetTuple1(k_point) ] return points_in_cell
def TagImageFromPolyDataSurface(surface, image, tag_value=1): # instantiate point locator in order to map data back to the image octree = vtk.vtkOctreePointLocator() octree.SetDataSet(image) octree.BuildLocator() # convert bounds of polydata to image extents extents = ConvertBoundsToExtents(image, surface.GetBounds()) # extract a smaller in order to iterate over less points voi = vtk.vtkExtractVOI() voi.SetInputData(image) voi.SetVOI(extents) voi.Update() # find which points are within the surface (polydata) provided selection = vtk.vtkSelectEnclosedPoints() selection.SetSurfaceData(surface) selection.SetInputData(voi.GetOutput()) selection.Update() # make sure to keep the same nomenclature for the vtk array to # not overwrite the current data scalars = ns.vtk_to_numpy(image.GetPointData().GetScalars()) scalars_name = image.GetPointData().GetScalars().GetName() # iterate and find which points are within the volume for i in range(selection.GetOutput().GetNumberOfPoints()): if selection.IsInside(i) == True: iD = octree.FindClosestPoint(selection.GetOutput().GetPoint(i)) scalars[iD] = tag_value # convert the numpy array to a vtk array s = ns.numpy_to_vtk(scalars) s.SetName(scalars_name) # update the image with the tagged values for the mapped volume image.GetPointData().SetScalars(s)
def getPointsInCell( points, cell, verbose=0): mypy.my_print(verbose, "*** getPointsInCell ***") ugrid_cell = vtk.vtkUnstructuredGrid() ugrid_cell.SetPoints(cell.GetPoints()) cell = vtk.vtkHexahedron() for k_point in xrange(8): cell.GetPointIds().SetId(k_point, k_point) cell_array_cell = vtk.vtkCellArray() cell_array_cell.InsertNextCell(cell) ugrid_cell.SetCells(vtk.VTK_HEXAHEDRON, cell_array_cell) geometry_filter = vtk.vtkGeometryFilter() if (vtk.vtkVersion.GetVTKMajorVersion() >= 6): geometry_filter.SetInputData(ugrid_cell) else: geometry_filter.SetInput(ugrid_cell) geometry_filter.Update() cell_boundary = geometry_filter.GetOutput() pdata_points = vtk.vtkPolyData() pdata_points.SetPoints(points) enclosed_points_filter = vtk.vtkSelectEnclosedPoints() enclosed_points_filter.SetSurfaceData(cell_boundary) if (vtk.vtkVersion.GetVTKMajorVersion() >= 6): enclosed_points_filter.SetInputData(pdata_points) else: enclosed_points_filter.SetInput(pdata_points) enclosed_points_filter.Update() points_in_cell = [k_point for k_point in xrange(points.GetNumberOfPoints()) if enclosed_points_filter.GetOutput().GetPointData().GetArray('SelectedPoints').GetTuple1(k_point)] return points_in_cell
def insidePoints(actor, points, invert=False, tol=1e-05): """Return list of points that are inside a polydata closed surface""" poly = polydata(actor, True) # check if the stl file is closed featureEdge = vtk.vtkFeatureEdges() featureEdge.FeatureEdgesOff() featureEdge.BoundaryEdgesOn() featureEdge.NonManifoldEdgesOn() setInput(featureEdge, poly) featureEdge.Update() openEdges = featureEdge.GetOutput().GetNumberOfCells() if openEdges != 0: colors.printc("Warning: polydata is not a closed surface", 5) vpoints = vtk.vtkPoints() for p in points: vpoints.InsertNextPoint(p) pointsPolydata = vtk.vtkPolyData() pointsPolydata.SetPoints(vpoints) sep = vtk.vtkSelectEnclosedPoints() sep.SetTolerance(tol) setInput(sep, pointsPolydata) if vtkMV: sep.SetSurfaceData(poly) else: sep.SetSurface(poly) sep.Update() mask1, mask2 = [], [] for i, p in enumerate(points): if sep.IsInside(i): mask1.append(p) else: mask2.append(p) if invert: return mask2 else: return mask1
import vtk # open stl stlReader = vtk.vtkSTLReader() stlReader.SetFileName( 'registerstl.stl' ) stlReader.Update() # check if point within bound vtkbound = vtk.vtkSelectEnclosedPoints() vtkbound.Initialize(stlReader.GetOutput()) for point in [(0.,0.,0.),(.4,.6,.7)]: print vtkbound.IsInsideSurface(point[0],point[1],point[2])
def main(): fn1, fn2 = get_program_parameters() polyData1 = ReadPolyData(fn1) if fn2: polyData2 = ReadPolyData(fn2) else: # If only one polydata is present, generate a second polydata by # rotating the original about its center. print('Generating modified polyData1') center = polyData1.GetCenter() transform = vtk.vtkTransform() transform.Translate(center[0], center[1], center[2]) transform.RotateY(90.0) transform.Translate(-center[0], -center[1], -center[2]) transformPD = vtk.vtkTransformPolyDataFilter() transformPD.SetTransform(transform) transformPD.SetInputData(polyData1) transformPD.Update() polyData2 = transformPD.GetOutput() # Mark points inside with 1 and outside with a 0 select = vtk.vtkSelectEnclosedPoints() select.SetInputData(polyData1) select.SetSurfaceData(polyData2) # Extract three meshes, one completely inside, one completely # outside and on the border between the inside and outside. threshold = vtk.vtkMultiThreshold() # Outside points have a 0 value in ALL points of a cell outsideId = threshold.AddBandpassIntervalSet( 0, 0, vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, 'SelectedPoints', 0, 1) # Inside points have a 1 value in ALL points of a cell insideId = threshold.AddBandpassIntervalSet( 1, 1, vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, 'SelectedPoints', 0, 1) # Border points have a 0 or a 1 in at least one point of a cell borderId = threshold.AddIntervalSet( 0, 1, vtk.vtkMultiThreshold.OPEN, vtk.vtkMultiThreshold.OPEN, vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, 'SelectedPoints', 0, 0) threshold.SetInputConnection(select.GetOutputPort()) # Select the intervals to be output threshold.OutputSet(outsideId) threshold.OutputSet(insideId) threshold.OutputSet(borderId) threshold.Update() # Visualize colors = vtk.vtkNamedColors() outsideColor = colors.GetColor3d('Crimson') insideColor = colors.GetColor3d('Banana') borderColor = colors.GetColor3d('Mint') surfaceColor = colors.GetColor3d('Peacock') backgroundColor = colors.GetColor3d('Silver') # Outside outsideMapper = vtk.vtkDataSetMapper() outsideMapper.SetInputData( threshold.GetOutput().GetBlock(outsideId).GetBlock(0)) outsideMapper.ScalarVisibilityOff() outsideActor = vtk.vtkActor() outsideActor.SetMapper(outsideMapper) outsideActor.GetProperty().SetDiffuseColor(outsideColor) outsideActor.GetProperty().SetSpecular(.6) outsideActor.GetProperty().SetSpecularPower(30) # Inside insideMapper = vtk.vtkDataSetMapper() insideMapper.SetInputData( threshold.GetOutput().GetBlock(insideId).GetBlock(0)) insideMapper.ScalarVisibilityOff() insideActor = vtk.vtkActor() insideActor.SetMapper(insideMapper) insideActor.GetProperty().SetDiffuseColor(insideColor) insideActor.GetProperty().SetSpecular(.6) insideActor.GetProperty().SetSpecularPower(30) insideActor.GetProperty().EdgeVisibilityOn() # Border borderMapper = vtk.vtkDataSetMapper() borderMapper.SetInputData( threshold.GetOutput().GetBlock(borderId).GetBlock(0)) borderMapper.ScalarVisibilityOff() borderActor = vtk.vtkActor() borderActor.SetMapper(borderMapper) borderActor.GetProperty().SetDiffuseColor(borderColor) borderActor.GetProperty().SetSpecular(.6) borderActor.GetProperty().SetSpecularPower(30) borderActor.GetProperty().EdgeVisibilityOn() surfaceMapper = vtk.vtkDataSetMapper() surfaceMapper.SetInputData(polyData2) surfaceMapper.ScalarVisibilityOff() # Surface of object containing cell surfaceActor = vtk.vtkActor() surfaceActor.SetMapper(surfaceMapper) surfaceActor.GetProperty().SetDiffuseColor(surfaceColor) surfaceActor.GetProperty().SetOpacity(.1) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.SetSize(640, 480) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.SetBackground(backgroundColor) renderer.UseHiddenLineRemovalOn() renderer.AddActor(surfaceActor) renderer.AddActor(outsideActor) renderer.AddActor(insideActor) renderer.AddActor(borderActor) renderWindow.SetWindowName('CellsInsideObject') renderWindow.Render() renderer.GetActiveCamera().Azimuth(30) renderer.GetActiveCamera().Elevation(30) renderer.GetActiveCamera().Dolly(1.25) renderWindow.Render() renderWindowInteractor.Start()
def CheckIntersections(self, inputModelHierarchyNode, inputFiducialNode): """ Look for intersections between the path (inputFiducialNode) and the models under the hierarchy node. Return (objectIDs, objectNames, normalVectors, entryAngles, curvatures, radiusVectors, totalLengthInObject), where the elements are the arrays of object IDs, names, normal vectors at the entry points, angles between the path and the normal vectors, curvatures at the entry points, normal vectors to the center, and the total length of the path in the object. """ if inputModelHierarchyNode == None: return None if inputFiducialNode == None: return None nOfModels = inputModelHierarchyNode.GetNumberOfChildrenNodes() objectIDs = [] objectNames = [] entryAngles = [] normalVectors = [] totalLengthInObject = [] curvaturesAtEntry = [] radiusNormalsAtEntry = [] for i in range(nOfModels): chnode = inputModelHierarchyNode.GetNthChildNode(i) if chnode == None: continue mnode = chnode.GetAssociatedNode() if mnode == None: continue name = mnode.GetName() objectPoly = mnode.GetPolyData() if objectPoly == None: continue triangle = vtk.vtkTriangleFilter() triangle.SetInputData(objectPoly) triangle.Update() objectTrianglePoly = triangle.GetOutput() # print "Processing object: %s" % name trajectoryPoints = vtk.vtkPoints() idList = vtk.vtkIdList() pos0 = [0.0] * 3 pos1 = [0.0] * 3 pos2 = [0.0] * 3 nFiducials = inputFiducialNode.GetNumberOfFiducials() posStart = None posEnd = None # Look for points inside the object for j in range(nFiducials): inputFiducialNode.GetNthFiducialPosition(j, pos0) trajectoryPoints.InsertNextPoint(pos0) trajectoryPoly = vtk.vtkPolyData() trajectoryPoly.SetPoints(trajectoryPoints) enclosed = vtk.vtkSelectEnclosedPoints() enclosed.SetInputData(trajectoryPoly) enclosed.SetSurfaceData(objectTrianglePoly) enclosed.SetTolerance( 0.0001) # Very important to get consistent result. enclosed.Update() lengthInObject = 0.0 isInside = False angles = [] normals = [] curvatures = [] radiusNormals = [] surfaceNormals = vtk.vtkPolyDataNormals() surfaceNormals.SetInputData(objectTrianglePoly) surfaceNormals.ComputeCellNormalsOn() surfaceNormals.Update() surfaceNormalsOutput = surfaceNormals.GetOutput() # extract the cell data surfaceNormalsCellData = surfaceNormalsOutput.GetCellData() sNormals = surfaceNormalsCellData.GetNormals() for j in range(nFiducials - 1): inputFiducialNode.GetNthFiducialPosition(j, pos0) inputFiducialNode.GetNthFiducialPosition(j + 1, pos1) isInside0 = enclosed.IsInside(j) isInside1 = enclosed.IsInside(j + 1) ## For debug #print "Point %d: from (%f, %f, %f) (%d) to (%f, %f, %f) (%d)" % (j, pos0[0], pos0[1], pos0[2], isInside0, pos1[0], pos1[1], pos1[2], isInside1) # A vector that represents the trajectory between pos0 and pos1 # The orientation will be adjusted later to direct to the outside of the object. trajVec = np.array(pos1) - np.array(pos0) if isInside0 and isInside1: ## Both in the object lSegment = np.linalg.norm(trajVec) lengthInObject = lengthInObject + lSegment isInside = True intersectingPoint = [0.0] * 3 if isInside0 != isInside1: ## Potential intersection bspTree = vtk.vtkModifiedBSPTree() bspTree.SetDataSet(objectTrianglePoly) bspTree.BuildLocator() tolerance = 0.0001 pCoord = [0.0] * 3 t = vtk.mutable(0) subID = vtk.mutable(0) cellID = vtk.mutable(0) fIntersect = bspTree.IntersectWithLine( pos0, pos1, tolerance, t, intersectingPoint, pCoord, subID, cellID) # idList = vtk.vtkIdList() # intersectingPoints = vtk.vtkPoints() # fIntersect = bspTree.IntersectWithLine(pos0, pos1, tolerance, intersectingPoints, idList) if fIntersect == 0: ## If this happens, consider smaller tolerance continue isInside = True # Get intersecting point and measure the length inside the boject # intersectingPoints.GetPoint(0, intersectingPoint) if isInside0: segmentInObject = np.array( intersectingPoint) - np.array(pos0) lengthInObject = lengthInObject + np.linalg.norm( segmentInObject) elif isInside1: segmentInObject = np.array( intersectingPoint) - np.array(pos1) lengthInObject = lengthInObject + np.linalg.norm( segmentInObject) trajVec = -trajVec # cellID = idList.GetId(0) cell = objectTrianglePoly.GetCell(cellID) if cell == None: continue cellNormal = [0.0] * 3 sNormals.GetTuple(cellID, cellNormal) # Check cell type? # if cell.GetCellType() == vtk.VTK_TRIANGLE: # subID = 0 # elif cell.GetCellType() == vtk.VTK_TRIANGLE_STRIP: # print "Triangle Strip" # # Get subID -- no need since the cells have already converted to triangles # cell.IntersectWithLine(pos0, pos1, tolerance, t, intersectingPoint, pCoord, subID) points = cell.GetPoints() if points == None: print "continue 4" continue p0 = [0.0] * 3 p1 = [0.0] * 3 p2 = [0.0] * 3 # Get point (when subID is used) # points.GetPoint(subID + 0, p0) # points.GetPoint(subID + 1, p1) # points.GetPoint(subID + 2, p2) points.GetPoint(0, p0) points.GetPoint(1, p1) points.GetPoint(2, p2) # print (intersectingPoint, p0, p1, p2) # npap0 = np.array(p0) # npap1 = np.array(p1) # npap2 = np.array(p2) # v0 = npap1-npap0 # v1 = npap2-npap0 # v = np.cross(v0, v1) # norm = np.linalg.norm(v,ord=1) # normVec = v / norm # print "Normal = (%f, %f, %f) / (%f, %f, %f)" % (normVec[0], normVec[1], normVec[2], cellNormal[0], cellNormal[1], cellNormal[2]) # Compute average normal #clippedModel = clip.GetOutput() # cellsNormal = clippedModel.GetCell(cellID).GetPointData().GetNormals() # # averageNormal = [0.0, 0.0, 0.0] # nOfNormals = 0; # # for cellIndex in range(0, cellsNormal.GetNumberOfTuples()): # cellNormal = [0.0, 0.0, 0.0] # cellsNormal.GetTuple(cellIndex, cellNormal) # # if not(math.isnan(cellNormal[0]) or math.isnan(cellNormal[1]) or math.isnan(cellNormal[2])): # averageNormal[0] = averageNormal[0] + cellNormal[0] # averageNormal[1] = averageNormal[1] + cellNormal[1] # averageNormal[2] = averageNormal[2] + cellNormal[2] # nOfNormals = nOfNormals + 1 # Calculate the entry angle. Entry angle is zero, when the trajectory is perpendicular # to the surface. # angle = vtk.vtkMath.AngleBetweenVectors(normVec, trajVec) * 180.0 / math.pi angle = vtk.vtkMath.AngleBetweenVectors( cellNormal, trajVec) * 180.0 / math.pi angles.append(angle) normals.append(cellNormal) trajNorm = np.linalg.norm(trajVec, ord=1) nTrajVec = trajVec if trajNorm > 0.0: nTrajVec = trajVec / trajNorm # # Caluclate the entry vector defined by: <v_e> = <n_t> - <n> # # where <n_t> and <n> are the trajectory vector and the normal. # entryVec = nTrajVec - normVec #print " -- Intersecting at (%f, %f, %f) with angle %f and normal vector (%f, %f, %f)" % (p[0], p[1], p[2], angle, normVec[0], normVec[1], normVec[2]) if j > 0: inputFiducialNode.GetNthFiducialPosition(j - 1, pos2) # inputFiducialNode.GetNthFiducialPosition(j, pos0) # inputFiducialNode.GetNthFiducialPosition(j+1, pos1) (kappa, vc) = self.ComputeCurvature(np.array(pos2), np.array(pos0), np.array(pos1)) curvatures.append(kappa) radiusNormals.append(vc) else: inputFiducialNode.GetNthFiducialPosition(j + 2, pos2) (kappa, vc) = self.ComputeCurvature(np.array(pos0), np.array(pos1), np.array(pos2)) curvatures.append(kappa) radiusNormals.append(vc) if isInside: objectIDs.append(i) objectNames.append(name) normalVectors.append(normals) entryAngles.append(angles) totalLengthInObject.append(lengthInObject) curvaturesAtEntry.append(curvatures) radiusNormalsAtEntry.append(radiusNormals) return (objectIDs, objectNames, normalVectors, entryAngles, totalLengthInObject, curvaturesAtEntry, radiusNormalsAtEntry)
transformPD1.Update() pd_3=transformPD1.GetOutput() writer=vtk.vtkPolyDataWriter() writer.SetInputData(pd_3) writer.SetFileName('pd_3.vtk') writer.Write() return pd, pd_2, pd_3, pts_shrink, size_points pd,pd_2,pd_3,pts_shrink, size_points=createShrunkVolume(mesh) pointsPolydata =vtk.vtkPolyData() pointsPolydata.SetPoints(pts_shrink) selectEnclosedPoints = vtk.vtkSelectEnclosedPoints() selectEnclosedPoints.SetInputData(pointsPolydata) selectEnclosedPoints.SetSurfaceData(pd_2) selectEnclosedPoints.Update() outputisinside=[] pt_isinside = vtk.vtkPoints() list_of_points2=[] inside_or_outside=[] for kk in range (0,size_points): xx=selectEnclosedPoints.IsInside(kk) inside_or_outside.append(xx)
def inside(path, number, points, labels): # time1=time.time() 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() openEdges = featureEdge.GetOutput().GetNumberOfCells() if openEdges != 0: print("STL file is not closed") print(openEdges) return openEdges # print(openEdges) # print(pdata.GetNumberOfPoints()) # 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) # for i in range() # checking for consistency of IsInside method filter.SetTolerance(0.00001) time1 = time.time() # obj_points=numpy.zeros([pdata.GetNumberOfPoints(),3]) # for i in range(pdata.GetNumberOfPoints()): # obj_points[i,:]=pdata.GetPoint(i) # obj_polygons = numpy.zeros([pdata.GetNumberOfCells(), 3, 3]) for i in range(pdata.GetNumberOfCells()): cell = vtk.vtkIdList() pdata.GetCellPoints(i, cell) for j in range(3): obj_polygons[i, j, :] = pdata.GetPoint(cell.GetId(j)) # print(obj_polygons) # distance = numpy.zeros(number) # pdata_GetNumberOfPoints=pdata.GetNumberOfPoints() # points=numpy.array(points) # label_point(number,distance,pdata_GetNumberOfPoints,obj_points,points,labels) for i in range(number): filter.SetInputData( getPolydata(points[i, 0], points[i, 1], points[i, 2])) filter.Update() labels[i, 0] = filter.IsInside(0) # if labels[i,0]==1: # print(1111,distance[i]) labels[i, 1] = 1 - labels[i, 0] pdata_GetNumberOfCells = pdata.GetNumberOfCells() label_surface(obj_polygons, pdata_GetNumberOfCells, distance, number, labels, points) print(time.time() - time1) # print(distance) return 0
def CalculateDistance(mito_surface_name, cell_inner_surface_name, cell_outer_surface_name): #Open the surface of Mito SurfaceMito = LegacyVTKReader(FileNames=[mito_surface_name]) SurfaceMito = GetActiveSource() SurfaceMito = servermanager.Fetch(SurfaceMito) #Open the outer surface of Cell OuterSurfaceCell = LegacyVTKReader(FileNames=[cell_outer_surface_name]) OuterSurfaceCell = GetActiveSource() OuterSurfaceCell = servermanager.Fetch(OuterSurfaceCell) geometryFilterOuterCell = vtk.vtkGeometryFilter() geometryFilterOuterCell.SetInputData(OuterSurfaceCell) geometryFilterOuterCell.Update() polydataOuterCell = geometryFilterOuterCell.GetOutput() #print polydataOuterCell.GetNumberOfPoints() #Open the inner surface of Cell InnerSurfaceCell = LegacyVTKReader(FileNames=[cell_inner_surface_name]) InnerSurfaceCell = GetActiveSource() InnerSurfaceCell = servermanager.Fetch(InnerSurfaceCell) geometryFilterInnerCell = vtk.vtkGeometryFilter() geometryFilterInnerCell.SetInputData(InnerSurfaceCell) geometryFilterInnerCell.Update() polydataInnerCell = geometryFilterInnerCell.GetOutput() #Get the bounds of the cell(xmin,xmax,ymin,ymax,zmin,zmax) bounds = [0] * 6 OuterSurfaceCell.GetBounds(bounds) #Creating the point locator LocatorMito = vtk.vtkPointLocator() LocatorMito.SetDataSet(SurfaceMito) LocatorMito.BuildLocator() #Vector to store the distance from foci to mito DistanceToMito = [] DistanceMoved = [] selectEnclosedPointsOuterCell = vtk.vtkSelectEnclosedPoints() selectEnclosedPointsOuterCell.Initialize(polydataOuterCell) selectEnclosedPointsInnerCell = vtk.vtkSelectEnclosedPoints() selectEnclosedPointsInnerCell.Initialize(polydataInnerCell) selectEnclosedPointsMito = vtk.vtkSelectEnclosedPoints() selectEnclosedPointsMito.Initialize(SurfaceMito) insideOuterCell = 0 insideInnerCell = 1 renderWindow = vtk.vtkRenderWindow() renderer = vtk.vtkRenderer() renderWindowInteractor = vtk.vtkRenderWindowInteractor() mapper = vtk.vtkPolyDataMapper() mapperMito = vtk.vtkPolyDataMapper() mapperMito.SetInputData(SurfaceMito) actorMito = vtk.vtkActor() actorMito.SetMapper(mapperMito) mapper.SetInputData(polydataOuterCell) #need to change mapperInner = vtk.vtkPolyDataMapper() mapperInner.SetInputData(polydataInnerCell) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetOpacity(0.5) actorinner = vtk.vtkActor() actorinner.SetMapper(mapperInner) actorinner.GetProperty().SetOpacity(0.5) renderWindow.SetSize(3000, 2000) renderWindow.AddRenderer(renderer) renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(actorMito) renderer.AddActor(actor) renderer.AddActor(actorinner) renderWindow.Render() while insideOuterCell == 0 and insideInnerCell == 1: x = random.uniform(bounds[0], bounds[1]) y = random.uniform(bounds[2], bounds[3]) z = random.uniform(bounds[4], bounds[5]) insideOuterCell = selectEnclosedPointsOuterCell.IsInsideSurface( x, y, z) insideInnerCell = selectEnclosedPointsInnerCell.IsInsideSurface( x, y, z) #Check to see if the random foci is inside the cell if insideOuterCell == 1 and insideInnerCell == 0: insideMito = selectEnclosedPointsMito.IsInsideSurface(x, y, z) #Check to see if the random foci is inside the mitochroniral if insideMito: insideOuterCell = 0 insideInnerCell = 1 continue else: #Calculate the distance between the foci (x,y,z) and the Surface foci = vtk.vtkSphereSource() foci.SetCenter(x, y, z) foci.SetRadius(0.05) mapper1 = vtk.vtkPolyDataMapper() mapper1.SetInputConnection(foci.GetOutputPort()) actor1 = vtk.vtkActor() actor1.GetProperty().SetColor(1, 0, 0) actor1.SetMapper(mapper1) renderWindow.AddRenderer(renderer) renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(actor1) renderWindow.Render() r = [x, y, z] ptId = LocatorMito.FindClosestPoint(r) u = SurfaceMito.GetPoints().GetPoint(ptId) distance = math.sqrt((r[0] - u[0])**2 + (r[1] - u[1])**2 + (r[2] - u[2])**2) DistanceToMito.append(distance) DistanceMoved.append(0) else: insideOuterCell = 0 insideInnerCell = 1 continue for randomNumber in range(timePoint): # mean of x,y,z muX = x muY = y muZ = z # standard deviation sigma = math.sqrt(2 * diffusionCoefficient * time) #Use xi = np.random.normal(muX, sigma, 1) yi = np.random.normal(muY, sigma, 1) zi = np.random.normal(muZ, sigma, 1) radius = math.sqrt((xi - x)**2 + (yi - y)**2 + (zi - z)**2) insideOuterCell = selectEnclosedPointsOuterCell.IsInsideSurface( xi, yi, zi) insideInnerCell = selectEnclosedPointsInnerCell.IsInsideSurface( xi, yi, zi) if insideOuterCell == 1 and insideInnerCell == 0: insideMito = selectEnclosedPointsMito.IsInsideSurface(xi, yi, zi) #Check to see if the random foci is inside the mitochroniral if insideMito: continue else: #Calculate the distance between the foci (x,y,z) and the Surface focii = vtk.vtkSphereSource() focii.SetCenter(xi, yi, zi) focii.SetRadius(0.05) mapper2 = vtk.vtkPolyDataMapper() mapper2.SetInputConnection(focii.GetOutputPort()) actor2 = vtk.vtkActor() actor2.SetMapper(mapper2) renderer.AddActor(actor2) path = vtk.vtkLineSource() path.SetPoint1(x, y, z) path.SetPoint2(xi, yi, zi) mapper3 = vtk.vtkPolyDataMapper() mapper3.SetInputConnection(path.GetOutputPort()) actor3 = vtk.vtkActor() actor3.SetMapper(mapper3) renderer.AddActor(actor3) renderWindow.Render() r = [xi, yi, zi] ptId = LocatorMito.FindClosestPoint(r) u = SurfaceMito.GetPoints().GetPoint(ptId) distance = math.sqrt((r[0] - u[0])**2 + (r[1] - u[1])**2 + (r[2] - u[2])**2) DistanceToMito.append(distance) DistanceMoved.append(radius) x = xi y = yi z = zi else: continue renderWindow.Render() renderWindowInteractor.Start() Delete(GetActiveSource()) del SurfaceMito del OuterSurfaceCell del InnerSurfaceCell del LocatorMito return DistanceToMito, DistanceMoved
def renderthis(self,warunek): # open a window and create a renderer self.widget.GetRenderWindow().AddRenderer(self.ren) # open file openFileDialog = wx.FileDialog(self, "Open STL file", "", self.filename, "*.stl", wx.FD_OPEN | wx.FD_FILE_MUST_EXIST) if openFileDialog.ShowModal() == wx.ID_CANCEL: return self.filename = openFileDialog.GetPath() # render the data reader = vtk.vtkSTLReader() reader.SetFileName(self.filename) reader.Update() mesh = reader.GetOutput() # To take the polygonal data from the vtkConeSource and # create a rendering for the renderer. coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInput(reader.GetOutput()) # create an actor for our scene if self.isploted: coneActor=self.ren.GetActors().GetLastActor() self.ren.RemoveActor(coneActor) coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) # Add actor self.ren.AddActor(coneActor) # print self.ren.GetActors().GetNumberOfItems() #addPoint(self.ren, pSource, color=[1.0,0.0,0.0]) #addPoint(self.ren, pTarget, color=[1.0,0.0,1.0]) addLine(self.ren, pp1, pp2) addLine(self.ren, pp3, pp4) addLine(self.ren, pp5, pp6) addLine(self.ren, pp7, pp8) addLine(self.ren, pp1, pp7) addLine(self.ren, pp3, pp5) addLine(self.ren, pp4, pp6) addLine(self.ren, pp2, pp8) addLine(self.ren, pp1, pp3) addLine(self.ren, pp7, pp5) addLine(self.ren, pp4, pp2) addLine(self.ren, pp6, pp8) if warunek==1: addEdges(self.ren) ##################################################################################### featureEdge=vtk.vtkFeatureEdges() featureEdge.FeatureEdgesOff() featureEdge.BoundaryEdgesOn() featureEdge.NonManifoldEdgesOn() featureEdge.SetInput(mesh) featureEdge.Update() openEdges = featureEdge.GetOutput().GetNumberOfCells() if openEdges != 0: print "the stl file is not closed" select = vtk.vtkSelectEnclosedPoints() select.SetSurface(mesh) inside_polydat = vtk.vtkPolyData() forcing_polydat = vtk.vtkPolyData() interpolation_polydat = vtk.vtkPolyData() inside_points = vtk.vtkPoints() forcing_points = vtk.vtkPoints() interpolation_points = vtk.vtkPoints() # for i in range(11): #IsInside(i-5,0.1,0.1,mesh) global licz global licz2 global licznik for j in range(1,lwY+1): for i in range(1,lwX+1): licz += 1 print (licz/float(stoProcent))*100.0 for k in range(1,lwZ+1): sprawdzenie = 0 siatkaX[1]=xmin+0.001 siatkaX[lwX]=xmax-0.001 siatkaY[1]=ymin+0.001 siatkaY[lwY]=ymax-0.001 siatkaZ[1]=zmin+0.001 siatkaZ[lwZ]=zmax-0.001 sprawdzenie = IsInsideCheck(siatkaX[i],siatkaY[j],siatkaZ[k],mesh) siatkaX[1]=xmin siatkaX[lwX]=xmax siatkaY[1]=ymin siatkaY[lwY]=ymax siatkaZ[1]=zmin siatkaZ[lwZ]=zmax mesh_point_inside = [siatkaX[i],siatkaY[j],siatkaZ[k]] #mesh_point_forcing = [siatkaX[i]+1.0,siatkaY[j],siatkaZ[k]] maska[licznik] = sprawdzenie licznik=licznik+1 if sprawdzenie == 1: inside_points.InsertNextPoint(mesh_point_inside) #forcing_points.InsertNextPoint(mesh_point_forcing) licznik=0 licznik_forcing=0 for j in range(0,lwY): for i in range(0,lwX): for k in range(0,lwZ): #print j,i,k maska3D[j][i][k]=maska[licznik] licznik=licznik+1 #print maska3D find_forcing_points(lwY,lwX,lwZ,maska3D,forcing_points,siatkaX,siatkaY,siatkaZ,boundary_points,mesh,intersection,maska3D_forcing,interpolation_points,fnix,fniy,fniz,fncx,fncy,fncz) for j in range(0,lwY): for i in range(0,lwX): for k in range(0,lwZ): if maska3D_forcing[j][i][k] > 0: licznik_forcing = licznik_forcing+maska3D_forcing[j][i][k] for i in range(0,licznik_forcing): print i,fnix[i],fniy[i],fniz[i],fncx[i],fncy[i],fncz[i] odczyt_STL(self.filename,normals,licznik_forcing,fnix,fniy,fniz,fncx,fncy,fncz) zp = [0,0,0] for i in range(0,licznik_forcing): if fncx[i]>0 and normals[i][0]<0: normals[i][0]=normals[i][0]*(-1.0) if fncx[i]<0 and normals[i][0]>0: normals[i][0]=normals[i][0]*(-1.0) if fncy[i]>0 and normals[i][1]<0: normals[i][1]=normals[i][1]*(-1.0) if fncy[i]<0 and normals[i][1]>0: normals[i][1]=normals[i][1]*(-1.0) if fncz[i]>0 and normals[i][2]<0: normals[i][2]=normals[i][2]*(-1.0) if fncz[i]<0 and normals[i][2]>0: normals[i][2]=normals[i][2]*(-1.0) for i in range(0,licznik_forcing): zp1 = [fncx[i],fncy[i],fncz[i]] zp2 = [normals[i][0]+fncx[i],normals[i][1]+fncy[i],normals[i][2]+fncz[i]] #normals[i][0]=normals[i][0]+fncx[i] #normals[i][1]=normals[i][1]+fncy[i] #normals[i][2]=normals[i][2]+fncz[i] addLine(self.ren, zp1, zp2) print i,normals[i],zp1,zp2 #print intersection #print "+++++++++++++++++++=" #print maska3D_forcing """ licznik=0 for j in range(0,lwY): for i in range(0,lwX-1): for k in range(0,lwZ): mesh_point_forcing = [siatkaX[i+1],siatkaY[j+1],siatkaZ[k+1]] if (maska3D[j][i][k] == 0) and (maska3D[j][i+1][k] == 1): forcing_points.InsertNextPoint(mesh_point_forcing) licznik=licznik+1 """ zapis = open('Maska.txt', 'w') for i in range(0,lwX*lwY*lwZ): zapis.write(str(maska[i])) zapis.write('\n') zapis.close() print "zapisano Maske" inside_polydat.SetPoints(inside_points) inside = vtk.vtkSphereSource() inside.SetRadius(0.02) inside.SetPhiResolution(8) inside.SetThetaResolution(8) ballGlyph = vtkGlyph3D() ballGlyph.SetColorModeToColorByScalar() ballGlyph.SetSourceConnection(inside.GetOutputPort()) ballGlyph.SetInput(inside_polydat) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(ballGlyph.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor([1.0,0.0,0.0]) self.ren.AddActor(actor) ###################################################################################### forcing_polydat.SetPoints(forcing_points) forcing = vtk.vtkSphereSource() #point.SetCenter(pS) forcing.SetRadius(0.02) forcing.SetPhiResolution(8) forcing.SetThetaResolution(8) forcingGlyph = vtkGlyph3D() forcingGlyph.SetColorModeToColorByScalar() forcingGlyph.SetSourceConnection(forcing.GetOutputPort()) forcingGlyph.SetInput(forcing_polydat) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(forcingGlyph.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor([0.0,1.0,0.0]) self.ren.AddActor(actor) ##################################################################################### """ interpolation_polydat.SetPoints(interpolation_points) interpolation = vtk.vtkSphereSource() #point.SetCenter(pS) interpolation.SetRadius(0.02) interpolation.SetPhiResolution(8) interpolation.SetThetaResolution(8) interpolationGlyph = vtkGlyph3D() interpolationGlyph.SetColorModeToColorByScalar() interpolationGlyph.SetSourceConnection(interpolation.GetOutputPort()) interpolationGlyph.SetInput(interpolation_polydat) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(interpolationGlyph.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor([0.0,0.0,1.0]) self.ren.AddActor(actor) """ ##################################################################################### obbTree = vtk.vtkOBBTree() obbTree.SetDataSet(mesh) obbTree.BuildLocator() pointsVTKintersection = vtk.vtkPoints() obbTree.IntersectWithLine(pSource, pTarget, pointsVTKintersection, None) pointsVTKIntersectionData = pointsVTKintersection.GetData() noPointsVTKIntersection = pointsVTKIntersectionData.GetNumberOfTuples() pointsIntersection = [] for idx in range(noPointsVTKIntersection): _tup = pointsVTKIntersectionData.GetTuple3(idx) pointsIntersection.append(_tup) print pointsIntersection if not self.isploted: axes = vtk.vtkAxesActor() self.marker = vtk.vtkOrientationMarkerWidget() self.marker.SetInteractor( self.widget._Iren ) self.marker.SetOrientationMarker( axes ) self.marker.SetViewport(0.75,0,1,0.25) self.marker.SetEnabled(1) self.ren.ResetCamera() self.ren.ResetCameraClippingRange() #cam = self.ren.GetActiveCamera() self.cam.Elevation(50) self.cam.Azimuth(40) #cam.SetPosition(0,0,1) #cam.SetFocalPoint(0,0,-50) self.isploted = True self.ren.Render()
def renderthis(self, warunek): # open a window and create a renderer self.widget.GetRenderWindow().AddRenderer(self.ren) # open file openFileDialog = wx.FileDialog(self, "Open STL file", "", self.filename, "*.stl", wx.FD_OPEN | wx.FD_FILE_MUST_EXIST) if openFileDialog.ShowModal() == wx.ID_CANCEL: return self.filename = openFileDialog.GetPath() # render the data reader = vtk.vtkSTLReader() reader.SetFileName(self.filename) reader.Update() mesh = reader.GetOutput() # To take the polygonal data from the vtkConeSource and # create a rendering for the renderer. coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInput(reader.GetOutput()) # create an actor for our scene if self.isploted: coneActor = self.ren.GetActors().GetLastActor() self.ren.RemoveActor(coneActor) coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) # Add actor self.ren.AddActor(coneActor) # print self.ren.GetActors().GetNumberOfItems() #addPoint(self.ren, pSource, color=[1.0,0.0,0.0]) #addPoint(self.ren, pTarget, color=[1.0,0.0,1.0]) addLine(self.ren, pp1, pp2) addLine(self.ren, pp3, pp4) addLine(self.ren, pp5, pp6) addLine(self.ren, pp7, pp8) addLine(self.ren, pp1, pp7) addLine(self.ren, pp3, pp5) addLine(self.ren, pp4, pp6) addLine(self.ren, pp2, pp8) addLine(self.ren, pp1, pp3) addLine(self.ren, pp7, pp5) addLine(self.ren, pp4, pp2) addLine(self.ren, pp6, pp8) if warunek == 1: addEdges(self.ren) ##################################################################################### featureEdge = vtk.vtkFeatureEdges() featureEdge.FeatureEdgesOff() featureEdge.BoundaryEdgesOn() featureEdge.NonManifoldEdgesOn() featureEdge.SetInput(mesh) featureEdge.Update() openEdges = featureEdge.GetOutput().GetNumberOfCells() if openEdges != 0: print "the stl file is not closed" select = vtk.vtkSelectEnclosedPoints() select.SetSurface(mesh) inside_polydat = vtk.vtkPolyData() forcing_polydat = vtk.vtkPolyData() interpolation_polydat = vtk.vtkPolyData() inside_points = vtk.vtkPoints() forcing_points = vtk.vtkPoints() interpolation_points = vtk.vtkPoints() # for i in range(11): #IsInside(i-5,0.1,0.1,mesh) global licz global licz2 global licznik for j in range(1, lwY + 1): for i in range(1, lwX + 1): licz += 1 print(licz / float(stoProcent)) * 100.0 for k in range(1, lwZ + 1): sprawdzenie = 0 siatkaX[1] = xmin + 0.001 siatkaX[lwX] = xmax - 0.001 siatkaY[1] = ymin + 0.001 siatkaY[lwY] = ymax - 0.001 siatkaZ[1] = zmin + 0.001 siatkaZ[lwZ] = zmax - 0.001 sprawdzenie = IsInsideCheck(siatkaX[i], siatkaY[j], siatkaZ[k], mesh) siatkaX[1] = xmin siatkaX[lwX] = xmax siatkaY[1] = ymin siatkaY[lwY] = ymax siatkaZ[1] = zmin siatkaZ[lwZ] = zmax mesh_point_inside = [siatkaX[i], siatkaY[j], siatkaZ[k]] #mesh_point_forcing = [siatkaX[i]+1.0,siatkaY[j],siatkaZ[k]] maska[licznik] = sprawdzenie licznik = licznik + 1 if sprawdzenie == 1: inside_points.InsertNextPoint(mesh_point_inside) #forcing_points.InsertNextPoint(mesh_point_forcing) licznik = 0 licznik_forcing = 0 for j in range(0, lwY): for i in range(0, lwX): for k in range(0, lwZ): #print j,i,k maska3D[j][i][k] = maska[licznik] licznik = licznik + 1 #print maska3D find_forcing_points(lwY, lwX, lwZ, maska3D, forcing_points, siatkaX, siatkaY, siatkaZ, boundary_points, mesh, intersection, maska3D_forcing, interpolation_points, fnix, fniy, fniz, fncx, fncy, fncz) for j in range(0, lwY): for i in range(0, lwX): for k in range(0, lwZ): if maska3D_forcing[j][i][k] > 0: licznik_forcing = licznik_forcing + maska3D_forcing[j][ i][k] for i in range(0, licznik_forcing): print i, fnix[i], fniy[i], fniz[i], fncx[i], fncy[i], fncz[i] odczyt_STL(self.filename, normals, licznik_forcing, fnix, fniy, fniz, fncx, fncy, fncz) zp = [0, 0, 0] for i in range(0, licznik_forcing): if fncx[i] > 0 and normals[i][0] < 0: normals[i][0] = normals[i][0] * (-1.0) if fncx[i] < 0 and normals[i][0] > 0: normals[i][0] = normals[i][0] * (-1.0) if fncy[i] > 0 and normals[i][1] < 0: normals[i][1] = normals[i][1] * (-1.0) if fncy[i] < 0 and normals[i][1] > 0: normals[i][1] = normals[i][1] * (-1.0) if fncz[i] > 0 and normals[i][2] < 0: normals[i][2] = normals[i][2] * (-1.0) if fncz[i] < 0 and normals[i][2] > 0: normals[i][2] = normals[i][2] * (-1.0) for i in range(0, licznik_forcing): zp1 = [fncx[i], fncy[i], fncz[i]] zp2 = [ normals[i][0] + fncx[i], normals[i][1] + fncy[i], normals[i][2] + fncz[i] ] #normals[i][0]=normals[i][0]+fncx[i] #normals[i][1]=normals[i][1]+fncy[i] #normals[i][2]=normals[i][2]+fncz[i] addLine(self.ren, zp1, zp2) print i, normals[i], zp1, zp2 #print intersection #print "+++++++++++++++++++=" #print maska3D_forcing """ licznik=0 for j in range(0,lwY): for i in range(0,lwX-1): for k in range(0,lwZ): mesh_point_forcing = [siatkaX[i+1],siatkaY[j+1],siatkaZ[k+1]] if (maska3D[j][i][k] == 0) and (maska3D[j][i+1][k] == 1): forcing_points.InsertNextPoint(mesh_point_forcing) licznik=licznik+1 """ zapis = open('Maska.txt', 'w') for i in range(0, lwX * lwY * lwZ): zapis.write(str(maska[i])) zapis.write('\n') zapis.close() print "zapisano Maske" inside_polydat.SetPoints(inside_points) inside = vtk.vtkSphereSource() inside.SetRadius(0.02) inside.SetPhiResolution(8) inside.SetThetaResolution(8) ballGlyph = vtkGlyph3D() ballGlyph.SetColorModeToColorByScalar() ballGlyph.SetSourceConnection(inside.GetOutputPort()) ballGlyph.SetInput(inside_polydat) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(ballGlyph.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor([1.0, 0.0, 0.0]) self.ren.AddActor(actor) ###################################################################################### forcing_polydat.SetPoints(forcing_points) forcing = vtk.vtkSphereSource() #point.SetCenter(pS) forcing.SetRadius(0.02) forcing.SetPhiResolution(8) forcing.SetThetaResolution(8) forcingGlyph = vtkGlyph3D() forcingGlyph.SetColorModeToColorByScalar() forcingGlyph.SetSourceConnection(forcing.GetOutputPort()) forcingGlyph.SetInput(forcing_polydat) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(forcingGlyph.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor([0.0, 1.0, 0.0]) self.ren.AddActor(actor) ##################################################################################### """ interpolation_polydat.SetPoints(interpolation_points) interpolation = vtk.vtkSphereSource() #point.SetCenter(pS) interpolation.SetRadius(0.02) interpolation.SetPhiResolution(8) interpolation.SetThetaResolution(8) interpolationGlyph = vtkGlyph3D() interpolationGlyph.SetColorModeToColorByScalar() interpolationGlyph.SetSourceConnection(interpolation.GetOutputPort()) interpolationGlyph.SetInput(interpolation_polydat) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(interpolationGlyph.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor([0.0,0.0,1.0]) self.ren.AddActor(actor) """ ##################################################################################### obbTree = vtk.vtkOBBTree() obbTree.SetDataSet(mesh) obbTree.BuildLocator() pointsVTKintersection = vtk.vtkPoints() obbTree.IntersectWithLine(pSource, pTarget, pointsVTKintersection, None) pointsVTKIntersectionData = pointsVTKintersection.GetData() noPointsVTKIntersection = pointsVTKIntersectionData.GetNumberOfTuples() pointsIntersection = [] for idx in range(noPointsVTKIntersection): _tup = pointsVTKIntersectionData.GetTuple3(idx) pointsIntersection.append(_tup) print pointsIntersection if not self.isploted: axes = vtk.vtkAxesActor() self.marker = vtk.vtkOrientationMarkerWidget() self.marker.SetInteractor(self.widget._Iren) self.marker.SetOrientationMarker(axes) self.marker.SetViewport(0.75, 0, 1, 0.25) self.marker.SetEnabled(1) self.ren.ResetCamera() self.ren.ResetCameraClippingRange() #cam = self.ren.GetActiveCamera() self.cam.Elevation(50) self.cam.Azimuth(40) #cam.SetPosition(0,0,1) #cam.SetFocalPoint(0,0,-50) self.isploted = True self.ren.Render()
def GenerateParticles(self): (mesh, minPoint, maxPoint) = self.STLMESH("box3D.stl") mntable = MNTable3D(minPoint, maxPoint, self.RMAX * 2.0, 1) packer = InsertGenerator3D(self.RMIN, self.RMAX, 1000, 1000, 1.0e-6, True) packer.generatePacking(mesh, mntable, 0, 1) mntable.generateBondsTagged(0, 1.0e-6, 0, 1, 1) mntable.write("tempas.vtu", 2) reader = vtk.vtkXMLUnstructuredGridReader() reader.SetFileName("tempas.vtu") reader.Update() self.particles = reader.GetOutput() reader = vtk.vtkXMLUnstructuredGridReader() reader.SetFileName("tempas.vtu") reader.Update() rodReader = vtk.vtkSTLReader() rodReader.SetFileName("rod3D.stl") rodReader.Update() betonasReader = vtk.vtkSTLReader() betonasReader.SetFileName("betonas3D.stl") betonasReader.Update() v1 = vtk.vtkSelectEnclosedPoints() v1.SetInputConnection(reader.GetOutputPort()) v1.SetSurfaceConnection(rodReader.GetOutputPort()) v1.CheckSurfaceOn() v1.InsideOutOff() v1.SetTolerance(1.0e-6) v1.Update() print(v1.GetOutput()) v1insideArray = v1.GetOutput().GetPointData().GetArray( "SelectedPoints") particleId = [] particleId1 = [] print(v1insideArray.GetNumberOfTuples()) for x in range(v1insideArray.GetNumberOfTuples()): particleId.append(v1insideArray.GetTuple1(x)) v2 = vtk.vtkSelectEnclosedPoints() v2.SetInputConnection(reader.GetOutputPort()) v2.SetSurfaceConnection(betonasReader.GetOutputPort()) v2.CheckSurfaceOn() v2.InsideOutOff() v2.SetTolerance(1.0e-6) v2.Update() v2insideArray = v2.GetOutput().GetPointData().GetArray( "SelectedPoints") for x in range(v2insideArray.GetNumberOfTuples()): particleId1.append(v2insideArray.GetTuple1(x)) #particleId.append(v2insideArray.GetTuple1(x)) poly = vtk.vtkPolyData() points = vtk.vtkPoints() cells = vtk.vtkCellArray() particle_id = vtk.vtkDoubleArray() particle_id.SetName("ID") particle_id.SetNumberOfComponents(1) radius = vtk.vtkDoubleArray() radius.SetName("RADIUS") radius.SetNumberOfComponents(1) bonds = vtk.vtkIntArray() bonds.SetName("BONDS_ID") bonds.SetNumberOfComponents(1) data = reader.GetOutput() for x in range(data.GetNumberOfPoints()): #val=v1insideArray.GetTuple1(x) ppp = data.GetPoint(x) points.InsertNextPoint(ppp[0] / 1000.0, ppp[1] / 1000.0, ppp[2] / 1000.0) radius.InsertNextTuple1( data.GetPointData().GetArray("radius").GetTuple1(x) / 1000.0) val = 0 if (particleId[x] == 0 and particleId1[x] == 0): val = 0 if (particleId1[x] != 0): val = 1 if (particleId[x] != 0): val = 2 particle_id.InsertNextTuple1(val) for x in range(data.GetNumberOfCells()): cell = data.GetCell(x) cells.InsertNextCell(2) cells.InsertCellPoint(cell.GetPointId(0)) cells.InsertCellPoint(cell.GetPointId(1)) v1 = particle_id.GetTuple1(cell.GetPointId(0)) v2 = particle_id.GetTuple1(cell.GetPointId(1)) bonds.InsertNextTuple1(0) if (v1 == 0 and v2 == 0): bonds.SetTuple1(x, 0) if ((v1 == 1 and v2 == 0) or (v1 == 0 and v2 == 1)): bonds.SetTuple1(x, 0) if ((v1 == 0 and v2 == 2) or (v1 == 2 and v2 == 0)): bonds.SetTuple1(x, 0) if (v1 == 1 and v2 == 1): bonds.SetTuple1(x, 1) if (v1 == 2 and v2 == 2): bonds.SetTuple1(x, 2) if ((v1 == 1 and v2 == 2) or (v1 == 2 and v2 == 1)): bonds.SetTuple1(x, 3) poly.SetPoints(points) poly.GetPointData().SetScalars(radius) poly.GetPointData().AddArray(particle_id) poly.GetCellData().SetScalars(bonds) poly.SetLines(cells) poly.GetPointData().SetActiveScalars("ID") th = vtk.vtkThreshold() th.SetInputData(poly) th.ThresholdByUpper(0.5) th.SetInputArrayToProcess(0, 0, 0, 0, 'ID') th.Update() writer = vtk.vtkXMLUnstructuredGridWriter() writer.SetFileName("final.vtu") writer.SetInputConnection(th.GetOutputPort()) writer.Write() boxSTL = vtk.vtkSTLReader() boxSTL.SetFileName("box3D.stl") boxSTL.Update() boxbounds = boxSTL.GetOutput().GetBounds() betonasSTL = vtk.vtkSTLReader() betonasSTL.SetFileName("betonas3D.stl") betonasSTL.Update() bounds = betonasSTL.GetOutput().GetBounds() print(bounds) reader = vtk.vtkXMLUnstructuredGridReader() reader.SetFileName("final.vtu") reader.Update() KIEKIS = reader.GetOutput().GetNumberOfPoints() NumberOfCells = reader.GetOutput().GetNumberOfCells() poly = vtk.vtkPolyData() pp = vtk.vtkPoints() pp.SetNumberOfPoints(KIEKIS) rad_seg = vtk.vtkDoubleArray() rad_seg.SetName("UNIQUE_RADIUS") rad_seg.SetNumberOfComponents(1) rad_seg.SetNumberOfTuples(1) rad_seg.SetTuple1(0, self.RMIN / 1000.0) rad = vtk.vtkDoubleArray() rad.SetName("RADIUS") rad.SetNumberOfComponents(1) rad.SetNumberOfTuples(KIEKIS) vel = vtk.vtkDoubleArray() vel.SetName("VELOCITY") vel.SetNumberOfComponents(3) vel.SetNumberOfTuples(KIEKIS) part_type = vtk.vtkIntArray() part_type.SetName("PARTICLE_TYPE") part_type.SetNumberOfComponents(1) part_type.SetNumberOfTuples(KIEKIS) part_material = vtk.vtkIntArray() part_material.SetName("PARTICLE_MATERIAL") part_material.SetNumberOfComponents(1) part_material.SetNumberOfTuples(KIEKIS) part_fix = vtk.vtkIntArray() part_fix.SetName("PARTICLE_FIX") part_fix.SetNumberOfComponents(1) part_fix.SetNumberOfTuples(KIEKIS) for x in range(KIEKIS): r = reader.GetOutput().GetPointData().GetArray("RADIUS").GetTuple1( x) pid = reader.GetOutput().GetPointData().GetArray("ID").GetTuple1(x) p = reader.GetOutput().GetPoint(x) pp.SetPoint(x, p) rad.SetTuple1(x, r) vel.SetTuple3(x, 0, 0, 0) part_type.SetTuple1(x, 0) part_fix.SetTuple1(x, 0) mat_id = 0 if (pid == 2): mat_id = 0 if (pid == 1): mat_id = 1 mat_id = random.randint(1, self.Max_material_count - 1) part_material.SetTuple1(x, mat_id) if (True): if (p[2] < bounds[4] / 1000.0): vel.SetTuple3(x, 0, 0, 0) part_fix.SetTuple1(x, 1) if (p[2] > bounds[5] / 1000.0): vel.SetTuple3(x, 0, 0, self.v) part_fix.SetTuple1(x, 1) cellsLines = vtk.vtkCellArray() state = vtk.vtkIntArray() state.SetName("STATE") state.SetNumberOfComponents(1) state.SetNumberOfTuples(NumberOfCells) force_N = vtk.vtkDoubleArray() force_N.SetName("F_N_LIMIT") force_N.SetNumberOfComponents(1) force_N.SetNumberOfTuples(NumberOfCells) force_T = vtk.vtkDoubleArray() force_T.SetName("F_T_LIMIT") force_T.SetNumberOfComponents(1) force_T.SetNumberOfTuples(NumberOfCells) for x in range(NumberOfCells): cell = reader.GetOutput().GetCell(x) cellsLines.InsertNextCell(2) cellsLines.InsertCellPoint(cell.GetPointId(0)) cellsLines.InsertCellPoint(cell.GetPointId(1)) state.SetTuple1(x, 0) bond_id = int(reader.GetOutput().GetCellData().GetArray( "BONDS_ID").GetTuple1(x)) force_T.SetTuple1(x, 0) force_N.SetTuple1( x, random.uniform(self.F_N_RANGES[bond_id][0], self.F_N_RANGES[bond_id][1])) force_T.SetTuple1( x, random.uniform(self.F_T_RANGES[bond_id][0], self.F_T_RANGES[bond_id][1])) poly.SetPoints(pp) poly.GetPointData().SetScalars(rad) poly.GetPointData().AddArray(vel) poly.GetPointData().AddArray(part_type) poly.GetPointData().AddArray(part_fix) poly.GetPointData().AddArray(part_material) poly.GetFieldData().AddArray(rad_seg) poly.SetLines(cellsLines) poly.GetCellData().SetScalars(state) poly.GetCellData().AddArray(force_N) poly.GetCellData().AddArray(force_T) # tran = vtk.vtkTransform() tran.Scale(0.001, 0.001, 0.001) tranf = vtk.vtkTransformFilter() tranf.SetTransform(tran) tranf.SetInputConnection(boxSTL.GetOutputPort()) tranf.Update() bbbbbb = tranf.GetOutput().GetBounds() tran = vtk.vtkTransform() tran.Translate(-bbbbbb[0], -bbbbbb[2], -bbbbbb[4]) tranf1 = vtk.vtkTransformFilter() tranf1.SetTransform(tran) tranf1.SetInputConnection(tranf.GetOutputPort()) tranf1.Update() aa = vtk.vtkDataSetWriter() aa.SetFileName("mesh.vtk") aa.SetInputConnection(tranf1.GetOutputPort()) aa.Write() tranf1 = vtk.vtkTransformFilter() tranf1.SetTransform(tran) tranf1.SetInputData(poly) tranf1.Update() writer = vtk.vtkXMLPolyDataWriter() writer.SetFileName("input.vtp") #writer.SetInputData(poly) writer.SetInputData(tranf1.GetOutput()) writer.Write() #minPoint,maxPoint tran = vtk.vtkTransform() tran.Scale(0.001, 0.001, 0.001) tran.Translate(-boxbounds[0], -boxbounds[2], -boxbounds[4]) tranf = vtk.vtkTransformFilter() tranf.SetTransform(tran) tranf.SetInputConnection(betonasReader.GetOutputPort()) tranf.Update() www = vtk.vtkDataSetWriter() www.SetInputConnection(tranf.GetOutputPort()) www.SetFileName("betonas3D.vtk") www.Write() tranf = vtk.vtkTransformFilter() tranf.SetTransform(tran) tranf.SetInputConnection(rodReader.GetOutputPort()) tranf.Update() www = vtk.vtkDataSetWriter() www.SetInputConnection(tranf.GetOutputPort()) www.SetFileName("rod3D.vtk") www.Write() E = np.linspace(self.E - self.E * self.MATERIAL_PASIMETYMAS_PROC, self.E + self.E * self.MATERIAL_PASIMETYMAS_PROC, num=self.Max_material_count) MIU = np.linspace(self.MIU - self.MIU * self.MATERIAL_PASIMETYMAS_PROC, self.MIU + self.MIU * self.MATERIAL_PASIMETYMAS_PROC, num=self.Max_material_count) RO = np.linspace(self.RO - self.RO * self.MATERIAL_PASIMETYMAS_PROC, self.RO + self.RO * self.MATERIAL_PASIMETYMAS_PROC, num=self.Max_material_count) E[0] = self.E_STEEL MIU[0] = self.MIU_STEEL RO[0] = self.RO_STEEL eilute = '"COUNT":' + str(self.Max_material_count) + ',\n' eilute = eilute + '"E":' + str(E) + ",\n" eilute = eilute + '"MIU":' + str(MIU) + ",\n" eilute = eilute + '"RO":' + str(RO) + ",\n" eilute = eilute + "\n\n" kk = 0 eil = '"CONTACT_LIST":[' mmm = '"MIU_COULOMB":[' for x in range(self.Max_material_count): kk = kk + 1 eil = eil + "[" + str(x) + "," + str(x) + "]," mmm = mmm + str(0.6) + "," for x in range(self.Max_material_count): for y in range(self.Max_material_count): if (x != y and x < y): kk = kk + 1 eil = eil + "[" + str(x) + "," + str(y) + "]," mmm = mmm + str(0.6) + "," eil = eil[:-1] + "],\n" mmm = mmm[:-1] + "]\n" eilute = eilute + '"COUNT:' + str(kk) + '",\n' eilute = eilute + eil + "\n" + mmm + "\n" print eilute
def Sperate(): reader=vtk.vtkXMLUnstructuredGridReader() reader.SetFileName("tempas.vtu") reader.Update() rodReader = vtk.vtkSTLReader() rodReader.SetFileName(rodas) rodReader.Update() betonasReader = vtk.vtkSTLReader() betonasReader.SetFileName(betonas) betonasReader.Update() v1=vtk.vtkSelectEnclosedPoints() v1.SetInputConnection(reader.GetOutputPort()) v1.SetSurfaceConnection(rodReader.GetOutputPort()) v1.CheckSurfaceOn () v1.InsideOutOff () v1.SetTolerance (1.0e-6) v1.Update() v1insideArray = v1.GetOutput().GetPointData().GetArray("SelectedPoints"); particleId=[] particleId1=[] for x in range(v1insideArray.GetNumberOfTuples()): particleId.append(v1insideArray.GetTuple1(x)) v2=vtk.vtkSelectEnclosedPoints() v2.SetInputConnection(reader.GetOutputPort()) v2.SetSurfaceConnection(betonasReader.GetOutputPort()) v2.CheckSurfaceOn () v2.InsideOutOff () v2.SetTolerance (1.0e-6) v2.Update() v2insideArray = v2.GetOutput().GetPointData().GetArray("SelectedPoints"); for x in range(v2insideArray.GetNumberOfTuples()): particleId1.append(v2insideArray.GetTuple1(x)) #particleId.append(v2insideArray.GetTuple1(x)) poly=vtk.vtkPolyData() points=vtk.vtkPoints() cells=vtk.vtkCellArray() particle_id=vtk.vtkDoubleArray() particle_id.SetName("ID") particle_id.SetNumberOfComponents(1) radius=vtk.vtkDoubleArray() radius.SetName("RADIUS") radius.SetNumberOfComponents(1) bonds=vtk.vtkIntArray() bonds.SetName("BONDS_ID") bonds.SetNumberOfComponents(1) data=reader.GetOutput() for x in range(data.GetNumberOfPoints()): #val=v1insideArray.GetTuple1(x) points.InsertNextPoint(data.GetPoint(x)) radius.InsertNextTuple1(data.GetPointData().GetArray("radius").GetTuple1(x)) val=0 if(particleId[x]==0 and particleId1[x]==0): val=0 if(particleId1[x]!=0): val=1 if(particleId[x]!=0): val=2 particle_id.InsertNextTuple1(val) for x in range(data.GetNumberOfCells()): cell=data.GetCell(x) cells.InsertNextCell(2); cells.InsertCellPoint(cell.GetPointId(0)); cells.InsertCellPoint(cell.GetPointId(1)); v1=particle_id.GetTuple1(cell.GetPointId(0)) v2=particle_id.GetTuple1(cell.GetPointId(1)) bonds.InsertNextTuple1(0) if(v1==0 and v2==0): bonds.SetTuple1(x,0) if((v1==1 and v2==0) or (v1==0 and v2==1)): bonds.SetTuple1(x,0) if((v1==0 and v2==2) or (v1==2 and v2==0)): bonds.SetTuple1(x,0) if(v1==1 and v2==1): bonds.SetTuple1(x,1) if(v1==2 and v2==2): bonds.SetTuple1(x,2) if((v1==1 and v2==2) or (v1==2 and v2==1)): bonds.SetTuple1(x,3) poly.SetPoints(points) poly.GetPointData().SetScalars(radius) poly.GetPointData().AddArray(particle_id) poly.GetCellData().SetScalars(bonds) poly.SetLines(cells) poly.GetPointData().SetActiveScalars("ID") th=vtk.vtkThreshold() th.SetInputData(poly) th.ThresholdByUpper (0.5) th.SetInputArrayToProcess(0,0,0,0,'ID') th.Update() writer=vtk.vtkXMLUnstructuredGridWriter() writer.SetFileName("final.vtu") writer.SetInputConnection(th.GetOutputPort()) writer.Write()