Beispiel #1
0
def opyfBuildLocatorandStuff2D(X):
    # Create points array which are positions to probe data with
    # FindClosestPoint(), We also create an array to hold the results of this
    # probe operation and
    # This array is the same array since we want to find the closest neighbor
    # The strategy will be to find the 2 closest point since one of them will be the same point
    # And we consider the second one, the farthest
    npPoints = X
    points = vtk.vtkPoints()
    points.SetDataTypeToDouble()
    probePoints = vtk.vtkPoints()
    probePoints.SetDataTypeToDouble()

    for [x, y] in npPoints:
        points.InsertNextPoint(x, y, 0.)
        probePoints.InsertNextPoint(x, y, 0.)

    polydata = vtk.vtkPolyData()
    polydata.SetPoints(points)
    points.ComputeBounds()

    staticLocator = vtk.vtkStaticPointLocator()
    staticLocator.SetDataSet(polydata)
    staticLocator.SetNumberOfPointsPerBucket(5)
    staticLocator.AutomaticOn()

    staticLocator.BuildLocator()

    return staticLocator, points, probePoints
Beispiel #2
0
 def get_data_vtk(self, points_interpol, interpolation_method="linear"):
     """
     Get interpolated data for points_interpol using vtks built-in interpolation methods
     """
     kernels = {
         "voronoi": vtk.vtkVoronoiKernel(),
         "gaussian": vtk.vtkGaussianKernel(),
         "shepard": vtk.vtkShepardKernel(),
         "linear": vtk.vtkLinearKernel()
     }
     pointnumpyarray = np.array(
         [points_interpol[pt] for pt in points_interpol])
     out_u_grid = vtk.vtkUnstructuredGrid()
     r = vtk.vtkPoints()
     r.SetData(numpy_to_vtk(pointnumpyarray))
     out_u_grid.SetPoints(r)
     locator = vtk.vtkStaticPointLocator()
     locator.SetDataSet(self.output)
     locator.BuildLocator()
     interpolator = vtk.vtkPointInterpolator()
     interpolator.SetInputData(out_u_grid)
     interpolator.SetSourceData(self.output)
     interpolator.SetKernel(kernels[interpolation_method])
     interpolator.SetLocator(locator)
     interpolator.Update()
     return interpolator.GetOutput().GetPointData()
Beispiel #3
0
def get_vtk_point_locator(centerline):
    """Wrapper for vtkStaticPointLocator.

    Args:
        centerline (vtkPolyData): Input vtkPolyData.

    Returns:
        locator (vtkStaticPointLocator): Point locator of the input surface.
    """
    locator = vtk.vtkStaticPointLocator()
    locator.SetDataSet(centerline)
    locator.BuildLocator()

    return locator
def showPointCloud(modelNodeID):

    model = slicer.mrmlScene.GetNodeByID(modelNodeID)
    polydata = model.GetPolyData()

    # Reuse the locator
    locator = vtk.vtkStaticPointLocator()
    locator.SetDataSet(polydata)
    locator.BuildLocator()

    # Remove isolated points
    removal = vtk.vtkRadiusOutlierRemoval()
    removal.SetInputData(polydata)
    removal.SetLocator(locator)
    removal.SetRadius(10)
    removal.SetNumberOfNeighbors(2)
    removal.GenerateOutliersOn()

    # Time execution
    timer = vtk.vtkTimerLog()
    timer.StartTimer()
    removal.Update()
    timer.StopTimer()
    time = timer.GetElapsedTime()
    print("Time to remove points: {0}".format(time))
    print("   Number removed: {0}".format(removal.GetNumberOfPointsRemoved()),
          " (out of: {}".format(polydata.GetNumberOfPoints()))

    # First output are the non-outliers
    remMapper = vtk.vtkPointGaussianMapper()
    remMapper.SetInputConnection(removal.GetOutputPort())
    remMapper.EmissiveOff()
    remMapper.SetScaleFactor(0.0)

    remActor = vtk.vtkActor()
    remActor.SetMapper(remMapper)

    lm = slicer.app.layoutManager()
    tdWidget = lm.threeDWidget(0)
    tdView = tdWidget.threeDView()
    rWin = tdView.renderWindow()
    rCollection = rWin.GetRenderers()
    renderer = rCollection.GetItemAsObject(0)

    # Add the actors to the renderer, set the background and size
    #
    renderer.AddActor(remActor)
