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
Beispiel #2
0
    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
Beispiel #3
0
 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
Beispiel #5
0
    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
Beispiel #8
0
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()
Beispiel #9
0
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()
Beispiel #10
0
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
Beispiel #11
0
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
Beispiel #12
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)
Beispiel #13
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)
Beispiel #14
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
Beispiel #15
0
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)
Beispiel #16
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
Beispiel #17
0
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)
Beispiel #18
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)
Beispiel #19
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)
Beispiel #21
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
Beispiel #22
0
    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]
Beispiel #23
0
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')
Beispiel #24
0
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()
Beispiel #26
0
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
Beispiel #27
0
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
Beispiel #29
0
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])

Beispiel #31
0
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()
Beispiel #32
0
    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)
Beispiel #33
0
    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
Beispiel #36
0
    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()
Beispiel #37
0
    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()
Beispiel #38
0
    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
Beispiel #39
0
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()