def RequestData(self, request, inInfo, outInfo): info = inInfo[0].GetInformationObject(0) inp = dsa.WrapDataObject(vtk.vtkDataSet.GetData(info)) if self.Cache is not None: self.DoParticle(self.Cache, inp) # print('data request') else: # First time step. Initialize. # This is where we will store the coordinates of all points # at all times self.OutputPoints = np.zeros( (len(self.TimeValues) * self.NumPts, 3)) # First time step uses the seed locations as the particle points pts = vtk.vtkPoints() pts.DeepCopy(self.Source.GetOutput().GetPoints()) self.Points = dsa.vtkDataArrayToVTKArray(pts.GetData()) self.OutputPoints[0:self.NumPts, :] = self.Points # This will be a point array showing the time value of each # output point. This is necessary to differentiate output # points since we store all timesteps in the output. self.TimeValuesArray = np.empty(len(self.TimeValues) * self.NumPts) self.TimeValuesArray[0:self.NumPts] = self.TimeValues[0] if self.UpdateTimeIndex < len(self.TimeValues) - 1: # If we are not done, ask the pipeline to re-execute us. self.UpdateTimeIndex += 1 request.Set( vtk.vtkStreamingDemandDrivenPipeline.CONTINUE_EXECUTING(), 1) c = inp.NewInstance() c.ShallowCopy(inp.VTKObject) c = dsa.WrapDataObject(c) self.Cache = c else: # Stop execution request.Remove( vtk.vtkStreamingDemandDrivenPipeline.CONTINUE_EXECUTING()) # Reset for next potential execution. self.UpdateTimeIndex = 0 # Create output outputPts = dsa.numpyTovtkDataArray(self.OutputPoints) pts = vtk.vtkPoints() pts.SetData(outputPts) output = dsa.WrapDataObject( vtk.vtkUnstructuredGrid.GetData(outInfo)) output.SetPoints(pts) tvs = dsa.numpyTovtkDataArray(self.TimeValuesArray) tvs.SetName("Time Values") output.GetPointData().SetScalars(tvs) # Clean up self.Cache = None self.OutputPoints = None self.Points = None return 1
def RequestData(self, request, inInfo, outInfo): output = dsa.WrapDataObject(vtk.vtkRectilinearGrid.GetData(outInfo)) info = outInfo.GetInformationObject(0) exts = info.Get(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_EXTENT()) whole = info.Get(vtk.vtkStreamingDemandDrivenPipeline.WHOLE_EXTENT()) # Dimensions for each processor nx = exts[1] - exts[0] + 1 ny = exts[3] - exts[2] + 1 nz = exts[5] - exts[4] + 1 # Read Data file f = Dataset(self.__DFileName, 'r') data = np.zeros([nz, ny, nx, self.nvar]) for i, field in enumerate(self._fields): data[:, :, :, i] = f.variables[field][exts[4]:exts[5] + 1, exts[2]:exts[3] + 1, exts[0]:exts[1] + 1] f.close() del f # Read Grid file f = Dataset(self.__GFileName, 'r') x = f.variables[self._grid_var_names[0]][exts[0]:exts[1] + 1] y = f.variables[self._grid_var_names[1]][exts[2]:exts[3] + 1] z = f.variables[self._grid_var_names[2]][exts[4]:exts[5] + 1] f.close() del f # output.SetDimensions([self.nx,self.ny,self.nz]) output.SetExtent(exts) output.SetXCoordinates(dsa.numpyTovtkDataArray(x, "X")) output.SetYCoordinates(dsa.numpyTovtkDataArray(y, "Y")) output.SetZCoordinates(dsa.numpyTovtkDataArray(z, "Z")) for i, field in enumerate(self._fields): output.PointData.append(data[:, :, :, i].ravel(), field) if self._grids: Z, Y, X = np.meshgrid(z, y, x, indexing='ij') if 'x' in self._grids: output.PointData.append(X.ravel(), 'x') del X if 'y' in self._grids: output.PointData.append(Y.ravel(), 'y') del Y if 'z' in self._grids: output.PointData.append(Z.ravel(), 'z') del Z output.PointData.SetActiveScalars(self._fields[0]) del data, x, y, z return 1
def Execute(self): polyData = vtk.vtkPolyData() wpPolyData = dsa.WrapDataObject(polyData) points = self.ArrayDict['Points'] vtkPoints = dsa.numpyTovtkDataArray(points, 'Points') wpPolyData.Points = vtkPoints self.PrintLog('converting point data') for pointDataKey in self.ArrayDict['PointData'].keys(): pointDataItem = self.ArrayDict['PointData'][pointDataKey] wpPolyData.PointData.append(pointDataItem, name=pointDataKey) self.PrintLog('converting cell data') for cellKey in self.ArrayDict['CellData'].keys(): if cellKey == 'CellPointIds': cellDataArray = vtk.vtkCellArray() for cellId in self.ArrayDict['CellData']['CellPointIds']: numberOfCellPoints = cellId.size cellDataArray.InsertNextCell(numberOfCellPoints) for cellPoint in cellId: cellDataArray.InsertCellPoint(cellPoint) wpPolyData.VTKObject.SetLines(cellDataArray) else: cellDataItem = self.ArrayDict['CellData'][cellKey] wpPolyData.CellData.append(cellDataItem, name=cellKey) self.Centerlines = wpPolyData.VTKObject
def RequestData(self, request, inInfo, outInfo): info = outInfo.GetInformationObject(0) # The time step requested t = info.Get(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_TIME_STEP()) timeStep = self.__TimeSteps[1] - self.__TimeSteps[0] t_index = (np.round(t / timeStep).astype(int) + self.__TimeOffset) % (len(self.__TimeSteps)-1) print(f"UPDATE_TIME_STEP: {t} / index {t_index}") data = self.create_bin_sphere(self.__Size, self.__Center, self.__Radius) output = vtk.vtkImageData.GetData(outInfo) output.SetDimensions(data.shape) output.SetSpacing(self.__Vox) # Make a VTK array from the numpy array (using pointers) scalarsSphere = dsa.numpyTovtkDataArray(data.ravel(order='F')) scalarsSphere.SetName("scalars_sphere") output.GetPointData().SetScalars(scalarsSphere) """ a = np.zeros((3, self.__Size[0], self.__Size[1], self.__Size[2]), order='F') a[0,:] = self.__ArrayVelocity[:,:,:,0,t_index] a[1,:] = self.__ArrayVelocity[:,:,:,1,t_index] a[2,:] = self.__ArrayVelocity[:,:,:,2,t_index] # Make a VTK array from the numpy array (using pointers) v = dsa.numpyTovtkDataArray(a.ravel(order='A').reshape( self.__Size[0] * self.__Size[1] * self.__Size[2], 3)) v.SetName("vectors") output.GetPointData().SetVectors(v) """ return 1
def Execute(self): self.PrintLog('Converting Numpy Array to vtkImageData') self.Image = vtk.vtkImageData() self.Image.SetDimensions(self.ArrayDict['Dimensions']) self.Image.SetOrigin(self.ArrayDict['Origin']) self.Image.SetSpacing(self.ArrayDict['Spacing']) self.Image.SetExtent((0, self.ArrayDict['Dimensions'][0] - 1, 0, self.ArrayDict['Dimensions'][1] - 1, 0, self.ArrayDict['Dimensions'][2] - 1,)) self.PrintLog('converting point data') for pointKey in self.ArrayDict['PointData'].keys(): if np.issubdtype(self.ArrayDict['PointData'][pointKey].dtype, np.floating): pointDataArrayType = vtk.VTK_FLOAT else: for checkDt in [int, np.uint8, np.uint16, np.uint32, np.uint64]: if np.issubdtype(self.ArrayDict['PointData'][pointKey].dtype, checkDt): pointDataArrayType = vtk.VTK_INT break else: continue flatArray = self.ArrayDict['PointData'][pointKey].ravel(order='F') pointDataArray = dsa.numpyTovtkDataArray(flatArray, name=pointKey, array_type=pointDataArrayType) self.Image.GetPointData().SetActiveScalars(pointKey) self.Image.GetPointData().SetScalars(pointDataArray)
def Execute(self): polyData = vtk.vtkPolyData() wpPolyData = dsa.WrapDataObject(polyData) points = self.ArrayDict['Points'] vtkPoints = dsa.numpyTovtkDataArray(points, 'Points') wpPolyData.Points = vtkPoints self.PrintLog('converting point data') for pointDataKey in self.ArrayDict['PointData'].keys(): pointDataItem = self.ArrayDict['PointData'][pointDataKey] wpPolyData.PointData.append(pointDataItem, name=pointDataKey) self.PrintLog('converting cell data') for cellKey in self.ArrayDict['CellData'].keys(): if cellKey == 'CellPointIds': cellDataArray = vtk.vtkCellArray() for cellId in self.ArrayDict['CellData']['CellPointIds']: numberOfCellPoints = cellId.size cellDataArray.InsertNextCell(numberOfCellPoints) for cellPoint in cellId: cellDataArray.InsertCellPoint(cellPoint) wpPolyData.VTKObject.SetLines(cellDataArray) else: cellDataItem = self.ArrayDict['CellData'][cellKey] wpPolyData.CellData.append(cellDataItem, name=cellKey) self.Centerlines = wpPolyData.VTKObject
def RequestData(self, request, inInfo, outInfo): logging.info('') start = timer() # input polydata # have to make a copy otherwise polys will not show up in the render # even though GetNumberOfCells() says they should be there tmp = vtk.vtkPolyData.GetData(inInfo[0]) inp = vtk.vtkPolyData() inp.ShallowCopy(tmp) # change color of all cells if self._color: ncells = inp.GetNumberOfCells() c = self._colorcycle.next() vtkarray = dsa.numpyTovtkDataArray(np.tile(c, (ncells, 1))) inp.GetCellData().SetScalars(vtkarray) # add to world mesh self._worldmesh.AddInputData(inp) self._worldmesh.Update() logging.info('Number of cells: in = {} total = {}'.format( inp.GetNumberOfCells(), self._worldmesh.GetOutput().GetNumberOfCells())) # output world mesh out = vtk.vtkPolyData.GetData(outInfo) out.ShallowCopy(self._worldmesh.GetOutput()) end = timer() logging.info('Execution time {:.4f} seconds'.format(end - start)) return 1
def RequestData(self, request, inInfo, outInfo): output = dsa.WrapDataObject(vtk.vtkRectilinearGrid.GetData(outInfo)) info = outInfo.GetInformationObject(0) exts = info.Get(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_EXTENT()) dims = [exts[1]-exts[0]+1, exts[3]-exts[2]+1, exts[5]-exts[4]+1] output.SetExtent(exts) xaxis = np.linspace(0., 1., dims[0]) yaxis = np.linspace(0., 1., dims[1]) zaxis = np.linspace(0., 1., dims[2]) xaxis = xaxis**2 yaxis = np.sqrt(yaxis) zaxis = zaxis*np.sqrt(zaxis) output.SetXCoordinates(dsa.numpyTovtkDataArray( xaxis , "X")) output.SetYCoordinates(dsa.numpyTovtkDataArray( yaxis , "Y")) output.SetZCoordinates(dsa.numpyTovtkDataArray( zaxis , "Z")) return 1
def RequestData(self, request, inInfo, outInfo): output = dsa.WrapDataObject(vtk.vtkRectilinearGrid.GetData(outInfo)) info = outInfo.GetInformationObject(0) exts = info.Get(vtk.vtkStreamingDemandDrivenPipeline.WHOLE_EXTENT()) dims = [exts[1]-exts[0]+1, exts[3]-exts[2]+1, exts[5]-exts[4]+1] output.SetExtent(exts) xaxis = np.linspace(0., 1., dims[0]) yaxis = np.linspace(0., 1., dims[1]) zaxis = np.linspace(0., 1., dims[2]) xaxis = xaxis**2 yaxis = np.sqrt(yaxis) zaxis = zaxis*np.sqrt(zaxis) output.SetXCoordinates(dsa.numpyTovtkDataArray( xaxis , "X")) output.SetYCoordinates(dsa.numpyTovtkDataArray( yaxis , "Y")) output.SetZCoordinates(dsa.numpyTovtkDataArray( zaxis , "Z")) return 1
def RequestData(self, request, inInfo, outInfo): logging.info('') start = timer() # input polydata # have to make a copy otherwise polys will not show up in the render # even though GetNumberOfCells() says they should be there tmp = vtk.vtkPolyData.GetData(inInfo[0]) inp = vtk.vtkPolyData() inp.ShallowCopy(tmp) # change color of all cells if self._color: ncells = inp.GetNumberOfCells() c = self._colorcycle.next() vtkarray = dsa.numpyTovtkDataArray(np.tile(c, (ncells, 1))) inp.GetCellData().SetScalars(vtkarray) # add to world mesh self._worldmesh.AddInputData(inp) self._worldmesh.Update() logging.info('Number of cells: in = {} total = {}' .format(inp.GetNumberOfCells(), self._worldmesh.GetOutput().GetNumberOfCells())) # output world mesh out = vtk.vtkPolyData.GetData(outInfo) out.ShallowCopy(self._worldmesh.GetOutput()) end = timer() logging.info('Execution time {:.4f} seconds'.format(end - start)) return 1
def unwrap_vtk_array(a, array_type=None): if is_numpy_string(a.dtype) or is_vtk_string(array_type): return _numpy_to_string(a, array_type=array_type) if any([np.issubdtype(a.dtype, d) for d in [np.integer, np.floating]]): return dsa.numpyTovtkDataArray(a, array_type=array_type) if np.issubdtype(a.dtype, np.object_): return _numpy_to_variant(a) raise ValueError('Unsupported array type: {0}'.format(type(a)))
def numpy2PolyData(data): vtkArr = dsa.numpyTovtkDataArray(data) pts = v.vtkPoints() pts.SetData(vtkArr) pd = v.vtkPolyData() pd.SetPoints(pts) vgf = v.vtkVertexGlyphFilter() vgf.SetInputData(pd) vgf.Update() return vgf.GetOutput()
def writeToVTK(x, fileName): """ Write flattened vector to VTK file. """ X = x.reshape((-1, 3)) pos = X[:72, :] posArr = dsa.numpyTovtkDataArray(pos, name='Points') rot = X[72:, :] ori = np.zeros_like(rot) get_orientations(rot, ori) normals = dsa.numpyTovtkDataArray(ori, name='PointNormals') pts = v.vtkPoints() pts.SetData(posArr) pd = v.vtkPolyData() pd.SetPoints(pts) pd.GetPointData().SetNormals(normals) polyData = dsa.WrapDataObject(pd) polyData.SetPolys(triangulate(polyData)) w = v.vtkPolyDataWriter() w.SetFileName(fileName) w.SetInputData(pd) w.Write()
def ProbeVelocity(self, data): # Update the particle locations we sample at pts = dsa.numpyTovtkDataArray(self.Points) self.ProbePoints.GetPoints().SetData(pts) self.Probe.SetSourceData(data) # Sample self.Probe.Update() p = dsa.WrapDataObject(self.Probe.GetOutput()) # All we care about is the vector values/ return p.PointData['vectors']
def stuff_vtu(self, outpt): outpt.SetPoints(dsa.VTKArray(np.array(self.points).astype('f4'))) outpt.PointData.append(dsa.VTKArray(np.array(self.V).astype('f4')), 'V') outpt.PointData.append(dsa.VTKArray(np.array(self.PV).astype('f4')), 'PV') outpt.PointData.append(dsa.VTKArray(np.array(self.I).astype('f4')), 'I') ct = dsa.numpyTovtkDataArray(np.array([vtk.VTK_VERTEX]*outpt.GetNumberOfPoints()).astype('u1')) co = dsa.numpy_support.numpy_to_vtkIdTypeArray(np.array(range(0, 2*outpt.GetNumberOfPoints(), 2))) ca = vtk.vtkCellArray() for i in range(outpt.GetNumberOfPoints()): ca.InsertNextCell(1, [i]) outpt.VTKObject.SetCells(ct, co, ca) for v in self.vars: outpt.PointData.append(dsa.VTKArray(np.array(v[2]).astype('f4')), v[0])
def SampleTetrahedra(vtu, pdf, n): points = np.ascontiguousarray(vtu.Points).astype('f4') pdf = np.ascontiguousarray(vtu.CellData[pdf]).astype('f4') tets = np.ascontiguousarray(vtu.Cells).astype('i4') ccode.SampleTetrahedra(n, vtu.GetNumberOfPoints(), vtu.GetNumberOfCells(), points, pdf, tets) n = ccode.GetNumberOfSamples() s = np.ctypeslib.as_array(C.cast(ccode.GetSamples(), C.POINTER(C.c_float)),shape=(n, 3)) samples = dsa.WrapDataObject(vtk.vtkUnstructuredGrid()) co = dsa.numpy_support.numpy_to_vtkIdTypeArray(np.arange(n).astype('i8')*2) ca = vtk.vtkCellArray() ca.SetCells(n, dsa.numpy_support.numpy_to_vtkIdTypeArray(np.column_stack(([1]*n, range(n))).reshape((2*n,)))) ct = dsa.numpyTovtkDataArray(np.array([vtk.VTK_VERTEX]*n).astype('u1')) samples.VTKObject.SetCells(ct, co, ca) samples.Points = dsa.numpy_support.numpy_to_vtk(s) return samples
def t_coords(self, t_coords: np.ndarray): """Set the active texture coordinates using an np.ndarray.""" if not isinstance(t_coords, np.ndarray): raise TypeError('Texture coordinates must be a numpy array') if t_coords.ndim != 2: raise ValueError('Texture coordinates must be a 2-dimensional array') valid_length = self.valid_array_len if t_coords.shape[0] != valid_length: raise ValueError(f'Number of texture coordinates ({t_coords.shape[0]}) must match number of points ({valid_length})') if t_coords.shape[1] != 2: raise ValueError('Texture coordinates must only have 2 components,' f' not ({t_coords.shape[1]})') vtkarr = numpyTovtkDataArray(t_coords, name='Texture Coordinates') self.SetTCoords(vtkarr) self.Modified()
def SampleVTI(vti, pdf, n): e = vti.VTKObject.GetExtent() o = vti.VTKObject.GetOrigin() s = vti.VTKObject.GetSpacing() dimensions = np.array([(e[2*i+1] - e[2*i])+1 for i in range(3)]).astype('i4') origin = np.array([o[i] - e[2*i]*s[i] for i in range(3)]).astype('f4') spacing = np.array(s).astype('f4') pdf = np.ascontiguousarray(vti.PointData[pdf]).astype('f4') ccode.SampleVTI(n, dimensions, origin, spacing, pdf); n = ccode.GetNumberOfSamples() s = np.ctypeslib.as_array(C.cast(ccode.GetSamples(), C.POINTER(C.c_float)),shape=(n, 3)) samples = dsa.WrapDataObject(vtk.vtkUnstructuredGrid()) co = dsa.numpy_support.numpy_to_vtkIdTypeArray(np.arange(n).astype('i8')*2) ca = vtk.vtkCellArray() ca.SetCells(n, dsa.numpy_support.numpy_to_vtkIdTypeArray(np.column_stack(([1]*n, range(n))).reshape((2*n,)).astype('i8'))) ct = dsa.numpyTovtkDataArray(np.array([vtk.VTK_VERTEX]*n).astype('u1')) samples.VTKObject.SetCells(ct, co, ca) samples.Points = dsa.numpy_support.numpy_to_vtk(s) return samples
def triangulate(pd): """ Generates a triangle mesh for a spherical point cloud. It is assumed that 'pd' is an object of dsa.PolyData type. """ # Project on a sphere sphereXyz = alg.norm(pd.Points) * np.linalg.norm(pd.Points, axis=1).mean() sphereXyz = np.around(sphereXyz, decimals=2) sphereArr = dsa.numpyTovtkDataArray(sphereXyz, name='SpherePts') pts = v.vtkPoints() pts.SetData(sphereArr) sphere = v.vtkPolyData() sphere.SetPoints(pts) # Store the original point ids idf = v.vtkIdFilter() idf.SetIdsArrayName('PointIds') idf.PointIdsOn() idf.SetInputData(sphere) # Delaunay3D to make a convex hull d3d = v.vtkDelaunay3D() d3d.SetInputConnection(idf.GetOutputPort()) # Extract the surface surf = v.vtkDataSetSurfaceFilter() surf.SetInputConnection(d3d.GetOutputPort()) surf.Update() # Now make a new cell array mapping to the old ids polyCells = v.vtkCellArray() sphereCells = surf.GetOutput().GetPolys() sphereCells.InitTraversal() origIds = surf.GetOutput().GetPointData().GetArray('PointIds') ptIds = v.vtkIdList() while (sphereCells.GetNextCell(ptIds)): polyCells.InsertNextCell(3) polyCells.InsertCellPoint(int(origIds.GetTuple1(ptIds.GetId(0)))) polyCells.InsertCellPoint(int(origIds.GetTuple1(ptIds.GetId(1)))) polyCells.InsertCellPoint(int(origIds.GetTuple1(ptIds.GetId(2)))) return polyCells
def RequestData(self, request, inInfo, outInfo): output = dsa.WrapDataObject(vtk.vtkStructuredGrid.GetData(outInfo)) info = outInfo.GetInformationObject(0) exts = info.Get(vtk.vtkStreamingDemandDrivenPipeline.WHOLE_EXTENT()) dims = [exts[1]-exts[0]+1, exts[3]-exts[2]+1, exts[5]-exts[4]+1] output.SetExtent(exts) Raxis = np.linspace(1., 2., dims[0]) Thetaaxis = np.linspace(0.,np.pi*0.5, dims[1]) xc, yc = np.meshgrid(Raxis, Thetaaxis, indexing="xy") X = xc * np.cos(yc) Y = xc * np.sin(yc) print X.size, X.shape Z=np.zeros(X.size).reshape(X.shape) coordinates = algs.make_vector(X.ravel(),Y.ravel(),Z.ravel()) pts = vtk.vtkPoints() pts.SetData(dsa.numpyTovtkDataArray(coordinates , "Points")) output.SetPoints(pts) output.PointData.append(xc.ravel(), "radius") output.PointData.append(yc.ravel(), "angle") return 1
def RequestData(self, request, inInfo, outInfo): info = outInfo.GetInformationObject(0) # We produce only the extent that we are asked (UPDATE_EXTENT) ue = info.Get(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_EXTENT()) ue = np.array(ue) output = vtk.vtkImageData.GetData(outInfo) # Parameters of the grid to produce dims = ue[1::2] - ue[0::2] + 1 origin = 0 spacing = 0.1 # The time step requested t = info.Get(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_TIME_STEP()) # The velocity vs y y = origin + spacing * np.arange(ue[2], ue[3] + 1) u = np.exp(-y / np.sqrt(2)) * np.sin(t - y / np.sqrt(2)) # Set the velocity for all points of the grid which # has of dimensions 3, dims[0], dims[1]. The first number # is because of 3 components in the vector. Note the # memory layout VTK uses is a bit unusual. It's Fortran # ordered but the velocity component increases fastest. a = np.zeros((3, dims[0], dims[1]), order='F') a[0, :] = u output.SetExtent(*ue) output.SetSpacing(0.5, 0.1, 0.1) # Make a VTK array from the numpy array (using pointers) v = dsa.numpyTovtkDataArray( a.ravel(order='A').reshape(dims[0] * dims[1], 3)) v.SetName("vectors") output.GetPointData().SetVectors(v) return 1
def RequestData(self, request, inInfo, outInfo): output = dsa.WrapDataObject(vtk.vtkMultiBlockDataSet.GetData(outInfo)) for i in range(self.__NumberOfBlocks): block = vtk.vtkImageData() imin = 0 imax = self.__CompositeBlockDims[0] - 1 jmin = (i % 2) * (self.__CompositeBlockDims[1] // 2) jmax = ((i % 2) + 1) * (self.__CompositeBlockDims[1] // 2) kmin = (i // 2) * (self.__CompositeBlockDims[2] // 2) kmax = ((i // 2) + 1) * (self.__CompositeBlockDims[2] // 2) print("block extents ", i, " = ", imin, imax, jmin, jmax, kmin, kmax) block.SetExtent(imin, imax, jmin, jmax, kmin, kmax) nbOfCells = (imax - imin) * (jmax - jmin) * (kmax - kmin) # the value of 'i' will be the block color blockcolor = np.ones(nbOfCells).astype('ushort') * i vtkBlockColors = dsa.numpyTovtkDataArray(blockcolor) vtkBlockColors.SetName("vtkCompositeIndex") block.GetCellData().SetScalars(vtkBlockColors) block.SetOrigin(0, (i % 2) - 1.0 * (i % 2), 0) block.SetSpacing(1, 1, 1) output.SetBlock(i, block) return 1
def RequestData(self, request, inInfo, outInfo): logging.info('{}'.format(self._name)) start = timer() # get the depth values vfa = vtk.vtkFloatArray() ib = self._imageBounds self._renWin.GetZbufferData(ib[0], ib[1], ib[2], ib[3], vfa) # add noise if self._noise is not 0.0: nvfa = numpy_support.vtk_to_numpy(vfa) nvfa += self._noise * nvfa * np.random.normal(0.0, 1.0, nvfa.shape) vfa = dsa.numpyTovtkDataArray(nvfa) # pack the depth values into the output vtkImageData info = outInfo.GetInformationObject(0) ue = info.Get(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_EXTENT()) out = vtk.vtkImageData.GetData(outInfo) out.GetPointData().SetScalars(vfa) out.SetExtent(ue) # append meta data to the vtkImageData containing intrinsic parameters out.sizex = self._renWin.GetSize()[0] out.sizey = self._renWin.GetSize()[1] out.viewport = self._ren.GetViewport() vtktmat = self._ren.GetActiveCamera().GetCompositeProjectionTransformMatrix( self._ren.GetTiledAspectRatio(), 0.0, 1.0) vtktmat.Invert() out.tmat = self._vtkmatrix_to_numpy(vtktmat) end = timer() logging.info('Execution time {:.4f} seconds'.format(end - start)) return 1
def RequestData(self, request, inInfo, outInfo): logging.info('{}'.format(self._name)) start = timer() # get the depth values vfa = vtk.vtkFloatArray() ib = self._imageBounds self._renWin.GetZbufferData(ib[0], ib[1], ib[2], ib[3], vfa) # add noise if self._noise is not 0.0: nvfa = numpy_support.vtk_to_numpy(vfa) nvfa += self._noise * np.random.normal(0.0, 1.0, nvfa.shape) vfa = dsa.numpyTovtkDataArray(nvfa) # pack the depth values into the output vtkImageData info = outInfo.GetInformationObject(0) ue = info.Get(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_EXTENT()) out = vtk.vtkImageData.GetData(outInfo) out.GetPointData().SetScalars(vfa) out.SetExtent(ue) # append meta data to the vtkImageData containing intrinsic parameters out.sizex = self._renWin.GetSize()[0] out.sizey = self._renWin.GetSize()[1] out.viewport = self._ren.GetViewport() vtktmat = self._ren.GetActiveCamera( ).GetCompositeProjectionTransformMatrix( self._ren.GetTiledAspectRatio(), 0.0, 1.0) vtktmat.Invert() out.tmat = self._vtkmatrix_to_numpy(vtktmat) end = timer() logging.info('Execution time {:.4f} seconds'.format(end - start)) return 1
usg = v.vtkUnstructuredGrid() usg.Allocate(198, 198) ids = v.vtkIdList() origIds = d2d.GetOutput().GetPointData().GetArray('OrigIds') while (meshTemp.GetNextCell(ids)): n = ids.GetNumberOfIds() uIds = v.vtkIdList() for i in range(n): uIds.InsertNextId(int(origIds.GetTuple1(ids.GetId(i)))) usg.InsertNextCell(5, uIds) # Insert Projection Lines uPts = v.vtkPoints() uPtsArr = np.vstack([proj3, rPts]) uPtsArr[N - 1] = c uPts.SetData(dsa.numpyTovtkDataArray(uPtsArr)) for i in range(N - 1): uIds = v.vtkIdList() uIds.InsertNextId(N - 1) uIds.InsertNextId(i) uIds.InsertNextId(i + N) usg.InsertNextCell(4, uIds) usg.SetPoints(uPts) wr = v.vtkUnstructuredGridWriter() wr.SetFileName('Scene.vtk') wr.SetInputData(usg) wr.Write() # Now write the final spherical mesh to polydate file
def Execute(self): if self.Surface == None: self.PrintError('Error: No Input Surface.') if self.InsideValue > 255: self.PrintError('Error: Cannot assign InsideValue of image to value greater than 255') # Step 1: Convert the input surface into an image mask of unsigned char type and spacing = PolyDataToImageDataSpacing # Where voxels lying inside the surface are set to 255 and voxels outside the image are set to value 0. # since we are creating a new image container from nothing, calculate the origin, extent, and dimensions for the # vtkImageDataObject from the surface parameters. bounds = self.Surface.GetBounds() dim = [] # list of size: 3, type: int for i in range(3): dim.append(int(math.ceil((bounds[i * 2 + 1] - bounds[i * 2]) / self.PolyDataToImageDataSpacing[i]))) origin = [bounds[0] + self.PolyDataToImageDataSpacing[0] / 2, bounds[2] + self.PolyDataToImageDataSpacing[1] / 2, bounds[4] + self.PolyDataToImageDataSpacing[2] / 2] extent = [0, dim[0] - 1, 0, dim[1] - 1, 0, dim[2] - 1] whiteImage = vtk.vtkImageData() whiteImage.SetSpacing(self.PolyDataToImageDataSpacing[0], self.PolyDataToImageDataSpacing[1], self.PolyDataToImageDataSpacing[2]) whiteImage.SetDimensions(dim[0], dim[1], dim[2]) whiteImage.SetExtent(extent[0], extent[1], extent[2], extent[3], extent[4], extent[5]) whiteImage.SetOrigin(origin[0], origin[1], origin[2]) whiteImage.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1) # initially set all values of the image to a value self.InsideValue npFillImagePoints = np.zeros(whiteImage.GetNumberOfPoints(), dtype=np.uint8) npFillImagePoints[:] = self.InsideValue # it is much faster to use the vtk data set adaptor functions to fill the point data tupples that it is to # loop over each index and set values individually. pointDataArray = dsa.numpyTovtkDataArray(npFillImagePoints, name='ImageScalars', array_type=vtk.VTK_UNSIGNED_CHAR) whiteImage.GetPointData().SetActiveScalars('ImageScalars') whiteImage.GetPointData().SetScalars(pointDataArray) # The vtkPolyDataToImageStencil class will convert polydata into an image stencil, masking an image. # The polydata can either be a closed surface mesh or a series of polyline contours (one contour per slice). polyDataToImageStencilFilter = vtk.vtkPolyDataToImageStencil() polyDataToImageStencilFilter.SetInputData(self.Surface) polyDataToImageStencilFilter.SetOutputSpacing(self.PolyDataToImageDataSpacing[0], self.PolyDataToImageDataSpacing[1], self.PolyDataToImageDataSpacing[2]) polyDataToImageStencilFilter.SetOutputOrigin(origin[0], origin[1], origin[2]) polyDataToImageStencilFilter.Update() # vtkImageStencil combines to images together by using a "cookie-cutter" operation. imageStencil = vtk.vtkImageStencil() imageStencil.SetInputData(whiteImage) imageStencil.SetStencilConnection(polyDataToImageStencilFilter.GetOutputPort()) imageStencil.ReverseStencilOff() imageStencil.SetBackgroundValue(self.OutsideValue) imageStencil.Update() self.Image = imageStencil.GetOutput()
def numpy2vtk(arr,dset,aa): vtkdata = dsa.numpyTovtkDataArray(arr) vtkarray = dsa.vtkDataArrayToVTKArray(vtkdata,dset) vtkarray.Association = aa return vtkarray
def RequestData(): import numpy as np from vtk.numpy_interface import dataset_adapter as dsa from vtk.util import numpy_support as ns ipoints = inputs[0] number_of_glyphs = ipoints.GetNumberOfPoints() glyph = inputs[1] glyph_points = [scale * xscale, scale * yscale, scale * zscale ] * glyph.Points points_per_glyph = glyph_points.shape[0] cells_per_glyph = len(glyph.CellTypes) if forward not in ipoints.PointData.keys(): print 'can\'t find forward array' return U = ipoints.PointData[forward] if up not in ipoints.PointData.keys(): print 'can\'t find up array' return V = ipoints.PointData[up] W = dsa.VTKArray(np.cross(U, V)) l = np.linalg.norm(U, axis=1) U = U / np.where(l == 0, 1.0, l) l = np.linalg.norm(U, axis=1) V = V / np.where(l == 0, 1.0, l) l = np.linalg.norm(W, axis=1) W = W / np.where(l == 0, 1.0, l) P = ipoints.Points p = P[0] u = U[0] v = V[0] w = W[0] opoints = [] for i, p, u, v, w in zip(range(len(P)), P, U, V, W): opoints.append(p + glyph_points[:, 0][:, np.newaxis] * u + glyph_points[:, 1][:, np.newaxis] * v + glyph_points[:, 2][:, np.newaxis] * w) opolys = [glyph.Cells] for i in range(1, len(P)): o = np.zeros(len(glyph.Cells)) k = 0 for j in range(len(glyph.Cells)): if k == 0: k = glyph.Cells[j] o[j] = k else: k = k - 1 o[j] = glyph.Cells[j] + i * points_per_glyph opolys.append(o) opoints = dsa.numpyTovtkDataArray(np.vstack(opoints)) ids = [np.array([i] * points_per_glyph) for i in range(len(P))] ids = dsa.numpyTovtkDataArray(np.vstack(ids).flatten(), name='ID') oug = vtk.vtkUnstructuredGrid() pts = vtk.vtkPoints() pts.SetData(opoints) oug.SetPoints(pts) ct = np.hstack([glyph.CellTypes for i in range(number_of_glyphs)]) co = np.hstack([ glyph.CellLocations + i * len(glyph.Cells) for i in range(number_of_glyphs) ]) opolys = np.hstack(opolys).astype('i8') # print '11111111' # if dbg == 1: # return ct = dsa.numpyTovtkDataArray(ct) co = dsa.numpy_support.numpy_to_vtkIdTypeArray(co) opolys = ns.numpy_to_vtkIdTypeArray(opolys) # print 'XYXYXYXY' # if dbg == 2: # return ca = vtk.vtkCellArray() ca.SetCells(number_of_glyphs * cells_per_glyph, opolys) # print 'BBBBBBBB' # if dbg == 3: # return oug.SetCells(ct, co, ca) oug.GetPointData().AddArray(ids) # print 'CCCCCCC' # if dbg == 4: # return oug.GetPointData().AddArray( dsa.numpyTovtkDataArray(np.vstack( [glyph.PointData['Normals'] for i in range(number_of_glyphs)]), name='Normals')) for n in ipoints.PointData.keys(): if n != 'Normals': a = [[ipoints.PointData[n][i]] * points_per_glyph for i in range(number_of_glyphs)] oug.GetPointData().AddArray( dsa.numpyTovtkDataArray(np.concatenate(a), name=n)) # print 'DDDDDDDDDDDDDDDDDDDDDDDDDDD' # print dir(self) # print 'DDDDDDDDDDDDDDDDDDDDDDDDDDD' # print self.GetUnstructuredGridOutput() # print 'DDDDDDDDDDDDDDDDDDDDDDDDDDD' self.GetUnstructuredGridOutput().Initialize() # print self.GetUnstructuredGridOutput() # print 'DDDDDDDDDDDDDDDDDDDDDDDDDDD' # if dbg == 5: # return self.GetUnstructuredGridOutput().ShallowCopy(oug) # print self.GetUnstructuredGridOutput() return
def Execute(self): if self.Surface == None: self.PrintError('Error: No Input Surface.') if self.InsideValue > 255: self.PrintError( 'Error: Cannot assign InsideValue of image to value greater than 255' ) # Step 1: Convert the input surface into an image mask of unsigned char type and spacing = PolyDataToImageDataSpacing # Where voxels lying inside the surface are set to 255 and voxels outside the image are set to value 0. # since we are creating a new image container from nothing, calculate the origin, extent, and dimensions for the # vtkImageDataObject from the surface parameters. bounds = self.Surface.GetBounds() dim = [] # list of size: 3, type: int for i in range(3): dim.append( int( math.ceil((bounds[i * 2 + 1] - bounds[i * 2]) / self.PolyDataToImageDataSpacing[i]))) origin = [ bounds[0] + self.PolyDataToImageDataSpacing[0] / 2, bounds[2] + self.PolyDataToImageDataSpacing[1] / 2, bounds[4] + self.PolyDataToImageDataSpacing[2] / 2 ] extent = [0, dim[0] - 1, 0, dim[1] - 1, 0, dim[2] - 1] whiteImage = vtk.vtkImageData() whiteImage.SetSpacing(self.PolyDataToImageDataSpacing[0], self.PolyDataToImageDataSpacing[1], self.PolyDataToImageDataSpacing[2]) whiteImage.SetDimensions(dim[0], dim[1], dim[2]) whiteImage.SetExtent(extent[0], extent[1], extent[2], extent[3], extent[4], extent[5]) whiteImage.SetOrigin(origin[0], origin[1], origin[2]) whiteImage.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1) # initially set all values of the image to a value self.InsideValue npFillImagePoints = np.zeros(whiteImage.GetNumberOfPoints(), dtype=np.uint8) npFillImagePoints[:] = self.InsideValue # it is much faster to use the vtk data set adaptor functions to fill the point data tupples that it is to # loop over each index and set values individually. pointDataArray = dsa.numpyTovtkDataArray( npFillImagePoints, name='ImageScalars', array_type=vtk.VTK_UNSIGNED_CHAR) whiteImage.GetPointData().SetActiveScalars('ImageScalars') whiteImage.GetPointData().SetScalars(pointDataArray) # The vtkPolyDataToImageStencil class will convert polydata into an image stencil, masking an image. # The polydata can either be a closed surface mesh or a series of polyline contours (one contour per slice). polyDataToImageStencilFilter = vtk.vtkPolyDataToImageStencil() polyDataToImageStencilFilter.SetInputData(self.Surface) polyDataToImageStencilFilter.SetOutputSpacing( self.PolyDataToImageDataSpacing[0], self.PolyDataToImageDataSpacing[1], self.PolyDataToImageDataSpacing[2]) polyDataToImageStencilFilter.SetOutputOrigin(origin[0], origin[1], origin[2]) polyDataToImageStencilFilter.Update() # vtkImageStencil combines to images together by using a "cookie-cutter" operation. imageStencil = vtk.vtkImageStencil() imageStencil.SetInputData(whiteImage) imageStencil.SetStencilConnection( polyDataToImageStencilFilter.GetOutputPort()) imageStencil.ReverseStencilOff() imageStencil.SetBackgroundValue(self.OutsideValue) imageStencil.Update() self.Image = imageStencil.GetOutput()
from vtk . numpy_interface import dataset_adapter as dsa from vtk . numpy_interface import algorithms as algs import h5py as h5 f1=h5.File("/pkg/etc/clion/system/cmake/generated/2774870a/2774870a/Debug/example/em/tokamak0007.h5") x=f1["/record/0/H"][:]['p']['v'] coords=algs.make_vector(x[:,0],x[:,1],x[:,2]) pts=vtk.vtkPoints() pts.SetData(dsa.numpyTovtkDataArray ( coords , " Points ")) output.SetPoints(pts)
output = self.GetOutput() # TODO: Generate the data as you want. from vtk.numpy_interface import dataset_adapter as dsa from vtk.numpy_interface import algorithms as algs import h5py as h5 f1 = h5.File( "/pkg/clion/etc/clion/system/cmake/generated/2774870a/2774870a/Debug/example/em/tokamak.h5" ) x = f1["/record/H"][:, :][:, req_time, 0] y = f1["/record/H"][:, :][:, req_time, 1] z = f1["/record/H"][:, :][:, req_time, 2] coords = algs.make_vector(x, y, z) pts = vtk.vtkPoints() pts.SetData(dsa.numpyTovtkDataArray(coords, "Points")) output.SetPoints(pts) # Now mark the timestep produced. output.GetInformation().Set(output.DATA_TIME_STEP(), req_time) ######################################################################################################## ## Script (RequestInformation) ######################################################################################################## def SetOutputTimesteps(algorithm, timesteps): executive = algorithm.GetExecutive() outInfo = executive.GetOutputInformation(0) outInfo.Remove(executive.TIME_STEPS()) for timestep in timesteps: outInfo.Append(executive.TIME_STEPS(), timestep)
def RequestData(): import numpy as np from time import time from vtk.numpy_interface import dataset_adapter as dsa from vtk.util import numpy_support as ns ipoints = inputs[0] number_of_glyphs = ipoints.GetNumberOfPoints() glyph = inputs[1] glyph_points = [scale * xscale, scale * yscale, scale * zscale ] * glyph.Points points_per_glyph = glyph_points.shape[0] cells_per_glyph = len(glyph.CellTypes) if forward not in ipoints.PointData.keys(): print('can\'t find forward array') return U = ipoints.PointData[forward] if up not in ipoints.PointData.keys(): print('can\'t find up array') return V = ipoints.PointData[up] W = dsa.VTKArray(np.cross(U, V)) l = np.linalg.norm(U, axis=1) U = U / np.where(l == 0, 1.0, l) l = np.linalg.norm(U, axis=1) V = V / np.where(l == 0, 1.0, l) l = np.linalg.norm(W, axis=1) W = W / np.where(l == 0, 1.0, l) P = ipoints.Points p = P[0] u = U[0] v = V[0] w = W[0] xpts = glyph_points[:, 0][:, np.newaxis] ypts = glyph_points[:, 1][:, np.newaxis] zpts = glyph_points[:, 2][:, np.newaxis] opoints = [] for i, p, u, v, w in zip(range(len(P)), P, U, V, W): opoints.append(p + xpts * u + ypts * v + zpts * w) opolys = [glyph.Cells.reshape(-1, 4)] ijk = glyph.Cells.reshape((-1, 4))[:, 1:4] for i in range(1, len(P)): nijk = np.column_stack( ([3] * ijk.shape[0], ijk + i * points_per_glyph)) opolys.append(nijk) opoints = dsa.numpyTovtkDataArray(np.vstack(opoints)) ids = [np.array([i] * points_per_glyph) for i in range(len(P))] ids = dsa.numpyTovtkDataArray(np.vstack(ids).flatten(), name='ID') oug = vtk.vtkUnstructuredGrid() pts = vtk.vtkPoints() pts.SetData(opoints) oug.SetPoints(pts) ct = np.hstack([glyph.CellTypes for i in range(number_of_glyphs)]) co = np.hstack([ glyph.CellLocations + i * len(glyph.Cells) for i in range(number_of_glyphs) ]) opolys = np.hstack(opolys).astype('i8') ct = dsa.numpyTovtkDataArray(ct) co = dsa.numpy_support.numpy_to_vtkIdTypeArray(co) opolys = ns.numpy_to_vtkIdTypeArray(opolys) ca = vtk.vtkCellArray() ca.SetCells(number_of_glyphs * cells_per_glyph, opolys) oug.SetCells(ct, co, ca) oug.GetPointData().AddArray(ids) oug.GetPointData().AddArray( dsa.numpyTovtkDataArray(np.vstack( [glyph.PointData['Normals'] for i in range(number_of_glyphs)]), name='Normals')) if 'Texture Coordinates' in glyph.PointData.keys(): a = np.vstack([ glyph.PointData['Texture Coordinates'] for i in range(len(ipoints.Points)) ]) oug.GetPointData().SetTCoords(dsa.numpyTovtkDataArray(a)) for n in ipoints.PointData.keys(): if n != 'Normals': a = [[ipoints.PointData[n][i]] * points_per_glyph for i in range(number_of_glyphs)] oug.GetPointData().AddArray( dsa.numpyTovtkDataArray(np.concatenate(a), name=n)) self.GetUnstructuredGridOutput().Initialize() self.GetUnstructuredGridOutput().ShallowCopy(oug) return
def RequestData(): import numpy as np from vtk.numpy_interface import dataset_adapter as dsa from math import ceil, floor sl = self.GetUnstructuredGridInput() nsl = dsa.WrapDataObject(sl) arclen = nsl.PointData['arclen'] nv = nsl.Cells[nsl.CellLocations] # number of verts in each line ns = nsl.CellLocations + 1 # index of first vertex in each line ne = ns + nv # index one past the last vertex lines = [nsl.Cells[i:j] for i, j in zip(ns, ne)] # divide into distinct lines llen = arclen[[l[-1] for l in lines]] # length of each line totlen = sum(llen) # total length sdist = totlen / nsamples # appx distance between samples nPerLine = np.array([int(ceil(l / sdist)) for l in llen]) # samples in each line nPerLine = np.where(nPerLine < 3, 3, nPerLine) iarrays = { 'points': nsl.Points } # initialize source arrays with input points oarrays = { 'points': [] } # initialize destination arrays with (empty) points for n in nsl.PointData.keys(): iarrays[n] = nsl.PointData[ n] # add input point data arrays to source arrays oarrays[n] = [] # add empty destination arrays for i, line in enumerate(lines): # for each input line... ns = nPerLine[i] # number in this line sdist1 = float(llen[i] / (ns - 1)) # inter-sample distance in this line x = arclen[line] # X axis is arc len along line y = range(len(line)) # Y is index along line s = [i * sdist1 for i in range(ns) ] # s's are the sample points along the line in arclen d = np.interp(s, x, y) # d's are the interpolant values ds = np.floor(d).astype('i4') # index of interval start dd = d - ds # delta in interval de = np.where(dd == 0, ds, ds + 1) # index of interval end (unless dd is zero) si = line[ds] # offset of starting value in arrays se = line[de] # offset of ending value in arrays for n in iarrays: # for each array we are interpolating... ia = iarrays[n] # input array sv = ia[si] # start values ev = ia[si] # end values v = sv + dd * (ev - sv) # interpolation oarrays[n].append(v) ptsa = np.concatenate(oarrays['points']).astype('f4') oug = self.GetUnstructuredGridOutput() op = vtk.vtkPoints() op.SetNumberOfPoints(ptsa.shape[0]) for i, p in enumerate(ptsa): op.InsertPoint(i, p[0], p[1], p[2]) oug.SetPoints(op) for n in oarrays: if n != 'points': a = dsa.numpyTovtkDataArray(np.concatenate(oarrays[n])) a.SetName(n) oug.GetPointData().AddArray(a) ct = dsa.numpyTovtkDataArray( np.array([vtk.VTK_VERTEX] * oug.GetNumberOfPoints()).astype('u1')) co = dsa.numpy_support.numpy_to_vtkIdTypeArray( np.array(range(0, 2 * oug.GetNumberOfPoints(), 2))) ca = vtk.vtkCellArray() for i in range(oug.GetNumberOfPoints()): ca.InsertNextCell(1, [i]) oug.SetCells(ct, co, ca)
def main(argv): import vtk from vtk.numpy_interface import dataset_adapter as dsa from vtk.numpy_interface import algorithms as algs import numpy as np ### get parameters import os if not os.path.exists(OD): os.makedirs(OD) print '!!!Output to DIR: ',OD if not read_fields_from_file: ### Readin stage # using parallel openfoam reader ofr = vtk.vtkPOpenFOAMReader() # set reader's options ofr.SetFileName(ID+IF) print '!!!open file: ',ID+IF ofr.SetDecomposePolyhedra(0) ofr.CacheMeshOn() ofr.SetCreateCellToPoint(0) ofr.DisableAllCellArrays() ofr.SetCellArrayStatus(fieldname,1) ofr.Update() # VTKArray is same as numpy array times = dsa.vtkDataArrayToVTKArray( ofr.GetTimeValues() ,ofr) # select the timestep between t0 and tf times = [t for t in times if t>=t0 and t<=tf] print '!!!available time steps: ',times N = len(times) np.save(times_filename,times) # using CellQuality to get cell's volumes as weight cq = vtk.vtkCellQuality() cq.SetInputConnection(0,ofr.GetOutputPort(0)) cq.SetQualityMeasureToVolume() cq.Update() # cq is a composite dataset so I need GetBlock(0) geom = cq.GetOutputDataObject(0).GetBlock(0) # get volumes of cells V, size = L (number of cells) V = np.copy(dsa.WrapDataObject(geom).CellData['CellQuality']) # normalize it as weight Vtotal = sum(V) V /= Vtotal # delete all other CellDataArray in geom DataSet, preserve its mesh structure and topology structure for i in range(geom.GetCellData().GetNumberOfArrays()): geom.GetCellData().RemoveArray(0) # add volume weight to it for saving geom.GetCellData().AddArray(dsa.numpyTovtkDataArray(V,'vol_weight')) # using *.vtu file format to save the vol_weight ugw = vtk.vtkXMLUnstructuredGridWriter() ugw.SetInputDataObject(geom) print '!!!Output vol_weight to file: ',geom_filename ugw.SetFileName(geom_filename) # using binary format ugw.SetDataModeToBinary() # enable compression ugw.SetCompressorTypeToZLib() # write to the file ugw.Write() # disconnect cq and ofr in order to isolate this dataset object from Update() cq.RemoveAllInputConnections(0) L = V.size # number of cells N = len(times) #number of timesteps # vector data is larger in size if field_is_vector == True: fields = np.zeros([N,L,3]) else: fields = np.zeros([N,L]) pipepout = ofr for i in range(N): t = times[i] print '!!!reading time:{}'.format(t) # set time value pipepout.GetOutputInformation(0).Set(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_TIME_STEP(),t) # read in field data of new timestep pipepout.Update() # d = dsa.WrapDataObject(pipepout.GetOutput().GetBlock(0)) print '!!!reading field:{}'.format(fieldname) field = d.CellData[fieldname] # get the first component of composite dataset, it is the internalField fields[i]=np.copy(field) # write data to file print '!!!write field data to file:',fields_filename np.savez(fields_filename,fields) else: #read fields from file fields = np.load(fields_filename)['arr_0'] ugr = vtk.vtkXMLUnstructuredGridReader() ugr.SetFileName(geom_filename) ugr.Update() geom = ugr.GetOutputDataObject(0) V = np.copy(dsa.WrapDataObject(geom).CellData['vol_weight']) times = np.load(times_filename) assert times.shape[0] == fields.shape[0] assert fields.shape[1] == V.shape[0] N = times.shape[0] L = fields.shape[1] print 'Read in dataset complete' ### POD section # calculate average field_avg = np.average(fields, axis=0) if subtractAvg: fields = fields - field_avg import modred as mr if do_POD: # if field is a vector, reshape the fields and corresponding volument weight if field_is_vector: shp_vec = fields.shape shp_flat = (fields.shape[0],fields.shape[1]*fields.shape[2]) fields = fields.reshape(shp_flat) V = np.tile(V,shp_vec[2]) # POD print '!!!Doing POD analysis' modes, eigen_vals, eigen_vecs, correlation_mat = mr.compute_POD_matrices_snaps_method(fields.T,range(M),inner_product_weights=V,return_all=True) # if field is a vector, reshape the output matrix if field_is_vector: fields = fields.reshape(shp_vec) modes = np.asarray(modes).T.reshape((modes.shape[1],shp_vec[1],shp_vec[2])) V = V[:shp_vec[1]] if output_correlation_matrix: print "!!!output POD correlation matrix",POD_cm_filename np.savetxt(POD_cm_filename,correlation_mat,delimiter=',') if output_POD_temporal_modes: print "!!!output POD temporal modes",POD_tm_filename # output temporal modes singular_vals = eigen_vals**0.5 POD_mode_energy_normalized = eigen_vals/correlation_mat.trace()[0,0] cumsum_POD_mode_energy_normalized = np.cumsum(POD_mode_energy_normalized) # generate header string header_str = 'temporal modes\n' header_str += 'time,eigen value,singular value,normalized eigen value,accumulated normalized eigen value' for i in range(N-1): header_str += ',Mode{}'.format(i) header_str += '\n' for i in range(N-1): header_str += ',SV ={}'.format(singular_vals[i]) header_str += '\n' for i in range(N-1): header_str += ',EV ={}'.format(eigen_vals[i]) header_str += '\n' for i in range(N-1): header_str += ',NEnergy ={}'.format(POD_mode_energy_normalized[i]) header_str += '\n' for i in range(N-1): header_str += ',CumsumEnergy ={}'.format(cumsum_POD_mode_energy_normalized[i]) header_str += '\n' np.savetxt(POD_tm_filename, \ np.c_[times, \ eigen_vecs], \ delimiter = ',', \ header = header_str) if output_POD_spatial_modes: print "!!!output POD spatial Modes to ",POD_sm_filename #output to xml vtk unstructured grid file ugcd = geom.GetCellData() ugcd.Reset() ugcd.CopyAllOff() for i in range(ugcd.GetNumberOfArrays()): ugcd.RemoveArray(0) # import POD mode for i in range(M): ugcd.AddArray(dsa.numpyTovtkDataArray(modes[i],prefix+'_POD_mode_{}_{}'.format(fieldname,i))) # add average field ugcd.AddArray(dsa.numpyTovtkDataArray(field_avg,'field_{}_avg'.format(fieldname))) ugw = vtk.vtkXMLUnstructuredGridWriter() ugw.SetInputDataObject(geom) ugw.SetFileName(POD_sm_filename) ugw.Write() if doReconstruction: print "!!! do Reconstrution with {} POD modes at time {}".format(MR,ReconTime) #get an empty mesh ugcd = geom.GetCellData() ugcd.Reset() ugcd.CopyAllOff() for i in range(ugcd.GetNumberOfArrays()): ugcd.RemoveArray(0) # reconstruct from first MR POD modes # ReconN = np.searchsorted(times,ReconTime) print "!!!actually, reconstruction is done at time {} rather than time {}".format(times[ReconN],ReconTime) recon_field = np.einsum("i...,i,i",modes[:MR],eigen_vals[:MR]**0.5,np.asarray(eigen_vecs)[ReconN,:MR])+field_avg; ugcd.AddArray(dsa.numpyTovtkDataArray(recon_field,prefix+'_POD_{}_Reconstructed_{}_{}'.format(MR,fieldname,ReconTime))) ugw = vtk.vtkXMLUnstructuredGridWriter() ugw.SetInputDataObject(geom) ugw.SetFileName(POD_reconstruction_filename) ugw.Write() if do_DMD: print "!!!Begin to calculate DMD modes" # if field is a vector, reshape the fields and corresponding volument weight if field_is_vector: shp_vec = fields.shape shp_flat = (fields.shape[0],fields.shape[1]*fields.shape[2]) fields = fields.reshape(shp_flat) V = np.tile(V,shp_vec[2]) # DMD, I do not know which mode is important, so I have to discard modes_ modes_, ritz_vals, mode_norms, build_coeffs = mr.compute_DMD_matrices_snaps_method(fields.T,[],inner_product_weights=V,return_all=True) # if field is a vector, reshape the fields, V and output matrix if field_is_vector: fields = fields.reshape(shp_vec) V = V[:shp_vec[1]] # sorting eorder = np.argsort(mode_norms)[::-1] # re-order the outputs ritz_vals = ritz_vals[eorder] mode_norms = mode_norms[eorder] build_coeffs = build_coeffs[:,eorder] #build the DMD_modes DMD_modes = np.einsum('ijk,il->ljk', fields,build_coeffs[:,:M_DMD]) if output_DMD_info: print "!!!output DMD info to :",DMD_info_filename # output modes info header_str = 'DMD modes info\n' header_str += 'ritz_vals.real,ritz_vals.imag,growth_rate, frequency, mode_norms\n' header_str += r'AU,AU,1/s, Hz, AU' dt = np.average(times[1:]-times[:-1]) #time step np.savetxt(DMD_info_filename, \ np.c_[ np.real(ritz_vals), \ np.imag(ritz_vals), \ np.log(np.abs(ritz_vals))/dt, \ np.angle(ritz_vals)/dt, \ mode_norms], \ delimiter = ',', \ header = header_str) if output_DMD_build_coeffs: print "!!!output DMD build coeffs. to :",DMD_build_coeffs_filename np.savez(DMD_build_coeffs_filename, build_coeffs) if output_DMD_spatial_modes: print "!!!output DMD info to :",DMD_sm_filename #output to xml vtk unstructured grid file ugcd = geom.GetCellData() ugcd.Reset() ugcd.CopyAllOff() for i in range(ugcd.GetNumberOfArrays()): ugcd.RemoveArray(0) #import pi from numpy import pi for i in range(M_DMD): ugcd.AddArray(dsa.numpyTovtkDataArray(np.abs(DMD_modes[i]),prefix+'_DMD_mode_abs_{}_{}'.format(fieldname,i))) ugcd.AddArray(dsa.numpyTovtkDataArray(np.angle(DMD_modes[i])*180/pi,prefix+'_DMD_mode_angle_{}_{}'.format(fieldname,i))) ugw = vtk.vtkXMLUnstructuredGridWriter() ugw.SetInputDataObject(geom) ugw.SetFileName(DMD_sm_filename) ugw.Write()
def RequestData(self, request, inInfo, outInfo): logging.info('') start = timer() # input (vtkImageData) inp = vtk.vtkImageData.GetData(inInfo[0]) # if the vtkImageData size has changed or this is the first time # save new size info and initialize containers if (self._sizex, self._sizey, self._viewport) != (inp.sizex, inp.sizey, inp.viewport): (self._sizex, self._sizey) = (inp.sizex, inp.sizey) self._viewport = inp.viewport self._init_containers() # the incoming depth image di = numpy_support.vtk_to_numpy(inp.GetPointData().GetScalars())\ .reshape((self._sizey, self._sizex)) # add z values to viewport_pts based on incoming depth image self._viewport_pts[2, :] = di.reshape(-1) # project to world coordinates self._world_pts = np.dot(inp.tmat, self._viewport_pts) self._world_pts = self._world_pts / self._world_pts[3] """ Remove invalid points """ # index to pts outside sensor range (defined by vtkCamera clipping range) outside_range = ~(di < self._param_farplane_threshold) # find pixel neighbors with large differences in value # http://docs.scipy.org/doc/scipy/reference/tutorial/ndimage.html kh = np.array([[1, -1], [0, 0]]) edges_h = abs(ndimage.convolve(di, kh, mode='nearest', origin=-1)) > self.param_convolution_theshold kv = np.array([[1, 0], [-1, 0]]) edges_v = abs(ndimage.convolve(di, kv, mode='nearest', origin=-1)) > self.param_convolution_theshold # combine all the points found to be invalid # and set them to a value underneath the "floor of the environment" # http://stackoverflow.com/a/20528566/4068274 invalid_index = np.logical_or.reduce((outside_range.reshape(-1), edges_h.reshape(-1), edges_v.reshape(-1))) self._world_pts[0:3, invalid_index] = np.array([[0.0], [-2.0], [0.0]]) """ Update and set filter output """ # update vtkPoints vtkarray = dsa.numpyTovtkDataArray(self._world_pts[0:3, :].T) self._points.SetData(vtkarray) # update output (vtkPolyData) out = vtk.vtkPolyData.GetData(outInfo) self._extract.Update() logging.info('Number of triangles: {}'.format(self._extract.GetOutput().GetNumberOfCells())) out.ShallowCopy(self._extract.GetOutput()) end = timer() logging.info('Execution time {:.4f} seconds'.format(end - start)) return 1
def RequestData(): import numpy as np from vtk.numpy_interface import dataset_adapter as dsa from math import ceil, floor sl = self.GetUnstructuredGridInput() # The streamlines nsl = dsa.WrapDataObject(sl) # wrap with a Python interface itime = nsl.PointData[ 'IntegrationTime'] # the time component of the streamlines nv = nsl.Cells[nsl.CellLocations] # number of verts in each line ns = nsl.CellLocations + 1 # index of first vertex in each line ne = ns + nv # index one past the last vertex lines = [nsl.Cells[i:j] for i, j in zip(ns, ne)] # divide into distinct lines # lines[i] is a list of the ids of the # vertices that comprise each streamline # Get length (in integration time) of longest line. Note - this assumes that the # forward- and backward- integrations are combined into one streamline (see JoinStreamlines) mint = itime[lines[0][0]] maxt = itime[lines[0][-1]] maxlen = itime[lines[0][-1]] - itime[lines[0][0]] if len(lines) > 1: for i in range(1, len(lines)): mt = itime[lines[i][-1]] - itime[lines[i][0]] if mt > maxlen: maxlen = mt if mint > itime[lines[i][0]]: mint = itime[lines[i][0]] if maxt < itime[lines[i][-1]]: maxt = itime[lines[i][-1]] # dt is the distance between samples in integration time - nt samples distributed along longest line dt = (maxt - mint) / nt # destination arrays for streamline points and any point-dependent data - eg. orientation data iarrays = { 'points': nsl.Points } # initialize source arrays with input points oarrays = { 'points': [] } # initialize destination arrays with (empty) points for n in nsl.PointData.keys(): iarrays[n] = nsl.PointData[ n] # add input point data arrays to source arrays oarrays[n] = [] # add empty destination arrays # for each sample time... for it in range(nt): sample_t = mint + (it + t) * dt # the point in time to interpolate at for i, line in enumerate(lines): # for each input line... # if this sample time is in the range for the current line... if sample_t >= itime[line[0]] and sample_t <= itime[line[-1]]: # index of first elt greater than sample_x (or 0, in which case we use the last) interval_end = np.argmax( itime[line] > sample_t) # linear search? if interval_end == 0: interval_end = len(line) - 1 # get indices of points and point-dependent data at either end of the interval endi = line[interval_end] starti = line[interval_end - 1] # interpolant value in interval d = (sample_t - itime[starti]) / (itime[endi] - itime[starti] ) # interpolant in interval for n in iarrays: # for each array we are interpolating... ia = iarrays[n] # input array sv = ia[starti] # start values ev = ia[endi] # end values v = sv + d * (ev - sv) # interpolation oarrays[n].append(v) # create an output vtkUnstructured data with the interpolated points and data ptsa = np.concatenate(oarrays['points']).reshape((-1, 3)).astype('f4') oug = vtk.vtkUnstructuredGrid() op = vtk.vtkPoints() op.SetNumberOfPoints(ptsa.shape[0]) for i, p in enumerate(ptsa): op.InsertPoint(i, p[0], p[1], p[2]) oug.SetPoints(op) for n in oarrays: if n != 'points': if oarrays[n][0].__class__ == dsa.VTKArray: ncomp = len(oarrays[n][0]) a = dsa.numpyTovtkDataArray( np.concatenate(oarrays[n]).reshape((-1, ncomp))) else: a = dsa.numpyTovtkDataArray(oarrays[n]) a.SetName(n) oug.GetPointData().AddArray(a) ct = dsa.numpyTovtkDataArray( np.array([vtk.VTK_VERTEX] * oug.GetNumberOfPoints()).astype('u1')) co = dsa.numpy_support.numpy_to_vtkIdTypeArray( np.array(range(0, 2 * oug.GetNumberOfPoints(), 2))) ca = vtk.vtkCellArray() for i in range(oug.GetNumberOfPoints()): ca.InsertNextCell(1, [i]) oug.SetCells(ct, co, ca) self.GetUnstructuredGridOutput().ShallowCopy(oug)
def RequestData(self, request, inInfoVec, outInfoVec): import sys, os import vtk from vtkmodules.vtkCommonDataModel import vtkUnstructuredGrid, vtkImageData, vtkDataSet from vtk.numpy_interface import dataset_adapter as dsa import ctypes as C import numpy as np if 'HOME' in os.environ: ccode_so = os.environ['HOME'] + '/python/_sample.so' elif 'HOMEPATH' in os.environ: ccode_so = os.environ['HOMEPATH'] + '/python/_sample.so' else: code_so = '_sample.so' if not os.path.isfile(ccode_so): print('can\'t find so:', ccode_so) return ccode = C.CDLL(ccode_so) if not ccode: print('failed to load ', ccode.so) ccode.SampleTetrahedra.argtypes = [ C.c_int, C.c_int, C.c_int, C.c_int, np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), np.ctypeslib.ndpointer(C.c_int, flags="C_CONTIGUOUS") ] ccode.SampleRectilinear.argtypes = [ C.c_int, C.c_int, np.ctypeslib.ndpointer(C.c_int, flags="C_CONTIGUOUS"), np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS") ] ccode.SampleVTI.argtypes = [ C.c_int, C.c_int, np.ctypeslib.ndpointer(C.c_int, flags="C_CONTIGUOUS"), np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS") ] ccode.GetNumberOfSamples.restype = C.c_int ccode.GetSamples.restype = C.c_void_p obj = dsa.WrapDataObject(vtkDataSet.GetData(inInfoVec[0], 0)) pdf = self.inputArray nSamples = self.nSamples if obj.GetClassName() == 'vtkImageData': a = vtkImageData.GetData(inInfoVec[0], 0) vti = dsa.WrapDataObject(vtkImageData.GetData(inInfoVec[0], 0)) e = vti.VTKObject.GetExtent() o = vti.VTKObject.GetOrigin() s = vti.VTKObject.GetSpacing() dimensions = np.array([(e[2 * i + 1] - e[2 * i]) + 1 for i in range(3)]).astype('i4') origin = np.array([o[i] + e[2 * i] * s[i] for i in range(3)]).astype('f4') spacing = np.array(s).astype('f4') pdf = np.ascontiguousarray(vti.CellData[pdf]).astype('f4') ccode.SampleVTI(0, nSamples, dimensions, origin, spacing, pdf) elif obj.GetClassName() == 'vtkUnstructuredGrid': vtu = dsa.WrapDataObject( vtkUnstructuredGrid.GetData(inInfoVec[0], 0)) points = np.ascontiguousarray(vtu.Points).astype('f4') pdf = np.ascontiguousarray(vtu.CellData[pdf]).astype('f4') tets = np.ascontiguousarray(vtu.Cells).astype('i4') ccode.SampleTetrahedra(0, nSamples, vtu.GetNumberOfPoints(), vtu.GetNumberOfCells(), points, pdf, tets) elif obj.GetClassName() == 'vtkRectilinearGrid': vtr = vtkRectilinearGrid.GetData(inInfoVec[0], 0) x_array = dsa.numpy_support.vtk_to_numpy( vtr.GetXCoordinates()).astype('f4') y_array = dsa.numpy_support.vtk_to_numpy( vtr.GetYCoordinates()).astype('f4') z_array = dsa.numpy_support.vtk_to_numpy( vtr.GetZCoordinates()).astype('f4') pdf = dsa.numpy_support.vtk_to_numpy( vtr.GetCellData().GetArray(pdf)).astype('f4') dim = (len(x_array), len(y_array), len(z_array)) ccode.SampleRectilinear(0, dim, x_array, y_array, z_array, pdf) else: print( "SampleCellDensity requires vtkImageData or vtkUnstructuredGrid" ) return 0 n = ccode.GetNumberOfSamples() s = np.ctypeslib.as_array(C.cast(ccode.GetSamples(), C.POINTER(C.c_float)), shape=(n, 3)) samples = dsa.WrapDataObject(vtk.vtkUnstructuredGrid()) co = dsa.numpy_support.numpy_to_vtkIdTypeArray( np.arange(n).astype('i8') * 2) ca = vtk.vtkCellArray() ca.SetCells( n, dsa.numpy_support.numpy_to_vtkIdTypeArray( np.column_stack(([1] * n, range(n))).reshape( (2 * n, )).astype('i8'))) ct = dsa.numpyTovtkDataArray( np.array([vtk.VTK_VERTEX] * n).astype('u1')) samples.VTKObject.SetCells(ct, co, ca) samples.Points = dsa.numpy_support.numpy_to_vtk(s, deep=1) outpt = vtkUnstructuredGrid.GetData(outInfoVec, 0) outpt.ShallowCopy(samples.VTKObject) ccode.Cleanup() return 1
def RequestData(self, request, inInfoVec, outInfoVec): import sys, os import vtk for i in dir(vtk): if i[:5] == 'vtkRe': print(i) from vtk.numpy_interface import dataset_adapter as dsa import ctypes as C import numpy as np if 'HOME' in os.environ: ccode_so = os.environ[ 'HOME'] + '/ParaviewPythonModules/libSampleDataset.so' elif 'HOMEPATH' in os.environ: ccode_so = os.environ[ 'HOMEPATH'] + '/ParaviewPythonModules/libSampleDataset.so' else: ccode_so = 'SampleDataset.so' if not os.path.isfile(ccode_so): print('can\'t find so:', ccode_so) return ccode = C.CDLL(ccode_so) if not ccode: print('failed to load ', ccode.so) ccode.SampleCartesian.argtypes = [ C.c_int, # desired number of samples np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), # origin (3) np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), # spacing (3) np.ctypeslib.ndpointer(C.c_int, flags="C_CONTIGUOUS"), # counts (3) C.c_float, # minimum spacing C.c_float, # maximum spacing C.c_int, # pdep data? np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), # data C.c_int, # number of retained samples np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), # retained samples np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS") ] # new data interpolated on retained samples ccode.SampleTetrahedra.argtypes = [ C.c_int, # desired number of samples C.c_int, # number of cells C.c_float, # minimum spacing C.c_float, # maximum spacing np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), # points np.ctypeslib.ndpointer(C.c_int, flags="C_CONTIGUOUS"), # cells C.c_int, # pdep data? np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), # data C.c_int, # number of retained samples np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS"), # retained samples np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS") ] # new data interpolated on retained samples ccode.GetNumberOfSamples.restype = C.c_int ccode.GetSamples.argtypes = [ np.ctypeslib.ndpointer(C.c_float, flags="C_CONTIGUOUS") ] # self.inputArray = 'PDF' print("Sample USING ", self.inputArray) if self.retained != None: r = vtk.vtkResampleWithDataSet() r.SetSourceData(vtk.vtkDataSet.GetData(inInfoVec[0], 0)) r.SetInputData(self.retained) r.Update() rr = dsa.WrapDataObject(r.GetOutput()) del r rs = rr.Points.astype('f4') rd = rr.PointData[self.inputArray].astype('f4') nRetained = rr.GetNumberOfPoints() del rr else: nRetained = 0 rs = np.zeros(1).astype('f4') rd = np.zeros(1).astype('f4') inpt = vtk.vtkImageData.GetData(inInfoVec[0], 0) if inpt != None: inpt = dsa.WrapDataObject(inpt) o = inpt.VTKObject.GetOrigin() e = inpt.VTKObject.GetExtent() s = inpt.VTKObject.GetSpacing() k = np.array([e[i * 2 + 1] - e[i * 2] + 1 for i in range(3)]).astype('i4') o = np.array([o[i] + e[2 * i] * s[i] for i in range(3)]).astype('f4') s = np.array(s).astype('f4') data = np.ascontiguousarray( inpt.PointData[self.inputArray]).astype('f4') ccode.SampleCartesian(self.samples, o, s, k, self.minSpacing, self.maxSpacing, 1, data, nRetained, rs, rd) else: inpt = vtk.vtkUnstructuredGrid.GetData(inInfoVec[0], 0) if inpt == None: print("Can only handle ImageData or UnstructuredGrid") return 1 inpt = dsa.WrapDataObject(inpt) if np.min(inpt.CellTypes) < vtk.VTK_TETRA or np.max( inpt.CellTypes) > vtk.VTK_TETRA: print( "can handle only cartesian grids or unstructured grids containing only tetrahedra" ) return 1 nCells = inpt.GetNumberOfCells() points = np.ascontiguousarray(inpt.Points).astype('f4') tets = np.ascontiguousarray(inpt.Cells).astype('i4') data = np.ascontiguousarray( inpt.PointData[self.inputArray]).astype('f4') ccode.SampleTetrahedra(self.samples, nCells, self.minSpacing, self.maxSpacing, points, tets, 1, data, nRetained, rs, rd) nSamples = ccode.GetNumberOfSamples() samples = np.zeros(nSamples * 3).astype('f4') ccode.GetSamples(samples) samples = samples.reshape(-1, 3) print("Xreturn ", nSamples, " samples") so = dsa.WrapDataObject(vtk.vtkUnstructuredGrid()) co = dsa.numpy_support.numpy_to_vtkIdTypeArray( np.arange(nSamples).astype('i8') * 2) ca = vtk.vtkCellArray() ca.SetCells( nSamples, dsa.numpy_support.numpy_to_vtkIdTypeArray( np.column_stack(([1] * nSamples, range(nSamples))).reshape( (2 * nSamples, )).astype('i8'))) ct = dsa.numpyTovtkDataArray( np.array([vtk.VTK_VERTEX] * nSamples).astype('u1')) so.VTKObject.SetCells(ct, co, ca) so.Points = dsa.numpy_support.numpy_to_vtk(samples, deep=1) print("hello") from vtk import vtkResampleWithDataSet r = vtkResampleWithDataSet() r.SetSourceData(inpt.VTKObject) r.SetInputData(so.VTKObject) r.Update() outpt = vtk.vtkUnstructuredGrid.GetData(outInfoVec, 0) outpt.ShallowCopy(r.GetOutput()) if self.continuity: self.retained = r.GetOutput() del so del r return 1