def showPointCloud(modelNodeID):

    model = slicer.mrmlScene.GetNodeByID(modelNodeID)
    polydata = model.GetPolyData()

    # Reuse the locator
    locator = vtk.vtkStaticPointLocator()
    locator.SetDataSet(polydata)
    locator.BuildLocator()

    # Remove isolated points
    removal = vtk.vtkRadiusOutlierRemoval()
    removal.SetInputData(polydata)
    removal.SetLocator(locator)
    removal.SetRadius(10)
    removal.SetNumberOfNeighbors(2)
    removal.GenerateOutliersOn()

    # Time execution
    timer = vtk.vtkTimerLog()
    timer.StartTimer()
    removal.Update()
    timer.StopTimer()
    time = timer.GetElapsedTime()
    print("Time to remove points: {0}".format(time))
    print("   Number removed: {0}".format(removal.GetNumberOfPointsRemoved()),
          " (out of: {}".format(polydata.GetNumberOfPoints()))

    # First output are the non-outliers
    remMapper = vtk.vtkPointGaussianMapper()
    remMapper.SetInputConnection(removal.GetOutputPort())
    remMapper.EmissiveOff()
    remMapper.SetScaleFactor(0.0)

    remActor = vtk.vtkActor()
    remActor.SetMapper(remMapper)
    
    lm = slicer.app.layoutManager()
    tdWidget = lm.threeDWidget(0)
    tdView = tdWidget.threeDView()
    rWin = tdView.renderWindow()
    rCollection = rWin.GetRenderers()
    renderer = rCollection.GetItemAsObject(0)

    # Add the actors to the renderer, set the background and size
    #
    renderer.AddActor(remActor)
Beispiel #6
0
def findClosestPointsTwoLists(X_source, X_target):
    '''return the closest points indexes in X_source from the X_target points,
    indexes output has the same length than X_target'''

    listPoints = X_source
    points = vtk.vtkPoints()
    points.SetDataTypeToDouble()

    listProbePoints = X_target
    probePoints = vtk.vtkPoints()
    probePoints.SetDataTypeToDouble()

    for [x, y] in listPoints:
        points.InsertNextPoint(x, y, 0.)
    for [x, y] in listProbePoints:
        probePoints.InsertNextPoint(x, y, 0.)

    polydata = vtk.vtkPolyData()
    polydata.SetPoints(points)
    points.ComputeBounds()

    staticLocator = vtk.vtkStaticPointLocator()
    staticLocator.SetDataSet(polydata)
    staticLocator.SetNumberOfPointsPerBucket(5)
    staticLocator.AutomaticOn()

    staticLocator.BuildLocator()

    staticClosestN = vtk.vtkIdList()
    ind = np.zeros(len(X_target), dtype=np.int)
    D = np.zeros(len(X_target))
    math = vtk.vtkMath()
    x = [0, 0, 0]
    p = [0, 0, 0]
    staticClosestN = vtk.vtkIdList()
    for i in range(len(X_target)):
        staticLocator.FindClosestNPoints(1, probePoints.GetPoint(i),
                                         staticClosestN)
        ind[i] = staticClosestN.GetId(0)  # we then select the closest point
        points.GetPoint(ind[i], x)
        probePoints.GetPoint(i, p)
        D[i] = math.Distance2BetweenPoints(x, p)**0.5

    return ind, D
Beispiel #7
0
def opyfBuildLocatorandStuff3D(X):

    npPoints = X
    points = vtk.vtkPoints()
    points.SetDataTypeToDouble()
    probePoints = vtk.vtkPoints()
    probePoints.SetDataTypeToDouble()

    for [x, y, z] in npPoints:
        points.InsertNextPoint(x, y, z)
        probePoints.InsertNextPoint(x, y, z)

    polydata = vtk.vtkPolyData()
    polydata.SetPoints(points)
    points.ComputeBounds()

    staticLocator = vtk.vtkStaticPointLocator()
    staticLocator.SetDataSet(polydata)
    staticLocator.SetNumberOfPointsPerBucket(5)
    staticLocator.AutomaticOn()

    staticLocator.BuildLocator()

    return staticLocator, points, probePoints
locator.FindClosestNPoints(10, probePoints.GetPoint(0), closestN)

# Time the deletion of the locator. The incremental locator is quite slow due
# to fragmented memory.
timer.StartTimer()
del locator
timer.StopTimer()
time2 = timer.GetElapsedTime()
totalTime = time + opTime + time2
print("    Delete Point Locator: {0}".format(time2))
print("    Point Locator (Total): {0}".format(totalTime))
print("\n")

# StaticPointLocator
# Time the creation of static point locator
staticLocator = vtk.vtkStaticPointLocator()
staticLocator.SetDataSet(polydata)
staticLocator.SetNumberOfPointsPerBucket(5)
staticLocator.AutomaticOn()

staticTimer = vtk.vtkTimerLog()
staticTimer.StartTimer()
staticLocator.BuildLocator()
staticTimer.StopTimer()
StaticTime = staticTimer.GetElapsedTime()
print("Build Static Point Locator: {0}".format(StaticTime))

# Now probe the dataset with FindClosestPoint()
math.RandomSeed(314159)
staticTimer.StartTimer()
for i in range (0,numProbes):
output = pl3d.GetOutput().GetBlock(0)

# Create a probe volume
center = output.GetCenter()
bounds = output.GetBounds()
length = output.GetLength()

probe = vtk.vtkImageData()
probe.SetDimensions(res,res,res)
probe.SetOrigin(bounds[0],bounds[2],bounds[4])
probe.SetSpacing((bounds[1]-bounds[0])/(res-1),
                 (bounds[3]-bounds[2])/(res-1),
                 (bounds[5]-bounds[4])/(res-1))

# Reuse the locator
locator = vtk.vtkStaticPointLocator()
locator.SetDataSet(output)
locator.BuildLocator()

# Use a gaussian kernel------------------------------------------------
gaussianKernel = vtk.vtkGaussianKernel()
gaussianKernel.SetRadius(0.5)
gaussianKernel.SetSharpness(4)
print ("Radius: {0}".format(gaussianKernel.GetRadius()))

interpolator = vtk.vtkPointInterpolator()
interpolator.SetInputData(probe)
interpolator.SetSourceData(output)
interpolator.SetKernel(gaussianKernel)
interpolator.SetLocator(locator)
interpolator.SetNullPointsStrategyToClosestPoint()
Beispiel #10
0
def opyfFindBlobs3D(scalars,
                    th1,
                    th2=None,
                    R=1.,
                    minArea=None,
                    CenterType='barycenter'):
    if th2 is None:
        th2 = np.max(scalars)

    [h, w, p] = scalars.shape
    scalars = scalars.T.copy()
    scalars = scalars.ravel()
    #    (scalars>=th1)*(scalars<=th2)
    #    indth=np.where((scalars>=th1)*(scalars<=th2))
    # Points XYZ
    x, y, z = np.mgrid[0:h, 0:w, 0:p]
    pts = np.empty(z.shape + (3, ), dtype=float)
    pts[..., 0] = x
    pts[..., 1] = y
    pts[..., 2] = z
    pts = pts.transpose(2, 1, 0, 3).copy()
    pts.shape = pts.size / 3, 3

    # VTK
    points = vtk.vtkPoints()
    points.SetDataTypeToDouble()

    for [x, y, z] in pts:
        points.InsertNextPoint(x, y, z)

    Scalarsvtk = vtk.vtkFloatArray()

    for s in scalars:
        Scalarsvtk.InsertNextValue(s)
    Ids = vtk.vtkIdList()

    polydata = vtk.vtkPolyData()
    #    polydata=vtk.vtkUnstructuredGrid()
    polydata.SetPoints(points)
    polydata.GetPointData().SetScalars(Scalarsvtk)

    ThresholdIn = vtk.vtkThresholdPoints()
    ThresholdIn.SetInputData(polydata)
    # ThresholdIn.ThresholdByLower(230.)
    ThresholdIn.ThresholdBetween(th1, th2)

    ThresholdIn.Update()

    PointsThresh = ThresholdIn.GetOutput().GetPoints()

    staticLocator = vtk.vtkStaticPointLocator()
    staticLocator.SetDataSet(ThresholdIn.GetOutput())
    staticLocator.SetNumberOfPointsPerBucket(5)
    staticLocator.AutomaticOn()

    staticLocator.BuildLocator()

    S = ThresholdIn.GetOutput().GetPointData().GetArray(0)
    nppointsArr = vtk_to_numpy(S)

    idspointsThresh = np.arange(0, PointsThresh.GetNumberOfPoints())
    entitiy = 0
    i = idspointsThresh[0]
    idsStored = np.array([])
    ids1 = [0]

    C = 1
    blob3D = []
    indstore = 0

    while len(idspointsThresh) > 0:
        C = 1
        while C == 1:
            ids2 = []
            l = len(idsStored)
            for i in ids1:
                PointswhithinRadius = vtk.vtkIdList()
                staticLocator.FindPointsWithinRadius(R,
                                                     PointsThresh.GetPoint(i),
                                                     PointswhithinRadius)

                for j in range(PointswhithinRadius.GetNumberOfIds()):
                    tempid = PointswhithinRadius.GetId(j)
                    if len(np.where(idsStored == tempid)[0]) == 0:
                        idsStored = np.append(idsStored, np.int(tempid))
                        ids2.append(tempid)
                        indDel = np.where(idspointsThresh == tempid)
                        idspointsThresh = np.delete(idspointsThresh, indDel, 0)

            if len(idsStored) == l:
                C = 0
                blob3D.append(idsStored[indstore:].astype(int))
                indstore = len(idsStored)
                entitiy += 1
                if len(idspointsThresh) > 0:
                    ids1 = [idspointsThresh[0]]
            else:
                ids1 = ids2

    C = np.zeros((len(blob3D), 3))

    AreaBlob = []
    X = vtk_to_numpy(PointsThresh.GetData())
    blob3Dout = []
    for i in range(len(blob3D)):
        ind = blob3D[i]

        Xblob = X[ind]
        blob3Dout.append(Xblob)
        pxInts = nppointsArr[ind]
        if CenterType == 'barycenter':
            C[i, :] = np.sum(Xblob * np.array([pxInts, pxInts, pxInts]).T,
                             axis=0) / (np.sum(pxInts))
        elif CenterType == 'geometric':
            C[i, :] = np.sum(Xblob, axis=0) / (np.float(len(pxInts)))
        AreaBlob.append(len(Xblob))
    AreaBlob = np.array(AreaBlob)
    blob3Dout = np.array(blob3Dout)
    if minArea is not None:
        C = C[np.where(AreaBlob > minArea)]
        blob3Dout = blob3Dout[np.where(AreaBlob > minArea)]
        AreaBlob = AreaBlob[np.where(AreaBlob > minArea)]

    return blob3Dout, C, AreaBlob
Beispiel #11
0
# Create an initial set of points and associated dataset
rpts = vtk.vtkPointSource()
rpts.SetNumberOfPoints(numPts)
rpts.SetDistributionToUniform()
rpts.SetRadius(1)
rpts.Update()
polydata = rpts.GetOutput()

# Print initial statistics
print("Processing NumPts: {0}".format(numPts))

timer = vtk.vtkTimerLog()

# Create the locator.
sclean = vtk.vtkStaticPointLocator()
sclean.SetDataSet(polydata)

timer.StartTimer()
sclean.BuildLocator()
timer.StopTimer()
time = timer.GetElapsedTime()
print("Build Static Point Locator (threaded): {0}".format(time))
print("Number of Divisions: ", sclean.GetDivisions())

# Create a comparison point locator.
clean = vtk.vtkPointLocator()
clean.SetDataSet(polydata)

timer.StartTimer()
clean.BuildLocator()
Beispiel #12
0
def npInterpolateVTK3D(npPoints,
                       npValues,
                       npTargetPoints,
                       ParametreInterpolatorVTK=None):

    if ParametreInterpolatorVTK == None:
        ParametreInterpolatorVTK = {
            'kernel': 'Gaussian',
            'Radius': 10.,
            'Sharpness': 2.
        }
    print('[' + ParametreInterpolatorVTK['kernel'] +
          ' Interpolation - Radius =' +
          str(ParametreInterpolatorVTK['Radius']) + ' - Sharpness =' +
          str(ParametreInterpolatorVTK['Sharpness']) + '] processing... ')
    #
    # Set Source Points
    UnGrid = vtk.vtkUnstructuredGrid()
    vtkP = vtk.vtkPoints()
    for [x, y, z] in npPoints:
        vtkP.InsertNextPoint(x, y, z)

    UnGrid.SetPoints(vtkP)
    # Set source Point Values
    l, c = npValues.shape
    for i in range(0, c):
        vtkFA = vtk.vtkFloatArray()
        vtkFA.SetName('Values' + str(i))
        for v in npValues:
            vtkFA.InsertNextValue(v[i])
        UnGrid.GetPointData().AddArray(vtkFA)

# Set Target Points

    vtkTP = vtk.vtkPoints()
    for [x, y, z] in npTargetPoints:
        vtkTP.InsertNextPoint(x, y, z)

    vtkTargetPointsPolyData = vtk.vtkPolyData()
    vtkTargetPointsPolyData.SetPoints(vtkTP)

    if ParametreInterpolatorVTK['kernel'] == 'Gaussian':

        Kernel = vtk.vtkGaussianKernel()
        Kernel.SetSharpness(ParametreInterpolatorVTK['Sharpness'])
        Kernel.SetRadius(ParametreInterpolatorVTK['Radius'])

    if ParametreInterpolatorVTK['kernel'] == 'Voronoi':
        Kernel = vtk.vtkVoronoiKernel()

    if ParametreInterpolatorVTK['kernel'] == 'Shepard':
        Kernel = vtk.vtkShepardKernel()
        Kernel.SetRadius(ParametreInterpolatorVTK['Radius'])

# Build locator
    locator = vtk.vtkStaticPointLocator()
    locator.SetDataSet(UnGrid)
    locator.BuildLocator()
    # build interpolator
    interp = vtk.vtkPointInterpolator()
    interp.SetInputData(vtkTargetPointsPolyData)
    interp.SetSourceData(UnGrid)
    interp.SetKernel(Kernel)
    interp.SetLocator(locator)
    interp.GetLocator().SetNumberOfPointsPerBucket(5)
    interp.SetNullPointsStrategyToMaskPoints()

    interp.Update()

    outputInterp = interp.GetOutput()
    pointsArr = outputInterp.GetPoints().GetData()
    nppointsArr = vtk_to_numpy(pointsArr)
    pdata = outputInterp.GetPointData()

    # Convert volocities into Numpy Array

    npOutputValues = np.zeros((len(npTargetPoints), c))

    for i in range(0, c):
        vtkOutputValues = pdata.GetArray('Values' + str(i))
        npOutputValues[:, i] = vtk_to_numpy(vtkOutputValues)

    return npOutputValues
# serve as starting points that shoot rays towards the
# center of the fist sphere.
#
sphere = vtk.vtkSphereSource()
sphere.SetThetaResolution(2 * res)
sphere.SetPhiResolution(res)
sphere.Update()

mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(sphere.GetOutputPort())

actor = vtk.vtkActor()
actor.SetMapper(mapper)

# Now the locator
loc = vtk.vtkStaticPointLocator()
loc.SetDataSet(sphere.GetOutput())
loc.SetNumberOfPointsPerBucket(5)
loc.BuildLocator()

locPD = vtk.vtkPolyData()
loc.GenerateRepresentation(4, locPD)
locMapper = vtk.vtkPolyDataMapper()
locMapper.SetInputData(locPD)
locActor = vtk.vtkActor()
locActor.SetMapper(locMapper)
locActor.GetProperty().SetRepresentationToWireframe()

# Now the outer sphere
sphere2 = vtk.vtkSphereSource()
sphere2.SetThetaResolution(res)
Beispiel #14
0
    def interpolate_data(self, points, disp, stretch=None, shear=None, on_deformed=True, kernel_radius=3.0,
                         kernel_sharpness=1.0, remove_null=True, return_deformed=True):

        """
        Interpolate data on the mesh. This can be used for comparing experimental and simulation data together.
        on_deform selects whether to interpolate the data on the original or on the deformed configuration
        """

        if stretch is None:
            stretch = np.array([])

        if shear is None:
            shear = np.array([])

        # We need nPts*3 data for vtk
        if points.shape[1] == 2:
            points_ = np.zeros([points.shape[0], 3])

        points_[:,0:2] = points

        # Deform data if needed
        if on_deformed:
            points_[:,0:2] = points + disp

        # Generate vtk points structure with all data
        vtkpoints = vtk.vtkPoints()
        vtkpoints.SetData(numpy_support.numpy_to_vtk(points_))

        vtkdisp = vtk.vtkDoubleArray()
        vtkdisp.SetName("disp")
        vtkdisp.SetNumberOfComponents(disp.shape[1])
        vtkdisp.SetNumberOfTuples(disp.shape[0])
        vtkdisp.SetVoidArray(disp.flatten(), disp.size, 1)

        vtkstretch = vtk.vtkDoubleArray()
        vtkstretch.SetName("stretch")
        vtkstretch.SetNumberOfComponents(1)
        vtkstretch.SetNumberOfTuples(stretch.size)
        vtkstretch.SetVoidArray(stretch, stretch.size, 1)

        shear = shear.reshape([-1, 4])
        vtkshear = vtk.vtkDoubleArray()
        vtkshear.SetName("shear")
        vtkshear.SetNumberOfComponents(shear.shape[1])
        vtkshear.SetNumberOfTuples(shear.shape[0])
        vtkshear.SetVoidArray(shear, shear.size, 1)

        vtkpointset = vtk.vtkPolyData()
        vtkpointset.SetPoints(vtkpoints)
        vtkpointset.GetPointData().AddArray(vtkdisp)
        vtkpointset.GetPointData().AddArray(vtkstretch)
        vtkpointset.GetPointData().AddArray(vtkshear)

        # Build the locator for the interpolation
        locator = vtk.vtkStaticPointLocator()
        locator.SetDataSet(vtkpointset)
        locator.BuildLocator()

        # Build the Gaussian kernel
        kernel = vtk.vtkGaussianKernel()
        kernel.SetKernelFootprint(0)
        kernel.SetRadius(kernel_radius)
        kernel.SetSharpness(kernel_sharpness)

        # If the interpolation is performed on the deformed configuration, warp the data
        if on_deformed:
            disp_ = np.zeros(self.x_nodes.shape)
            disp_[:,0:2] = self.disp

            warpData = vtk.vtkDoubleArray()
            warpData.SetName("warp")
            warpData.SetNumberOfComponents(3)
            warpData.SetNumberOfTuples(self.x_nodes.shape[0])
            warpData.SetVoidArray(disp_, self.x_nodes.shape[0], 1)

            self.vtkmesh.GetPointData().AddArray(warpData)
            self.vtkmesh.GetPointData().SetActiveVectors(warpData.GetName())

            warpVector = vtk.vtkWarpVector()
            warpVector.SetInputData(self.vtkmesh)
            warpVector.Update()

            self.vtkmesh = warpVector.GetOutput()

        coarseInterpolator = vtk.vtkPointInterpolator()
        coarseInterpolator.SetSourceData(vtkpointset)
        coarseInterpolator.SetInputData(self.vtkmesh)
        coarseInterpolator.SetKernel(kernel)
        coarseInterpolator.SetLocator(locator)
        coarseInterpolator.PassPointArraysOff()
        coarseInterpolator.SetNullPointsStrategyToMaskPoints() # Get points with an invalid interpolation
        coarseInterpolator.Update()

        vtkmesh = coarseInterpolator.GetOutput()

        if return_deformed:
            self.x_nodes[:,0:2] += self.disp

        self.disp = numpy_support.vtk_to_numpy(vtkmesh.GetPointData().GetArray("disp"))
        self.stretch = numpy_support.vtk_to_numpy(vtkmesh.GetPointData().GetArray("stretch"))
        self.shear = numpy_support.vtk_to_numpy(vtkmesh.GetPointData().GetArray("shear"))

        if remove_null:
            not_null = (numpy_support.vtk_to_numpy(vtkmesh.GetPointData().GetArray(
                coarseInterpolator.GetValidPointsMaskArrayName()))).astype(bool)

            idlist_old = np.arange(self.x_nodes.shape[0])[not_null]

            self.x_nodes = self.x_nodes[not_null]
            self.disp = self.disp[not_null]
            self.stretch = self.stretch[not_null]
            self.shear = self.shear[not_null]

            idlist_new = np.arange(self.x_nodes.shape[0])

            c1 = np.in1d(self.connec[:, 0], idlist_old)
            c2 = np.in1d(self.connec[:, 1], idlist_old)
            c3 = np.in1d(self.connec[:, 2], idlist_old)
            self.connec = self.connec[np.logical_and(np.logical_and(c1,c2),c3)]

            for i in idlist_new:
                self.connec[self.connec == idlist_old[i]] = i

            points = vtk.vtkPoints()
            points.SetData(numpy_support.numpy_to_vtk(self.x_nodes))
            vtkmesh.SetPoints(points)

            cells = vtk.vtkCellArray()
            cells.SetCells(self.connec.shape[0], numpy_support.numpy_to_vtkIdTypeArray(self.connec))
            vtkmesh.SetPolys(cells)

        self.shear = self.shear.reshape([-1, 2, 2])