def VtkDibujaIdsCells(uGrid, setToDraw, entTypeName, renderer): ids= vtk.vtkIdFilter() ids.SetInput(uGrid) ids.CellIdsOff() ids.PointIdsOff() VtkCargaIdsCells(uGrid,setToDraw,entTypeName) # Dibuja las etiquetas de las líneas. cc= vtk.vtkCellCenters() cc.SetInputConnection(ids.GetOutputPort()) # Centroides de las celdas. visCells= vtk.vtkSelectVisiblePoints() visCells.SetInputConnection(cc.GetOutputPort()) visCells.SetRenderer(renderer) visCells.SelectionWindowOff() #Create the mapper to display the cell ids. Specify the format to # use for the labels. Also create the associated actor. cellMapper= vtk.vtkLabeledDataMapper() cellMapper.SetInputConnection(visCells.GetOutputPort()) cellMapper.GetLabelTextProperty().SetColor(0,0,0.9) cellLabels= vtk.vtkActor2D() cellLabels.SetMapper(cellMapper) renderer.AddActor2D(cellLabels)
def VtkDibujaIdsElementos(nmbUGrid, setName, renderer): # ****** Creamos las etiquetas para las celdas ******* ids= vtk.vtkIdFilter() ids.SetInput(nmbUGrid) ids.CellIdsOff() ids.PointIdsOff() VtkCargaIdsElem(nmbUGrid,setName)() # Dibuja las etiquetas de las líneas. cc= vtk.vtkCellCenters() cc.SetInput(ids) # Centroides de las celdas. visElems= vtk.vtkSelectVisiblePoints() visElems.SetInput(cc) visElems.SetRenderer(renderer) visElems.SelectionWindowOff() ''' Create the mapper to display the element ids. Specify the format to use for the labels. Also create the associated actor. ''' elemMapper= vtk.vtkLabeledShStrMapper() elemMapper.SetInput(visElems) elemMapper.LabelTextProperty.SetColor(0,0,0.9) elemLabels= vtk.vtkActor2D() elemLabels.SetMapper(elemMapper) renderer.AddActor2D(elemLabels)
def buildATPMesh(polydata, filename): centroidFilter = vtk.vtkCellCenters() centroidFilter.VertexCellsOn() centroidFilter.SetInputData(polydata) newPolydata = vtk.vtkPolyData() newPolydata = centroidFilter.GetOutput() centroidFilter.Update() ATPValues = vtk.vtkDoubleArray() ATPValues.SetName("initialATP") _, _, yMin, yMax, _, _ = polydata.GetBounds() yRange = yMax - yMin for pointId in range(0, newPolydata.GetNumberOfPoints()): _, y, _ = newPolydata.GetPoint(pointId) ATPValue = y / (yRange * 1.0) ATPValues.InsertNextValue(ATPValue) newPolydata.GetCellData().SetScalars(ATPValues) polyDataWriter = vtk.vtkXMLPolyDataWriter() polyDataWriter.SetFileName(filename) polyDataWriter.SetInputData(newPolydata) polyDataWriter.Write()
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkCellCenters(), 'Processing.', ('vtkDataSet',), ('vtkPolyData',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def getCenters(self): vtkCenters=vtk.vtkCellCenters() vtkCenters.SetInputConnection(self.outputPort) vtkCenters.Update() centersOutput=vtkCenters.GetOutput() self.centers=np.array([centersOutput.GetPoint(i) for i in range(self.Ncells)]) return self.centers
def Execute(self): if not self.Centerlines: self.PrintError('Error: No input centerlines.') return if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 self.vmtkRenderer.RegisterScript(self) if self.CellDataArrayName: cellCenters = vtk.vtkCellCenters() cellCenters.SetInput(self.Centerlines) cellCenters.Update() cellCenters.GetOutput().GetPointData().SetActiveScalars(self.CellDataArrayName) labelsMapper = vtk.vtkLabeledDataMapper(); labelsMapper.SetInput(cellCenters.GetOutput()) labelsMapper.SetLabelModeToLabelScalars() labelsActor = vtk.vtkActor2D() labelsActor.SetMapper(labelsMapper) self.vmtkRenderer.Renderer.AddActor(labelsActor) centerlineMapper = vtk.vtkPolyDataMapper() centerlineMapper.SetInput(self.Centerlines) if self.CellDataArrayName and not self.PointDataArrayName: centerlineMapper.ScalarVisibilityOn() centerlineMapper.SetScalarModeToUseCellData() self.Centerlines.GetCellData().SetActiveScalars(self.CellDataArrayName) centerlineMapper.SetScalarRange(self.Centerlines.GetCellData().GetScalars().GetRange(0)) elif self.PointDataArrayName: centerlineMapper.ScalarVisibilityOn() centerlineMapper.SetScalarModeToUsePointData() self.Centerlines.GetPointData().SetActiveScalars(self.PointDataArrayName) centerlineMapper.SetScalarRange(self.Centerlines.GetPointData().GetScalars().GetRange(0)) else: centerlineMapper.ScalarVisibilityOff() centerlineActor = vtk.vtkActor() centerlineActor.SetMapper(centerlineMapper) self.vmtkRenderer.Renderer.AddActor(centerlineActor) scalarBarActor = None if self.Legend and centerlineActor and self.PointDataArrayName: scalarBarActor = vtk.vtkScalarBarActor() scalarBarActor.SetLookupTable(centerlineActor.GetMapper().GetLookupTable()) scalarBarActor.GetLabelTextProperty().ItalicOff() scalarBarActor.GetLabelTextProperty().BoldOff() scalarBarActor.GetLabelTextProperty().ShadowOff() scalarBarActor.SetLabelFormat('%.2f') scalarBarActor.SetTitle(self.PointDataArrayName) self.vmtkRenderer.Renderer.AddActor(scalarBarActor) if self.Display: self.vmtkRenderer.Render() if self.OwnRenderer: self.vmtkRenderer.Deallocate()
def getCellCenters( mesh, verbose=1): myVTK.myPrint(verbose, "*** getCellCenters ***") filter_cell_centers = vtk.vtkCellCenters() filter_cell_centers.SetInputData(mesh) filter_cell_centers.Update() return filter_cell_centers.GetOutput()
def getCellCenters( mesh, verbose=0): myVTK.myPrint(verbose, "*** getCellCenters ***") filter_cell_centers = vtk.vtkCellCenters() if (vtk.vtkVersion.GetVTKMajorVersion() >= 6): filter_cell_centers.SetInputData(mesh) else: filter_cell_centers.SetInput(mesh) filter_cell_centers.Update() return filter_cell_centers.GetOutput()
def _save_mark_actors(self, gui, make_node_labels, make_element_labels, nnodes, nelements, actors): """replace the actors with labels""" iactor = 0 actors2 = [] if make_node_labels and nnodes: mapper = actors[iactor].GetMapper() mygrid = mapper.GetInput() point_id_filter = get_ids_filter( mygrid, idsname='Ids_points', is_nids=True, is_eids=False) point_id_filter.SetFieldData(1) point_id_filter.SetPointIds(0) point_id_filter.FieldDataOn() label_actor = create_node_labels( point_id_filter, mygrid, gui.rend, label_size=self._annotation_size) #actors.append(label_actor) actors2.append(label_actor) iactor += 1 if make_element_labels and nelements: mapper = actors[iactor].GetMapper() mygrid = mapper.GetInput() element_id_filter = get_ids_filter( mygrid, idsname='Ids_cells', is_nids=False, is_eids=True) element_id_filter.SetFieldData(1) element_id_filter.SetCellIds(0) element_id_filter.FieldDataOn() # Create labels for cells cell_centers = vtk.vtkCellCenters() cell_centers.SetInputConnection(element_id_filter.GetOutputPort()) cell_mapper = vtk.vtkLabeledDataMapper() cell_mapper.SetInputConnection(cell_centers.GetOutputPort()) cell_mapper.SetLabelModeToLabelScalars() label_actor = vtk.vtkActor2D() label_actor.SetMapper(cell_mapper) #actors.append(label_actor) actors2.append(label_actor) iactor += 1 return actors2
def GetGeomCenterOfMass(mesh): cellcenter=vtk.vtkCellCenters() cellcenter.SetInputData(mesh) cellcenter.Update() cell_centeroutput=cellcenter.GetOutput() cell_centeroutput_num=cell_centeroutput.GetNumberOfPoints() center=[0.0,0.0,0.0] centerOfMassFilter =vtk.vtkCenterOfMass() centerOfMassFilter.SetInputData(mesh) centerOfMassFilter.SetUseScalarsAsWeights(0) centerOfMassFilter.Update() xx=centerOfMassFilter.GetCenter() return xx,cell_centeroutput
def surface_coordinate_systems(pd, cl=None): """ for each cell of polydata pd compute: - x, center # P, D - cx, normal # P, D - cy, longitudinal direction using centerline # P, D - cz, last vector for orthogonal coords # P, D """ # cell centers cell_centers = vtk.vtkCellCenters() cell_centers.SetInputData(pd) cell_centers.Update() vtk_x = cell_centers.GetOutput().GetPoints().GetData() x = nps.vtk_to_numpy(vtk_x) # P, D # cell normals cell_normals = vtk.vtkPolyDataNormals() cell_normals.SetInputData(pd) cell_normals.ComputeCellNormalsOn() cell_normals.ComputePointNormalsOff() cell_normals.ConsistencyOn() cell_normals.AutoOrientNormalsOn() cell_normals.Update() vtk_cn = cell_normals.GetOutput().GetCellData().GetNormals() cx = nps.vtk_to_numpy(vtk_cn) # P, D # direction of closest point on centerline if cl is None: cy=None cz=None else: apts = nps.vtk_to_numpy(cl.GetPoints().GetData()) # K, D adir = apts[+1:, :] - apts[:-1, :] # could get some smoothing adir = np.concatenate((adir, adir[-1:, :]), axis=0) closest_points_idx = _closest_points(x, apts) cy = adir[closest_points_idx, :] cy -= np.expand_dims(np.sum(cx * cy, axis=1)/np.sum(cx * cx, axis=1), 1) * cx # orthogonal cy /= np.expand_dims(np.sqrt((cy**2).sum(axis=1)), 1) # normal # cross-product cz = np.cross(cx, cy) return x, cx, cy, cz
def boundary_data(self, boundary, sort=None): """Return cell-center coordinates and data from a boundary. Parameters ---------- boundary : str The name of the boundary. sort : str Whether to sort the data along a coordinate. Use "x" and "y" to sort along x and y, respectively. Default is no sorting. Returns ------- Two ndarrays The coordinates of the boundary face centres. The corresponding data. """ blockData = self.extract_block_by_name(boundary) cCenters = vtk.vtkCellCenters() cCenters.SetInputData(blockData) cCenters.Update() points = np.array(dsa.WrapDataObject(cCenters.GetOutput()).Points) dataVTK = dsa.WrapDataObject(blockData).CellData data = {} for key in dataVTK.keys(): data[key] = np.array(dataVTK[key]) if sort is None: return points[:, [0, 1]], data elif sort == "x": ind = np.argsort(points[:, 0]) elif sort == "y": ind = np.argsort(points[:, 1]) points = points[ind] for key in data: data[key] = data[key][ind] return points[:, [0, 1]], data
def polyShowCellIds(ren,obj): #@c Show the cell ids of a given poly object in a renderer #@a ren: renderer #@a obj: object name if isinstance(obj,list): tag = "%s_%s" % (ren[0],obj[0]) elif isinstance(obj,str): tag = "%s_%s" % (ren[0],obj) else: raise ValueError("Argument type unsupported.") try: vis.polyUnshowCellIds(ren,obj) except: pass lmap = [None]*2 lmap[0] = "p_lmapc_"+tag labels = [None]*2 labels[0] = "p_labelsc_"+tag ids = [None]*2 ids[0] = "p_cellids_"+tag filt = vtk.vtkCellCenters() if isinstance(obj,list): filt.SetInputDataObject(obj[1]) else: vtkPoly = Repository.ExportToVtk(obj) filt.SetInputDataObject(vtkPoly) filt.Update() ids[1] = filt.GetOutput() lmap[1] = vtk.vtkLabeledDataMapper() lmap[1].SetLabelModeToLabelIds() lmap[1].SetInputDataObject(ids[1]) lmap[1].SetLabelFormat("%g") labels[1] = vtk.vtkActor2D() labels[1].SetMapper(lmap[1]) ren[1].AddActor2D(labels[1]) vis.render(ren) setattr(vis,lmap[0],lmap) setattr(vis,labels[0],labels) return
def RequestData(self, request, inInfoVec, outInfoVec): pdi = self.GetInputData(inInfoVec, 0, 0) pdo = self.GetOutputData(outInfoVec, 0) # Find cell centers filt = vtk.vtkCellCenters() filt.SetInputDataObject(pdi) filt.Update() # I use the dataset adapter/numpy interface because its easy centers = dsa.WrapDataObject(filt.GetOutput()).Points centers = interface.convertArray(centers) centers.SetName('Cell Centers') # Copy input data and add cell centers as tuple array pdo.DeepCopy(pdi) pdo.GetCellData().AddArray(centers) return 1
def mapPointDataToCellData(ugrid_data, ugrid_mesh, field_name, cell_length_ratio_for_radius=0.5, verbose=True): if (verbose): print '*** mapPointDataToCellData ***' nb_cells = ugrid_mesh.GetNumberOfCells() filter_cell_centers = vtk.vtkCellCenters() if (vtk.vtkVersion.GetVTKMajorVersion() >= 6): filter_cell_centers.SetInputData(ugrid_mesh) else: filter_cell_centers.SetInput(ugrid_mesh) filter_cell_centers.Update() pdata_mesh_cell_centers = filter_cell_centers.GetOutput() point_locator = vtk.vtkPointLocator() point_locator.SetDataSet(ugrid_data) point_locator.Update() nb_components = ugrid_data.GetPointData().GetArray(field_name).GetNumberOfComponents() farray_tensors = createFloatArray(field_name, nb_components, nb_cells) points_within_radius = vtk.vtkIdList() for num_cell in range(nb_cells): l = (ugrid_mesh.GetCell(num_cell).GetLength2())**(0.5) point_locator.FindPointsWithinRadius(l*cell_length_ratio_for_radius, pdata_mesh_cell_centers.GetPoint(num_cell), points_within_radius) #points_in_cell = findPointsInCell(ugrid_data.GetPoints(), ugrid_mesh.GetCell(num_cell)) if (points_within_radius.GetNumberOfIds()): tensor = sum([numpy.array(ugrid_data.GetPointData().GetArray(field_name).GetTuple(points_within_radius.GetId(num_id))) for num_id in range(points_within_radius.GetNumberOfIds())])/points_within_radius.GetNumberOfIds() else: tensor = [0]*nb_components farray_tensors.InsertTuple(num_cell, tensor) ugrid_mesh.GetCellData().AddArray(farray_tensors)
def VtkDibujaIdsElementos(ids): '''Dibuja las etiquetas de los elementos. Not implemented yet.''' cc = vtk.vtkCellCenters() vtk.SetInput(ids) # Centroides de las celdas. visCells = vtk.vtkSelectVisiblePoints() visCells.SetInput(cc) visCells.SetRenderer("renderer") visCells.SelectionWindowOff() #Create the mapper to display the cell ids. Specify the format to # use for the labels. Also create the associated actor. cellMapper = vtk.vtkLabeledShStrMapper cellMapper.SetInput(visCells) cellMapper.LabelTextProperty().SetColor(0, 0, 0.9) cellLabels = vtk.vtkActor2D() cellLabels.SetMapper(cellMapper)
def boundary_cell_data(self, boundary, sort=None): """Return cell-centre coordinates and data from cells adjacent to a specific boundary. Parameters ---------- boundary : str The name of the boundary. sort : {None, 'x', 'y'}, optional Whether to sort the data along a coordinate. Use 'x' and 'y' to sort along x and y, respectively. Default is no sorting. Returns ------- Two ndarrays """ selection = self.extract_boundary_cells(boundary) cCenters = vtk.vtkCellCenters() cCenters.SetInputData(selection.GetOutput()) cCenters.Update() points = np.array(dsa.WrapDataObject(cCenters.GetOutput()).Points) dataVTK = dsa.WrapDataObject(selection.GetOutput()).CellData data = {} for key in dataVTK.keys(): data[key] = np.array(dataVTK[key]) if sort is None: return points[:, [0, 1]], data elif sort == "x": ind = np.argsort(points[:, 0]) elif sort == "y": ind = np.argsort(points[:, 1]) points = points[ind] for key in data: data[key] = data[key][ind] return points[:, [0, 1]], data
def RequestData(self, request, inInfoVec, outInfoVec): pdi = self.GetInputData(inInfoVec, 0, 0) pdo = self.GetOutputData(outInfoVec, 0) # Find cell centers filt = vtk.vtkCellCenters() filt.SetInputDataObject(pdi) filt.Update() centers = dsa.WrapDataObject(filt.GetOutput()).Points # Get CellData wpdi = dsa.WrapDataObject(pdi) celldata = wpdi.CellData keys = celldata.keys() # Make poly data of Cell centers: pdo.DeepCopy(interface.pointsToPolyData(centers)) for i, name in enumerate(keys): pdo.GetPointData().AddArray(pdi.GetCellData().GetArray(name)) return 1
def copyATPFromRef(angle): print "Processing angle", angle, "..." # Read reference file. # Get Jplc double array from point data. referenceReader = vtk.vtkXMLPolyDataReader() referenceReader.SetFileName("quadMeshFullATPc4080_reference.vtp") referenceReader.Update() Jplc = referenceReader.GetOutput().GetCellData().GetArray("initialATP") # Read EC mesh. # Get centroids. ecMeshReader = vtk.vtkXMLPolyDataReader() ecMeshReader.SetFileName( os.path.join(str(angle), "quadMeshFullECc4080.vtp")) ecMeshReader.Update() ecSurface = ecMeshReader.GetOutput() ecCentroidFilter = vtk.vtkCellCenters() ecCentroidFilter.VertexCellsOn() ecCentroidFilter.SetInput(ecSurface) ecCentroidFilter.Update() ecCentroids = ecCentroidFilter.GetOutput() # Write EC mesh with Jplc as cell data. ecSurface.GetCellData().AddArray(Jplc) atpSurfaceWriter = vtk.vtkXMLPolyDataWriter() atpSurfaceWriter.SetInput(ecSurface) atpSurfaceWriter.SetFileName( os.path.join(str(angle), "quadMeshFullATPc4080_.vtp")) atpSurfaceWriter.Update() # Write EC centroids with Jpls as cell data. ecCentroids.GetCellData().AddArray(Jplc) atpPointsWriter = vtk.vtkXMLPolyDataWriter() atpPointsWriter.SetInput(ecCentroids) atpPointsWriter.SetFileName( os.path.join(str(angle), "quadMeshFullATPc4080.vtp")) print atpPointsWriter.GetFileName() atpPointsWriter.Update()
def __init__(self, fileName, clean=False, pointData=False): """ Create Case from file. Parameters ---------- fileName : str The file to be read in. Should be data in VTK format. clean : bool Whether to attempt to clean the data of redundant cells. """ self.fileName = fileName # Read in the data self._blockData = self.read(clean, pointData) # Compute the cell-centres self._cellCentres = vtk.vtkCellCenters() self._cellCentres.SetInputData(self._blockData.GetBlock(0)) self._cellCentres.Update() self._cellCentres =\ dsa.WrapDataObject(self._cellCentres.GetOutput()).GetPoints() self._cellCentres = np.array(self._cellCentres[:, :2]) self._vtkData = dsa.WrapDataObject(self._blockData.GetBlock(0)) self._boundaries = self._fill_boundary_list() self._bounds = self._vtkData.VTKObject.GetBounds()[:4] self._fields = self._vtkData.CellData.keys() plot_limits = self._compute_plot_limits() self._xlim = plot_limits[0] self._ylim = plot_limits[1] self._boundaryCellCoords, self._boundaryCellData = \ self._compute_boundary_cell_data()
def compute_cell_center(surf, append=False, key='cell_center'): """Compute center of cells (parametric center). Parameters ---------- surf : vtkPolyData or BSPolyData Input surface. append : bool, optional If True, append array to cell data attributes of input surface and return surface. Otherwise, only return array. Default is False. key : str, optional Array name to append to surface's cell data attributes. Only used if ``append == True``. Default is 'cell_center'. Returns ------- output : vtkPolyData, BSPolyData or ndarray Return ndarray if ``append == False``. Otherwise, return input surface with the new array. """ return serial_connect(surf, vtkCellCenters()).Points
def _transform(self, transform): """Transform the geometry according to a vtkTransform filter.""" # Transform the internal field filter = vtk.vtkTransformPolyDataFilter() filter.SetInputData(self.blockData.GetBlock(0)) filter.SetTransform(transform) filter.Update() self._blockData.SetBlock(0, filter.GetOutput()) # Transform boundary data i = 1 for boundary in self.boundaries: filter = vtk.vtkTransformPolyDataFilter() filter.SetTransform(transform) filter.SetInputData(self.blockData.GetBlock(i)) filter.Update() self.blockData.SetBlock(i, filter.GetOutput()) i += 1 # Update attuributes self._cellCentres = vtk.vtkCellCenters() self._cellCentres.SetInputData(self.blockData.GetBlock(0)) self._cellCentres.Update() self._cellCentres = \ dsa.WrapDataObject(self._cellCentres.GetOutput()).GetPoints() self._cellCentres = np.array(self._cellCentres[:, :2]) self._vtkData = dsa.WrapDataObject(self._blockData.GetBlock(0)) self._bounds = self._vtkData.VTKObject.GetBounds()[:4] plot_limits = self._compute_plot_limits() self._xlim = plot_limits[0] self._ylim = plot_limits[1] self._boundaryCellCoords, self._boundaryCellData = \ self._compute_boundary_cell_data()
def cell_center_points(self): """ Method for obtaining cell center points """ if self._cell_center_points is not None: return self._cell_center_points ccf = vtk.vtkCellCenters() ccf.SetInputData(self.output) ccf.VertexCellsOn() ccf.Update() self._cell_center_points = vtk_to_numpy( ccf.GetOutput().GetPoints().GetData()) if self.dim == 1: self.one_d_axis = self.one_d_axis self._cell_center_points = self._cell_center_points[:, self. one_d_axis] if self.dim == 2: self.plane = [0, 1, 2] self.plane.pop(self.two_d_planenormal) self._cell_center_points = np.delete(self._cell_center_points, self.two_d_planenormal, 1) return self._cell_center_points
def copyATPFromRef(angle): print "Processing angle", angle, "..." # Read reference file. # Get Jplc double array from point data. referenceReader = vtk.vtkXMLPolyDataReader() referenceReader.SetFileName("quadMeshFullATPc4080_reference.vtp") referenceReader.Update() Jplc = referenceReader.GetOutput().GetCellData().GetArray("initialATP") # Read EC mesh. # Get centroids. ecMeshReader = vtk.vtkXMLPolyDataReader() ecMeshReader.SetFileName(os.path.join(str(angle), "quadMeshFullECc4080.vtp")) ecMeshReader.Update() ecSurface = ecMeshReader.GetOutput() ecCentroidFilter = vtk.vtkCellCenters() ecCentroidFilter.VertexCellsOn() ecCentroidFilter.SetInput(ecSurface) ecCentroidFilter.Update() ecCentroids = ecCentroidFilter.GetOutput() # Write EC mesh with Jplc as cell data. ecSurface.GetCellData().AddArray(Jplc) atpSurfaceWriter = vtk.vtkXMLPolyDataWriter() atpSurfaceWriter.SetInput(ecSurface) atpSurfaceWriter.SetFileName(os.path.join(str(angle), "quadMeshFullATPc4080_.vtp")) atpSurfaceWriter.Update() # Write EC centroids with Jpls as cell data. ecCentroids.GetCellData().AddArray(Jplc) atpPointsWriter = vtk.vtkXMLPolyDataWriter() atpPointsWriter.SetInput(ecCentroids) atpPointsWriter.SetFileName(os.path.join(str(angle), "quadMeshFullATPc4080.vtp")) print atpPointsWriter.GetFileName() atpPointsWriter.Update()
def main(): # Read reference file. # Get Jplc double array from point data. referenceReader = vtk.vtkXMLPolyDataReader() referenceReader.SetFileName("quadMeshFullATPc4080_reference.vtp") referenceReader.Update() Jplc = referenceReader.GetOutput().GetCellData().GetArray("initialATP") # Read EC mesh. # Get centroids. ecMeshReader = vtk.vtkXMLPolyDataReader() ecMeshReader.SetFileName("quadMeshFullECc4080.vtp") ecMeshReader.Update() ecSurface = ecMeshReader.GetOutput() ecCentroidFilter = vtk.vtkCellCenters() ecCentroidFilter.VertexCellsOn() ecCentroidFilter.SetInput(ecSurface) ecCentroidFilter.Update() ecCentroids = ecCentroidFilter.GetOutput() # Write EC mesh with Jplc as cell data. # Write EC centroids with Jpls as cell data. ecSurface.GetCellData().AddArray(Jplc) atpSurfaceWriter = vtk.vtkXMLPolyDataWriter() atpSurfaceWriter.SetInput(ecSurface) atpSurfaceWriter.SetFileName("quadMeshFullATPc4080_.vtp") atpSurfaceWriter.Update() ecCentroids.GetCellData().AddArray(Jplc) atpPointsWriter = vtk.vtkXMLPolyDataWriter() atpPointsWriter.SetInput(ecCentroids) atpPointsWriter.SetFileName("quadMeshFullATPc4080.vtp") atpPointsWriter.Update()
def resample_to_2d_1d(pdi, pdo, geom): # geom_types=ns.vtk_to_numpy(geom.GetCellTypesArray()) geom_locations=ns.vtk_to_numpy(geom.GetCellLocationsArray()) geom_2d_id=np.where(geom_types==VTK_TRIANGLE)[0] n_2d_cells=geom_2d_id.size #print geom_2d_id geom_2d_locations=geom_locations[geom_2d_id] geom_1d_id=np.where(geom_types==VTK_LINE)[0] n_1d_cells=geom_1d_id.size #print geom_1d_id geom_1d_locations=geom_locations[geom_1d_id] # should check that there are both 2d and 1d elements other # similarly we should check that there are only triangles in the pdi # create a sampling dataset aux_dataset=vtk.vtkUnstructuredGrid() # compute centroids input_copy = geom.NewInstance() input_copy.UnRegister(None) input_copy.ShallowCopy(geom) geom_centers=vtk.vtkCellCenters() geom_centers.SetInputData(geom) geom_centers.Update() output=geom_centers.GetOutput() barycenters=ns.vtk_to_numpy(output.GetPoints().GetData()).reshape(-1,3) barycenters_2d=barycenters[geom_2d_id] #print barycenters_2d # shift right half of points barycenters_2d[:,0]=np.where(barycenters_2d[:,0]<0, barycenters_2d[:,0]+LEFT_SHIFT, barycenters_2d[:,0]+RIGHT_SHIFT) # compute 1d avarage points cell_data=ns.vtk_to_numpy(geom.GetCells().GetData()) grid = np.meshgrid( [0,1,2], geom_1d_locations ) grid = map(np.ravel, grid) cell_data_selection=grid[0]+grid[1] array_of_1d_cells=(cell_data[cell_data_selection]) assert(len(array_of_1d_cells)>0) geom_points_y=ns.vtk_to_numpy(geom.GetPoints().GetData())[:,1] x_points=np.array((0)) y_points=np.array((0)) # reference grid x=np.linspace(LEFT_SHIFT,RIGHT_SHIFT,AVERAGE_POINTS) y=np.linspace(0,1,AVERAGE_POINTS) ref_x, ref_y=map(np.ravel, np.meshgrid(x,y)) assert( np.all(array_of_1d_cells[0::3]==2) ) p0=geom_points_y[array_of_1d_cells[1::3]] p1=geom_points_y[array_of_1d_cells[2::3]] x_points=np.tile(ref_x, geom_1d_id.size) yy,y0=np.meshgrid(ref_y,p0) yy,y1=np.meshgrid(ref_y,p1) y_points=(y0*yy+y1*(1-yy)).ravel() assert(x_points.size==y_points.size) z_points=np.zeros(len(x_points)) points_1d=np.hstack(( x_points.reshape((-1,1)), y_points.reshape((-1,1)), z_points.reshape((-1,1)) )) #print points_1d all_points=append(barycenters_2d, points_1d) all_points.shape=(-1,3) # make a probe dataset points=vtk.vtkPoints() points.SetData(make_vtk_array(all_points, "points")) point_set=vtk.vtkUnstructuredGrid() point_set.SetPoints(points) probe=vtk.vtkProbeFilter() probe.SetSourceData(pdi) probe.SetInputData(point_set) probe.Update() out=probe.GetOutput() probe_data=out.GetPointData() # reconstruct element arrays pdo.DeepCopy(geometry) cell_data=pdo.GetCellData() for i_array in range(probe_data.GetNumberOfArrays()): # make interpolation array vtk_array=probe_data.GetArray(i_array) array_name=vtk_array.GetName() n_components=vtk_array.GetNumberOfComponents() n_tuples=vtk_array.GetNumberOfTuples() array=ns.vtk_to_numpy(vtk_array) array.shape=(n_tuples,n_components) new_array=np.zeros((pdo.GetNumberOfCells(),n_components), dtype=array.dtype) new_array[geom_2d_id,:]=array[0:n_2d_cells,:] array_1d=array[n_2d_cells:,:].reshape(n_1d_cells, AVERAGE_POINTS*AVERAGE_POINTS, n_components) new_array[geom_1d_id,:]=np.average(array_1d, axis=1) new_vtk_array=ns.numpy_to_vtk(new_array, deep=1) cell_data.AddArray( make_vtk_array(new_array, "interpol_"+vtk_array.GetName()) ) # compute difference array vtk_geometry_array=pdo.GetCellData().GetArray(array_name) if vtk_geometry_array: assert_eq(vtk_geometry_array.GetNumberOfComponents(), new_array.shape[1]) assert_eq(vtk_geometry_array.GetNumberOfTuples(), new_array.shape[0]) geometry_array=ns.vtk_to_numpy(vtk_geometry_array) geometry_array.shape=new_array.shape difference=geometry_array - new_array cell_data.AddArray( make_vtk_array(difference, "diff_"+vtk_array.GetName()) )
def _CreateSkeleton(self): """Create the structure of the output vtkUnstructuredGrid and a map from the index of a point in the extraction file to the corresponding cellId in the skeleton. This method should only be called if the extraction object this instance is working on has changed since the last time this method was called. """ input = self.GetUnstructuredGridInput() # Get the centres as these should match the extracted property positions centers = vtk.vtkCellCenters() if vtk.vtkVersion().GetVTKMajorVersion() <= 5: centers.SetInput( input ); else: centers.SetInputData( input ); #centers.SetInput(input) centers.Update() # Use this to find the cell ID for each point. locator = vtk.vtkOctreePointLocator() locator.SetDataSet(centers.GetOutput()) locator.BuildLocator() # Should be fine enough locator.SetTolerance(0.1 * self.Extracted.voxelSizeMetres) # Get the first set of extracted data from the file. We don't care # which as we only want to use the positions. extracted_positions = self.Extracted.GetByIndex(0).position nExtractedPoints = len(extracted_positions) # Make a list of the cell ids to keep; i.e. the cell in the input # (whole geometry) with ID cellIdsGmy[i] contains the point given by # extracted_positions[i] gmyCellIdsByInput = vtk.vtkIdTypeArray() gmyCellIdsByInput.SetNumberOfComponents(1) gmyCellIdsByInput.SetNumberOfTuples(nExtractedPoints) gmyCellIdsByInputNp = numpy_support.vtk_to_numpy(gmyCellIdsByInput) for i, point in enumerate(extracted_positions): # Get cell in geometry corresponding to the point cellId = locator.FindClosestPoint(point) if cellId == -1: raise ValueError("Can't find cell for point at " + str(point)) gmyCellIdsByInputNp[i] = cellId # Make an object to select only the cell ids we want selector = vtk.vtkSelectionNode() selector.SetFieldType(CELL) selector.SetContentType(INDICES) selector.SetSelectionList(gmyCellIdsByInput) # Make an object to hold the selector selectors = vtk.vtkSelection() selectors.AddNode(selector) # Perform the selection extractSelection = vtk.vtkExtractSelectedIds() if vtk.vtkVersion().GetVTKMajorVersion() <= 5: extractSelection.SetInput(0, input) extractSelection.SetInput(1, selectors) else: extractSelection.SetInputData(0, input) extractSelection.SetInputData(1, selectors) extractSelection.Update() gmyCellIdsByOutput = extractSelection.GetOutput().GetCellData().GetArray('vtkOriginalCellIds') gmyCellIdsByOutputNp = numpy_support.vtk_to_numpy(gmyCellIdsByOutput) self.OutputCellIdsByInputIndex = MatchCorresponding(gmyCellIdsByOutputNp,gmyCellIdsByInputNp) # Create the skeleton data object and only copy in the structure. self.Skeleton = vtk.vtkUnstructuredGrid() self.Skeleton.CopyStructure(extractSelection.GetOutput()) return
def getIWDSurjectMatrix(vtkDataSet1, vtkDataSet2, leafsize = 10, nrofNear = 9, eps=0, p=1.): """ Function to calculate and return a sparse matrix of surjection form vtkDataSet1 to vtkDataSet2 Input: vtkDataSet1 - vtk DataSet - Mesh with cells vtkDataSet2 - vtk DataSet - Mesh with cells Output: scipy sparce matrix - Weight inverse distance values """ # Import packages import numpy as np, SimPEG as simpeg, vtk import vtk.util.numpy_support as npsup from scipy.spatial import cKDTree as KDTree # Prep the matrices # Get cell centers ds1CC = vtk.vtkCellCenters() ds1CC.SetInputData(vtkDataSet1) ds1CC.Update() ds1CCpts = ds1CC.GetOutput() ds1Arr = npsup.vtk_to_numpy(ds1CCpts.GetPoints().GetData()) ds2CC = vtk.vtkCellCenters() ds2CC.SetInputData(vtkDataSet2) ds2CC.Update() ds2CCpts = ds2CC.GetOutput() ds2Arr = npsup.vtk_to_numpy(ds2CCpts.GetPoints().GetData()) # Use a inverse distance weighting of the cell centers # Based on this stack overflow. # http://stackoverflow.com/questions/3104781/inverse-distance-weighted-idw-interpolation-with-python # Build the KDtree KDtree = KDTree( ds1Arr, leafsize = leafsize ) # Calculate the distances and indexes distances, ixs = KDtree.query( ds2Arr, k=nrofNear, eps=eps ) iL = [] jL = [] valL = [] for nr,(dist, ix) in enumerate(zip( distances, ixs )): iL.append(nr*np.ones_like(ix)) jL.append(ix) if nrofNear == 1: # Only using one point valL.append(np.ones_like(ix)) elif dist[0] < 1e-10: # If points are the "same" valL.append(np.ones_like(ix)) else: # weight z s by 1/dist -- w = 1. / dist**p w /= np.sum(w) valL.append(w) # Return the matrix i = np.concatenate(iL) j = np.concatenate(jL) val = np.concatenate(valL) # Make the outMat = simpeg.sp.csr_matrix((val,(i,j)),shape=(vtkDataSet2.GetNumberOfCells(),vtkDataSet1.GetNumberOfCells()),dtype=float) return outMat
def BuildViewWithTag(self): if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 self.vmtkRenderer.RegisterScript(self) if self.Actor: self.vmtkRenderer.Renderer.RemoveActor(self.Actor) if self.ScalarBarActor: self.vmtkRenderer.Renderer.RemoveActor(self.ScalarBarActor) if self.Surface.GetPointData().GetArray(self.RegionTagArrayName) == None and self.Surface.GetCellData().GetArray(self.RegionTagArrayName) == None: self.PrintError('Error: no regiontagarray with name specified') elif self.Surface.GetPointData().GetArray(self.RegionTagArrayName) != None: regionTagArray = self.Surface.GetPointData().GetArray(self.RegionTagArrayName) for j in range (self.Surface.GetNumberOfPoints()): if regionTagArray.GetTuple1(j) not in self.TagSet: self.TagSet.append(regionTagArray.GetTuple1(j)) self.TagSet.sort() self.NumberOfRegions = len(self.TagSet) tagSetCopy = list(self.TagSet) labelPoints = vtk.vtkPoints() labelPoints.SetNumberOfPoints(len(self.TagSet)) point = [0.0,0.0,0.0] for j in range (self.Surface.GetNumberOfPoints()): item = regionTagArray.GetTuple1(j) if item in tagSetCopy: self.Surface.GetPoint(j, point) labelPoints.SetPoint(self.TagSet.index(item), point) tagSetCopy.remove(item) self.Surface.GetPointData().SetActiveScalars(self.RegionTagArrayName) elif self.Surface.GetCellData().GetArray(self.RegionTagArrayName) != None: regionTagArray = self.Surface.GetCellData().GetArray(self.RegionTagArrayName) for j in range (self.Surface.GetNumberOfCells()): if regionTagArray.GetTuple1(j) not in self.TagSet: self.TagSet.append(regionTagArray.GetTuple1(j)) self.TagSet.sort() self.NumberOfRegions = len(self.TagSet) tagSetCopy = list(self.TagSet) labelPoints = vtk.vtkPoints() labelPoints.SetNumberOfPoints(len(self.TagSet)) point = [0.0,0.0,0.0] cellCenters = vtk.vtkCellCenters() cellCenters.SetInput(self.Surface) cellCenters.Update() regionTagArrayCenters = cellCenters.GetOutput().GetPointData().GetArray(self.RegionTagArrayName) for j in range (cellCenters.GetOutput().GetNumberOfPoints()): item = regionTagArrayCenters.GetTuple1(j) if item in tagSetCopy: cellCenters.GetOutput().GetPoint(j, point) labelPoints.SetPoint(self.TagSet.index(item), point) tagSetCopy.remove(item) self.Surface.GetCellData().SetActiveScalars(self.RegionTagArrayName) labelPolyData = vtk.vtkPolyData() labelPolyData.SetPoints(labelPoints) labelPolyData.Update() labelArray = vtk.vtkIntArray() labelArray.SetNumberOfComponents(1) labelArray.SetNumberOfTuples(self.NumberOfRegions) labelArray.SetName('label') labelArray.FillComponent(0,0) labelPolyData.GetPointData().AddArray(labelArray) for item in self.TagSet: labelArray.SetTuple1(self.TagSet.index(item), item) labelPolyData.GetPointData().SetActiveScalars('label') labelsMapper = vtk.vtkLabeledDataMapper() labelsMapper.SetInput(labelPolyData) labelsMapper.SetLabelModeToLabelScalars() labelsMapper.GetLabelTextProperty().SetColor(1, 1, 1) labelsMapper.GetLabelTextProperty().SetFontSize(14) self.labelsActor = vtk.vtkActor2D() self.labelsActor.SetMapper(labelsMapper) self.vmtkRenderer.Renderer.AddActor(self.labelsActor) surfaceMapper = vtk.vtkPolyDataMapper() surfaceMapper.SetInput(self.Surface) surfaceMapper.ScalarVisibilityOn() surfaceMapper.SetScalarRange(self.TagSet[0], self.TagSet[self.NumberOfRegions-1]) self.Actor = vtk.vtkActor() self.Actor.SetMapper(surfaceMapper) self.Actor.GetProperty().SetOpacity(self.Opacity) self.Actor.GetProperty().SetLineWidth(self.LineWidth) if self.FlatInterpolation: self.Actor.GetProperty().SetInterpolationToFlat() self.SetSurfaceRepresentation(self.Representation) self.vmtkRenderer.Renderer.AddActor(self.Actor) self.vmtkRenderer.AddKeyBinding('w','Change surface representation.',self.RepresentationCallback) if self.Legend and self.Actor: self.ScalarBarActor = vtk.vtkScalarBarActor() self.ScalarBarActor.SetLookupTable(self.Actor.GetMapper().GetLookupTable()) self.ScalarBarActor.GetLabelTextProperty().ItalicOff() self.ScalarBarActor.GetLabelTextProperty().BoldOff() self.ScalarBarActor.GetLabelTextProperty().ShadowOff() ## self.ScalarBarActor.GetLabelTextProperty().SetColor(0.0,0.0,0.0) self.ScalarBarActor.SetLabelFormat('%.2f') self.ScalarBarActor.SetTitle(self.LegendTitle) self.vmtkRenderer.Renderer.AddActor(self.ScalarBarActor) if self.Display: self.vmtkRenderer.Render() ## self.vmtkRenderer.Renderer.RemoveActor(self.Actor) ## self.vmtkRenderer.Renderer.RemoveActor(self.ScalarBarActor) if self.OwnRenderer: self.vmtkRenderer.Deallocate()
def resample_to_2d_1d(pdi, pdi_frac, pdo, geom): # geom_types=ns.vtk_to_numpy(geom.GetCellTypesArray()) geom_locations=ns.vtk_to_numpy(geom.GetCellLocationsArray()) geom_2d_id=np.where(geom_types==VTK_TRIANGLE)[0] n_2d_cells=geom_2d_id.size #print geom_2d_id #geom_2d_locations=geom_locations[geom_2d_id] geom_1d_id=np.where(geom_types==VTK_LINE)[0] n_1d_cells=geom_1d_id.size #print geom_1d_id geom_1d_locations=geom_locations[geom_1d_id] # should check that there are both 2d and 1d elements other # similarly we should check that there are only triangles in the pdi # create a sampling dataset aux_dataset=vtk.vtkUnstructuredGrid() # compute centroids input_copy = geom.NewInstance() input_copy.UnRegister(None) input_copy.ShallowCopy(geom) geom_centers=vtk.vtkCellCenters() geom_centers.SetInputData(geom) geom_centers.Update() output=geom_centers.GetOutput() barycenters=ns.vtk_to_numpy(output.GetPoints().GetData()).reshape(-1,3) barycenters_2d=barycenters[geom_2d_id] #print barycenters_2d # shift right half of points barycenters_2d[:,0]=np.where(barycenters_2d[:,0]<0, barycenters_2d[:,0]-X_SHIFT_LEFT, barycenters_2d[:,0]+X_SHIFT_RIGHT) # compute 1d avarage points cell_data=ns.vtk_to_numpy(geom.GetCells().GetData()) grid = np.meshgrid( [0,1,2], geom_1d_locations ) grid = map(np.ravel, grid) cell_data_selection=grid[0]+grid[1] array_of_1d_cells=(cell_data[cell_data_selection]) assert(len(array_of_1d_cells)>0) geom_points_y=ns.vtk_to_numpy(geom.GetPoints().GetData())[:,1] x_points=np.array((0)) y_points=np.array((0)) # trapezoid rule """ def weights(N): return np.array([0.5] + (N-2)*[1.0] + [0.5]) average_weights=np.outer( weights(AVERAGE_POINTS_X), weights(AVERAGE_POINTS_Y)).flatten() # reference grid x=np.linspace(-X_SHIFT_LEFT, X_SHIFT_RIGHT, AVERAGE_POINTS_X) y=np.linspace(0,1,AVERAGE_POINTS_Y) """ def weights(N): # trapezoidal weights return np.array([0.5] + (N-2)*[1.0] + [0.5]) # midpoint rule in both directions (avoid problems at boundary) average_weights=np.outer( np.ones(AVERAGE_POINTS_Y), np.ones(AVERAGE_POINTS_X) ).flatten() # reference grid N=float(AVERAGE_POINTS_X) dx=(X_SHIFT_RIGHT + X_SHIFT_LEFT)/N x=np.linspace(-X_SHIFT_LEFT+dx/2, X_SHIFT_RIGHT-dx/2,N) N=float(AVERAGE_POINTS_Y) y=np.linspace(1/(2*N),1-1/(2*N),N) #print "weights: ", average_weights #print "y: ", y ref_x, ref_y=map(np.ravel, np.meshgrid(x,y)) #print "y: ", ref_y #print "x: ", ref_x assert( np.all(array_of_1d_cells[0::3]==2) ) p0=geom_points_y[array_of_1d_cells[1::3]] p1=geom_points_y[array_of_1d_cells[2::3]] x_points=np.tile(ref_x, geom_1d_id.size) yy,y0=np.meshgrid(ref_y,p0) yy,y1=np.meshgrid(ref_y,p1) y_points=(y0*yy+y1*(1-yy)).ravel() #print average_weights.size, x_points.size, y_points.size assert(x_points.size==y_points.size) assert(AVERAGE_POINTS_X*AVERAGE_POINTS_Y==average_weights.size) z_points=np.zeros(len(x_points)) points_1d=np.hstack(( x_points.reshape((-1,1)), y_points.reshape((-1,1)), z_points.reshape((-1,1)) )) #print points_1d barycenters_2d.shape=(-1,3) points_1d.shape=(-1,3) #all_points=append(barycenters_2d, points_1d) #all_points.shape=(-1,3) # make a dataset # probe on fracture dataset points_f=vtk.vtkPoints() points_f.SetData(ns.numpy_to_vtk(points_1d, deep=1)) point_set_f=vtk.vtkUnstructuredGrid() point_set_f.SetPoints(points_f) probe_f=vtk.vtkProbeFilter() probe_f.SetSourceData(pdi_frac) probe_f.SetInputData(point_set_f) probe_f.Update() out_f=probe_f.GetOutput() probe_data_f=out_f.GetPointData() # probe on continuum dataset points=vtk.vtkPoints() points.SetData(ns.numpy_to_vtk(barycenters_2d, deep=1)) point_set=vtk.vtkUnstructuredGrid() point_set.SetPoints(points) probe=vtk.vtkProbeFilter() probe.SetSourceData(pdi) probe.SetInputData(point_set) probe.Update() out=probe.GetOutput() probe_data=out.GetPointData() # reconstruct element arrays pdo.DeepCopy(geometry) cell_data=pdo.GetCellData() for i_array in range(cell_data.GetNumberOfArrays()): cell_data.RemoveArray(i_array) point_data=pdo.GetPointData() for i_array in range(point_data.GetNumberOfArrays()): point_data.RemoveArray(i_array) assert(probe_data.GetNumberOfArrays() == probe_data_f.GetNumberOfArrays() ) for i_array in range(probe_data.GetNumberOfArrays()): vtk_array=probe_data.GetArray(i_array) array=ns.vtk_to_numpy(vtk_array) n_components=vtk_array.GetNumberOfComponents() n_tuples=vtk_array.GetNumberOfTuples() assert(n_tuples == n_2d_cells) array.shape=(n_tuples,n_components) vtk_array_f=probe_data_f.GetArray(i_array) array_f=ns.vtk_to_numpy(vtk_array_f) n_components_f=vtk_array_f.GetNumberOfComponents() n_tuples_f=vtk_array_f.GetNumberOfTuples() assert(n_components == n_components_f) assert( n_1d_cells*len(average_weights) == n_tuples_f) assert( array.dtype == array_f.dtype) array_f.shape=(n_1d_cells, len(average_weights), n_components) #print vtk_array.GetName() #print array_f.shape #print array_f new_array=np.zeros((pdo.GetNumberOfCells(),n_components), dtype=array.dtype) new_array[geom_2d_id,:]=array new_array[geom_1d_id,:]=np.average(array_f, weights=average_weights, axis=1) new_vtk_array=ns.numpy_to_vtk(new_array, deep=1) new_vtk_array.SetName(vtk_array.GetName()) cell_data.AddArray(new_vtk_array) #ids=ns.numpy_to_vtk(np.arange(n_2d_cells+n_1d_cells), deep=1) #ids.SetName('ids') #cell_data.AddArray(ids) '''
def Execute(self): if not self.Centerlines: self.PrintError("Error: No input centerlines.") return if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 self.vmtkRenderer.RegisterScript(self) if self.CellDataArrayName: cellCenters = vtk.vtkCellCenters() cellCenters.SetInputData(self.Centerlines) cellCenters.Update() cellCenters.GetOutput().GetPointData().SetActiveScalars(self.CellDataArrayName) labelsMapper = vtk.vtkLabeledDataMapper() labelsMapper.SetInputConnection(cellCenters.GetOutputPort()) labelsMapper.SetLabelModeToLabelScalars() labelsActor = vtk.vtkActor2D() labelsActor.SetMapper(labelsMapper) self.vmtkRenderer.Renderer.AddActor(labelsActor) centerlineMapper = vtk.vtkPolyDataMapper() centerlineMapper.SetInputData(self.Centerlines) if self.CellDataArrayName and not self.PointDataArrayName: centerlineMapper.ScalarVisibilityOn() centerlineMapper.SetScalarModeToUseCellData() self.Centerlines.GetCellData().SetActiveScalars(self.CellDataArrayName) centerlineMapper.SetScalarRange(self.Centerlines.GetCellData().GetScalars().GetRange(0)) elif self.PointDataArrayName: centerlineMapper.ScalarVisibilityOn() centerlineMapper.SetScalarModeToUsePointData() self.Centerlines.GetPointData().SetActiveScalars(self.PointDataArrayName) centerlineMapper.SetScalarRange(self.Centerlines.GetPointData().GetScalars().GetRange(0)) else: centerlineMapper.ScalarVisibilityOff() if self.ColorMap == "grayscale": lut = centerlineMapper.GetLookupTable() lut.SetNumberOfTableValues(self.NumberOfColors) lut.SetValueRange(0.0, 1.0) lut.SetSaturationRange(0.0, 0.0) lut.Build() centerlineMapper.SetLookupTable(lut) if self.ColorMap == "rainbow": lut = centerlineMapper.GetLookupTable() lut.SetHueRange(0.666667, 0.0) lut.SetSaturationRange(0.75, 0.75) lut.SetValueRange(1.0, 1.0) lut.SetAlphaRange(1.0, 1.0) lut.SetNumberOfColors(self.NumberOfColors) lut.Build() centerlineMapper.SetLookupTable(lut) if self.ColorMap == "blackbody": lut = centerlineMapper.GetLookupTable() lut.SetNumberOfTableValues(self.NumberOfColors) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.SetColorSpaceToRGB() colorTransferFunction.AddRGBPoint(0, 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(0.4, 0.901961, 0.0, 0.0) colorTransferFunction.AddRGBPoint(0.8, 0.901961, 0.901961, 0.0) colorTransferFunction.AddRGBPoint(1.0, 1.0, 1.0, 1.0) for ii, ss in enumerate([float(xx) / float(self.NumberOfColors) for xx in range(self.NumberOfColors)]): cc = colorTransferFunction.GetColor(ss) lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0) lut.Build() centerlineMapper.SetLookupTable(lut) if self.ColorMap == "cooltowarm": lut = centerlineMapper.GetLookupTable() lut.SetNumberOfTableValues(self.NumberOfColors) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.SetColorSpaceToDiverging() colorTransferFunction.AddRGBPoint(0, 0.231373, 0.298039, 0.752941) colorTransferFunction.AddRGBPoint(0.5, 0.865003, 0.865003, 0.865003) colorTransferFunction.AddRGBPoint(1.0, 0.705882, 0.0156863, 0.14902) for ii, ss in enumerate([float(xx) / float(self.NumberOfColors) for xx in range(self.NumberOfColors)]): cc = colorTransferFunction.GetColor(ss) lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0) lut.Build() centerlineMapper.SetLookupTable(lut) centerlineActor = vtk.vtkActor() centerlineActor.SetMapper(centerlineMapper) self.vmtkRenderer.Renderer.AddActor(centerlineActor) scalarBarActor = None if self.Legend and centerlineActor and self.PointDataArrayName: scalarBarActor = vtk.vtkScalarBarActor() scalarBarActor.SetLookupTable(centerlineActor.GetMapper().GetLookupTable()) scalarBarActor.GetLabelTextProperty().ItalicOff() scalarBarActor.GetLabelTextProperty().BoldOff() scalarBarActor.GetLabelTextProperty().ShadowOff() scalarBarActor.SetLabelFormat("%.2f") scalarBarActor.SetTitle(self.PointDataArrayName) self.vmtkRenderer.Renderer.AddActor(scalarBarActor) if self.Display: self.vmtkRenderer.Render() if self.OwnRenderer: self.vmtkRenderer.Deallocate()
def mri_projected_segmentation(tm, hd5): if segmented_name not in [MRI_SEGMENTED, MRI_LAX_SEGMENTED]: raise ValueError( f'{segmented_name} is recognized neither as SAX nor LAX segmentation', ) cine_segmented_grids = _mri_hd5_to_structured_grids( hd5, segmented_name, ) cine_to_segment_grids = _mri_hd5_to_structured_grids( hd5, to_segment_name, ) tensor = np.zeros(tm.shape, dtype=np.float32) # Loop through segmentations and datasets for ds_i, ds_segmented in enumerate(cine_segmented_grids): for ds_j, ds_to_segment in enumerate(cine_to_segment_grids): dims = ds_to_segment.GetDimensions() pts = vtk.util.numpy_support.vtk_to_numpy( ds_to_segment.GetPoints().GetData(), ) npts_per_slice = dims[0] * dims[1] ncells_per_slice = (dims[0] - 1) * (dims[1] - 1) n_orientation = (pts[npts_per_slice] - pts[0]) n_orientation /= np.linalg.norm(n_orientation) cell_centers = vtk.vtkCellCenters() cell_centers.SetInputData(ds_to_segment) cell_centers.Update() cell_pts = vtk.util.numpy_support.vtk_to_numpy( cell_centers.GetOutput().GetPoints().GetData(), ) # Loop through dataset slices for s in range(dims[2] - 1): slice_center = np.mean( pts[s * npts_per_slice:(s + 2) * npts_per_slice], axis=0, ) slice_cell_pts = cell_pts[s * ncells_per_slice:(s + 1) * ncells_per_slice] slice_segmented = _cut_through_plane( ds_segmented, slice_center, n_orientation, ) map_to_segmented = _map_points_to_cells( slice_cell_pts, slice_segmented, ) # Loop through time for t in range(MRI_FRAMES): arr_name = f'{segmented_name}_{t}' segmented_arr = vtk.util.numpy_support.vtk_to_numpy( slice_segmented.GetCellData().GetArray(arr_name), ) projected_arr = segmented_arr[map_to_segmented] if len(tm.shape) == 3: tensor[:, :, t] = np.maximum( tensor[:, :, t], projected_arr.reshape( tm.shape[0], tm.shape[1], ), ) elif len(tm.shape) == 4: tensor[:, :, s, t] = np.maximum( tensor[:, :, s, t], projected_arr.reshape( tm.shape[0], tm.shape[1], ), ) if save_path: writer_segmented = vtk.vtkXMLPolyDataWriter() writer_segmented.SetInputData(slice_segmented) writer_segmented.SetFileName( os.path.join( save_path, f'{tm.name}_segmented_{ds_i}_{ds_j}_{s}.vtp', ), ) writer_segmented.Update() return tensor
def _Execute(self): """Private method that actually does the reading. Called by the VTK API. """ input = self.GetUnstructuredGridInput() # Load the snapshot data snap = HemeLbSnapshot(self.FileName) # Get the centres as these should match the snapshot positions centers = vtk.vtkCellCenters() centers.SetInput(input) centers.Update() # Use this to find the cell ID for each point. locator = vtk.vtkOctreePointLocator() locator.SetDataSet(centers.GetOutput()) locator.BuildLocator() # Should be fine enough locator.SetTolerance(0.1 * snap.voxel_size) # Copy the structure to output. grid = self.GetUnstructuredGridOutput() grid.ShallowCopy(input) nCells = len(snap) # Basic sanity check that we probably have matching geometry and # snapshot. if grid.GetNumberOfCells() != nCells: raise ValueError('Geometry ({}) and snapshot ({}) have different ' 'cell counts'.format(grid.GetNumberOfCells(), len(snap))) # Velocity field velocity = vtk.vtkDoubleArray() velocity.SetNumberOfComponents(3) velocity.SetNumberOfTuples(nCells) velocity.SetName('velocity') # Pressure pressure = vtk.vtkDoubleArray() pressure.SetNumberOfComponents(1) pressure.SetNumberOfTuples(nCells) pressure.SetName('pressure') # Stress stress = vtk.vtkDoubleArray() stress.SetNumberOfComponents(1) stress.SetNumberOfTuples(nCells) stress.SetName('stress') # The hard work bit. for pt in snap: # Get cell in geometry corresponding to the point cellId = locator.FindClosestPoint(pt.position) if cellId == -1: raise ValueError("Can't find cell for point at " + str(pt.position)) # Copy the data into the VTK structure velocity.SetTuple3(cellId, *pt.velocity) pressure.SetTuple1(cellId, pt.pressure) stress.SetTuple1(cellId, pt.stress) continue # Add the arrays to the output grid.GetCellData().AddArray(velocity) grid.GetCellData().AddArray(pressure) grid.GetCellData().AddArray(stress) return
def on_show(self): """show the highlight""" passed = self.on_validate() self.parent().mouse_actions.get_grid_selected(self.model_name) if passed and self.win_parent is not None: nodes, unused_flag1 = check_patran_syntax(self.nodes_edit, pound=self._nodes_pound) elements, unused_flag2 = check_patran_syntax( self.elements_edit, pound=self._elements_pound) if len(nodes) == 0 and len(elements) == 0: return False nodes_filtered = np.intersect1d(self.nodes, nodes) elements_filtered = np.intersect1d(self.elements, elements) nnodes = len(nodes_filtered) nelements = len(elements_filtered) if nnodes == 0 and nelements == 0: return False self.on_remove_actors() gui = self.parent() mouse_actions = gui.mouse_actions grid = mouse_actions.get_grid_selected(self.model_name) actors = create_highlighted_actors(gui, grid, all_nodes=self.nodes, nodes=nodes_filtered, set_node_scalars=True, all_elements=self.elements, elements=elements_filtered, set_element_scalars=True) iactor = 0 make_element_labels = True make_node_labels = True if make_node_labels and nnodes: mapper = actors[iactor].GetMapper() mygrid = mapper.GetInput() point_id_filter = get_ids_filter(mygrid, idsname='Ids_points', is_nids=True, is_eids=False) point_id_filter.SetFieldData(1) point_id_filter.SetPointIds(0) point_id_filter.FieldDataOn() label_actor = create_node_labels(point_id_filter, mygrid, gui.rend, label_size=self._label_size) actors.append(label_actor) iactor += 1 if make_element_labels and nelements: mapper = actors[iactor].GetMapper() mygrid = mapper.GetInput() element_id_filter = get_ids_filter(mygrid, idsname='Ids_cells', is_nids=False, is_eids=True) element_id_filter.SetFieldData(1) element_id_filter.SetCellIds(0) element_id_filter.FieldDataOn() # Create labels for cells cell_centers = vtk.vtkCellCenters() cell_centers.SetInputConnection( element_id_filter.GetOutputPort()) cell_mapper = vtk.vtkLabeledDataMapper() cell_mapper.SetInputConnection(cell_centers.GetOutputPort()) cell_mapper.SetLabelModeToLabelScalars() label_actor = vtk.vtkActor2D() label_actor.SetMapper(cell_mapper) actors.append(label_actor) iactor += 1 if actors: add_actors_to_gui(gui, actors, render=True) self.actors = actors return passed
def Execute(self): if not self.Network: self.Network = vtk.vtkPolyData() networkPoints = vtk.vtkPoints() networkLines = vtk.vtkCellArray() radiusArray = vtk.vtkDoubleArray() radiusArray.SetName(self.RadiusArrayName) self.Network.SetPoints(networkPoints) self.Network.SetLines(networkLines) self.Network.GetPointData().AddArray(radiusArray) if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 self.vmtkRenderer.ExitAfterTextInputMode = False self.vmtkRenderer.RegisterScript(self) if self.Image and (not self.PlaneWidgetX or not self.PlaneWidgetY or not self.PlaneWidgetZ): imageViewer = vmtkimageviewer.vmtkImageViewer() imageViewer.Image = self.Image imageViewer.vmtkRenderer = self.vmtkRenderer imageViewer.Display = 0 imageViewer.Execute() self.PlaneWidgetX = imageViewer.PlaneWidgetX self.PlaneWidgetY = imageViewer.PlaneWidgetY self.PlaneWidgetZ = imageViewer.PlaneWidgetZ if self.Image: spacing = self.Image.GetSpacing() self.CurrentRadius = min(spacing) if self.UseActiveTubes and not self.FeatureImage: imageFeatures = vmtkimagefeatures.vmtkImageFeatures() imageFeatures.Image = self.Image imageFeatures.FeatureImageType = 'vtkgradient' imageFeatures.Execute() self.FeatureImage = imageFeatures.FeatureImage self.NetworkRadiusArray = self.Network.GetPointData().GetArray(self.RadiusArrayName) self.Network.GetPointData().SetActiveScalars(self.RadiusArrayName) networkMapper = vtk.vtkPolyDataMapper() networkMapper.SetInputData(self.Network) networkMapper.SetScalarModeToUseCellData() self.NetworkActor = vtk.vtkActor() self.NetworkActor.SetMapper(networkMapper) self.vmtkRenderer.Renderer.AddActor(self.NetworkActor) self.NetworkTube = vtk.vtkTubeFilter() self.NetworkTube.SetInputData(self.Network) self.NetworkTube.SetVaryRadiusToVaryRadiusByAbsoluteScalar() self.NetworkTube.SetNumberOfSides(20) networkTubeMapper = vtk.vtkPolyDataMapper() networkTubeMapper.SetInputConnection(self.NetworkTube.GetOutputPort()) networkTubeMapper.ScalarVisibilityOff() networkTubeActor = vtk.vtkActor() networkTubeActor.SetMapper(networkTubeMapper) networkTubeActor.PickableOff() networkTubeActor.GetProperty().SetOpacity(0.2) self.vmtkRenderer.Renderer.AddActor(networkTubeActor) self.Selection = vtk.vtkPolyData() self.SelectionPoints = vtk.vtkPoints() self.SelectionRadiusArray = vtk.vtkDoubleArray() self.SelectionRadiusArray.SetName(self.RadiusArrayName) self.Selection.SetPoints(self.SelectionPoints) self.Selection.GetPointData().AddArray(self.SelectionRadiusArray) self.Selection.GetPointData().SetActiveScalars(self.RadiusArrayName) glyphs = vtk.vtkGlyph3D() glyphSource = vtk.vtkSphereSource() glyphSource.SetRadius(1.0) glyphSource.SetThetaResolution(20) glyphSource.SetPhiResolution(20) glyphs.SetInputData(self.Selection) glyphs.SetSourceConnection(glyphSource.GetOutputPort()) glyphs.SetScaleModeToScaleByScalar() glyphs.SetScaleFactor(1.0) selectionMapper = vtk.vtkPolyDataMapper() selectionMapper.SetInputConnection(glyphs.GetOutputPort()) self.SelectionActor = vtk.vtkActor() self.SelectionActor.SetMapper(selectionMapper) self.SelectionActor.GetProperty().SetColor(1.0,0.0,0.0) self.SelectionActor.GetProperty().SetOpacity(0.5) self.SelectionActor.PickableOff() self.vmtkRenderer.Renderer.AddActor(self.SelectionActor) self.ActiveSegmentSeeds = vtk.vtkPolyData() self.ActiveSegmentSeedsPoints = vtk.vtkPoints() self.ActiveSegmentSeedsRadiusArray = vtk.vtkDoubleArray() self.ActiveSegmentSeedsRadiusArray.SetName(self.RadiusArrayName) self.ActiveSegmentSeeds.SetPoints(self.ActiveSegmentSeedsPoints) self.ActiveSegmentSeeds.GetPointData().AddArray(self.ActiveSegmentSeedsRadiusArray) self.ActiveSegmentSeeds.GetPointData().SetActiveScalars(self.RadiusArrayName) activeSegmentSeedsGlyphs = vtk.vtkGlyph3D() activeSegmentSeedsGlyphSource = vtk.vtkSphereSource() activeSegmentSeedsGlyphSource.SetRadius(1.0) activeSegmentSeedsGlyphSource.SetThetaResolution(20) activeSegmentSeedsGlyphSource.SetPhiResolution(20) activeSegmentSeedsGlyphs.SetInputData(self.ActiveSegmentSeeds) activeSegmentSeedsGlyphs.SetSourceConnection(activeSegmentSeedsGlyphSource.GetOutputPort()) activeSegmentSeedsGlyphs.SetScaleModeToScaleByScalar() activeSegmentSeedsGlyphs.SetScaleFactor(1.0) activeSegmentSeedsMapper = vtk.vtkPolyDataMapper() activeSegmentSeedsMapper.SetInputConnection(activeSegmentSeedsGlyphs.GetOutputPort()) activeSegmentSeedsMapper.ScalarVisibilityOff() self.ActiveSegmentSeedsActor = vtk.vtkActor() self.ActiveSegmentSeedsActor.SetMapper(activeSegmentSeedsMapper) self.ActiveSegmentSeedsActor.GetProperty().SetColor(1.0,0.0,0.0) self.ActiveSegmentSeedsActor.GetProperty().SetOpacity(0.5) self.ActiveSegmentSeedsActor.PickableOff() self.vmtkRenderer.Renderer.AddActor(self.ActiveSegmentSeedsActor) self.ActiveSegment = vtk.vtkPolyData() self.ActiveSegmentPoints = vtk.vtkPoints() self.ActiveSegmentCellArray = vtk.vtkCellArray() self.ActiveSegmentRadiusArray = vtk.vtkDoubleArray() self.ActiveSegmentRadiusArray.SetName(self.RadiusArrayName) self.ActiveSegment.SetPoints(self.ActiveSegmentPoints) self.ActiveSegment.SetLines(self.ActiveSegmentCellArray) self.ActiveSegment.GetPointData().AddArray(self.ActiveSegmentRadiusArray) self.ActiveSegment.GetPointData().SetActiveScalars(self.RadiusArrayName) activeSegmentMapper = vtk.vtkPolyDataMapper() activeSegmentMapper.ScalarVisibilityOff() if self.SplineInterpolation and self.Image != None: splineFilter = vtk.vtkSplineFilter() splineFilter.SetInputData(self.ActiveSegment) splineFilter.SetSubdivideToLength() splineFilter.SetLength(2.0*min(self.Image.GetSpacing())) activeSegmentMapper.SetInputConnection(splineFilter.GetOutputPort()) else: activeSegmentMapper.SetInputData(self.ActiveSegment) self.ActiveSegmentActor = vtk.vtkActor() self.ActiveSegmentActor.SetMapper(activeSegmentMapper) self.ActiveSegmentActor.GetProperty().SetColor(1.0,1.0,1.0) self.ActiveSegmentActor.GetProperty().SetLineWidth(3.0) self.ActiveSegmentActor.PickableOff() self.vmtkRenderer.Renderer.AddActor(self.ActiveSegmentActor) activeTube = vtk.vtkTubeFilter() activeTube.SetInputConnection(activeSegmentMapper.GetInputPort()) activeTube.SetVaryRadiusToVaryRadiusByAbsoluteScalar() activeTube.SetNumberOfSides(20) activeTubeMapper = vtk.vtkPolyDataMapper() activeTubeMapper.SetInputConnection(activeTube.GetOutputPort()) activeTubeMapper.ScalarVisibilityOff() activeTubeActor = vtk.vtkActor() activeTubeActor.SetMapper(activeTubeMapper) activeTubeActor.PickableOff() activeTubeActor.GetProperty().SetOpacity(0.6) self.vmtkRenderer.Renderer.AddActor(activeTubeActor) self.NetworkLabelsArray = vtk.vtkStringArray.SafeDownCast(self.Network.GetCellData().GetAbstractArray(self.LabelsArrayName)) if not self.NetworkLabelsArray: self.NetworkLabelsArray = vtk.vtkStringArray() self.NetworkLabelsArray.SetName(self.LabelsArrayName) self.NetworkLabelsArray.SetNumberOfValues(self.Network.GetNumberOfCells()) for i in range(self.Network.GetNumberOfCells()): self.NetworkLabelsArray.SetValue(i,'') self.Network.GetCellData().AddArray(self.NetworkLabelsArray) self.CellCenters = vtk.vtkCellCenters() self.CellCenters.SetInputData(self.Network) self.CellCenters.VertexCellsOff() self.CellCenters.Update() labeledMapper = vtk.vtkLabeledDataMapper() labeledMapper.SetInputConnection(self.CellCenters.GetOutputPort()) labeledMapper.SetLabelModeToLabelFieldData() labeledMapper.SetFieldDataName(self.LabelsArrayName) labeledMapper.GetLabelTextProperty().SetFontFamilyToArial() labeledMapper.GetLabelTextProperty().BoldOff() labeledMapper.GetLabelTextProperty().ItalicOff() labeledMapper.GetLabelTextProperty().ShadowOff() self.LabelsActor = vtk.vtkActor2D() self.LabelsActor.SetMapper(labeledMapper) self.LabelsActor.VisibilityOff() self.vmtkRenderer.Renderer.AddActor(self.LabelsActor) self.CellPicker = vtk.vtkCellPicker() self.CellPicker.SetTolerance(1E-2) self.CellPicker.InitializePickList() self.CellPicker.AddPickList(self.NetworkActor) self.CellPicker.PickFromListOn() self.vmtkRenderer.AddKeyBinding('a','Add mode.',self.AddCallback) self.vmtkRenderer.AddKeyBinding('d','Delete mode.',self.DeleteCallback) self.vmtkRenderer.AddKeyBinding('m','Merge mode.',self.MergeCallback) self.vmtkRenderer.AddKeyBinding('s','Split mode.',self.SplitCallback) self.vmtkRenderer.AddKeyBinding('l','Label mode.',self.LabelCallback) self.vmtkRenderer.AddKeyBinding('Tab','Show labels.',self.ShowLabelCallback) self.vmtkRenderer.RenderWindowInteractor.AddObserver("KeyReleaseEvent", self.KeyReleaseCallback) self.vmtkRenderer.RenderWindowInteractor.AddObserver("LeftButtonPressEvent", self.LeftButtonPressCallback) self.vmtkRenderer.RenderWindowInteractor.AddObserver("MouseMoveEvent", self.MouseMoveCallback) if self.PlaneWidgetX: self.PlaneWidgetX.UseContinuousCursorOn() self.PlaneWidgetX.AddObserver("StartInteractionEvent", self.PlaneStartInteractionCallback) if self.PlaneWidgetY: self.PlaneWidgetY.UseContinuousCursorOn() self.PlaneWidgetY.AddObserver("StartInteractionEvent", self.PlaneStartInteractionCallback) if self.PlaneWidgetZ: self.PlaneWidgetZ.UseContinuousCursorOn() self.PlaneWidgetZ.AddObserver("StartInteractionEvent", self.PlaneStartInteractionCallback) self.FirstRender() self.Surface = self.NetworkTube.GetOutput() if self.OwnRenderer: self.vmtkRenderer.Deallocate()
extr.RemoveAllCellTypes() extr.AddCellType(vtk.VTK_TETRA) extr.Update() print("\tNumber of tets: {0}".format(extr.GetOutput().GetNumberOfCells())) if extr.GetOutput().GetNumberOfCells() != 5*res*res*res: error = 1 extr.RemoveAllCellTypes() extr.AddCellType(vtk.VTK_VOXEL) extr.Update() print("\tNumber of voxels: {0}".format(extr.GetOutput().GetNumberOfCells())) if extr.GetOutput().GetNumberOfCells() != res*res*res: error = 1 # Now construct polydata as a conglomerate of verts, lines, polys centers = vtk.vtkCellCenters() centers.SetInputConnection(sample.GetOutputPort()) centers.VertexCellsOn() edges = vtk.vtkExtractEdges() edges.SetInputConnection(sample.GetOutputPort()) polys = vtk.vtkGeometryFilter() polys.SetInputConnection(sample.GetOutputPort()) appendP = vtk.vtkAppendPolyData() appendP.AddInputConnection(centers.GetOutputPort()) appendP.AddInputConnection(edges.GetOutputPort()) appendP.AddInputConnection(polys.GetOutputPort()) appendP.Update()
visPts.SetInputConnection(ids.GetOutputPort()) visPts.SetRenderer(ren) visPts.SelectionWindowOn() visPts.SetSelection(xmin, xmin + xLength, ymin, ymin + yLength) # Create the mapper to display the point ids. Specify the format to # use for the labels. Also create the associated actor. ldm = vtk.vtkLabeledDataMapper() # ldm.SetLabelFormat("%g") ldm.SetInputConnection(visPts.GetOutputPort()) ldm.SetLabelModeToLabelFieldData() pointLabels = vtk.vtkActor2D() pointLabels.SetMapper(ldm) # Create labels for cells cc = vtk.vtkCellCenters() cc.SetInputConnection(ids.GetOutputPort()) visCells = vtk.vtkSelectVisiblePoints() visCells.SetInputConnection(cc.GetOutputPort()) visCells.SetRenderer(ren) visCells.SelectionWindowOn() visCells.SetSelection(xmin, xmin + xLength, ymin, ymin + yLength) # Create the mapper to display the cell ids. Specify the format to # use for the labels. Also create the associated actor. cellMapper = vtk.vtkLabeledDataMapper() cellMapper.SetInputConnection(visCells.GetOutputPort()) # cellMapper.SetLabelFormat("%g") cellMapper.SetLabelModeToLabelFieldData() cellMapper.GetLabelTextProperty().SetColor(0, 1, 0) cellLabels = vtk.vtkActor2D()
def GenCurvatureCoupling(programArguments): ''' programArguments: ini file containing model parameters''' # Load relevant parameters from ini file conf = ConfigObj(programArguments) parameters = conf['Parameters'] majorCirc = parameters['surfaceLength'] minorCirc = parameters['surfaceWidth'] thetaMesh = parameters['xMesh'] # Minor rand major radii r = float(minorCirc)/(2*np.pi) R = float(majorCirc)/(2*np.pi) # Read geometry from disk torusReader = vtk.vtkXMLPolyDataReader() torusReader.SetFileName("torus_R" + majorCirc + "_r" + minorCirc + "_mesh" + thetaMesh + ".vtp") torusReader.Update() torus = torusReader.GetOutput() # Obtain cell centres cellCentresFilter = vtk.vtkCellCenters() cellCentresFilter.SetInputData(torus) cellCentresFilter.Update() cellCentres = cellCentresFilter.GetOutput() gaussianCurvature = vtk.vtkDoubleArray() gaussianCurvature.SetName("Gaussian Curvature") couplingStrength = vtk.vtkDoubleArray() couplingStrength.SetName("Coupling Strength") # Iterate over all centres for cId in range(cellCentres.GetNumberOfPoints()): point = cellCentres.GetPoint(cId) phi, theta = XYZtoPT(point,r,R) #Convert phi, theta eta, theta_i, a = PTtoETA(phi, theta, r, R) # Gaussian curvature resultG = np.cos(theta) / (r * (R + r * np.cos(theta))) # Coupling strength (not sure why 10 is there but is necessary) resultC = 10 * math.pow((math.cosh(eta) - np.cos(theta_i)),2) / math.pow(a,2) gaussianCurvature.InsertNextValue(resultG) couplingStrength.InsertNextValue(resultC) torus.GetCellData().AddArray(gaussianCurvature) torus.GetCellData().AddArray(couplingStrength) outputFileName = "CurvatureCoupling_torus_R" + majorCirc + "_r" + minorCirc + "_mesh" + thetaMesh + ".vtp" writer = vtk.vtkXMLPolyDataWriter() writer.SetInputData(torus) writer.SetFileName(outputFileName) writer.Update() print "Saving output to file", outputFileName
sphereSource.SetPhiResolution(64) sphereMapper = vtk.vtkPolyDataMapper() sphereMapper.SetInputConnection(sphereSource.GetOutputPort()) sphereActor = vtk.vtkActor() sphereActor.SetMapper(sphereMapper) sphereActor.GetProperty().SetColor(0., 0., 0.) actors.append(sphereActor) # show vector field grid.GetCellData().SetActiveVectors("2-form") arrowSource = vtk.vtkArrowSource() arrowSource.SetShaftRadius(0.03) #arrowSource.SetHeight(0.3) #arrowSource.SetResolution(8) cellCenters = vtk.vtkCellCenters() cellCenters.SetVertexCells(1) cellCenters.SetInputData(grid) glyph = vtk.vtkGlyph3D() glyph.SetVectorModeToUseVector() glyph.SetScaleModeToScaleByVector() glyph.SetColorModeToColorByVector() glyph.SetSourceConnection(arrowSource.GetOutputPort()) glyph.SetInputConnection(cellCenters.GetOutputPort()) glyph.SetScaleFactor(0.5) glyph.Update() glyphMapper = vtk.vtkPolyDataMapper() glyphMapper.SetInputConnection(glyph.GetOutputPort()) glyphMapper.SetUseLookupTableScalarRange(1)
boundary_tubeActor.GetProperty().SetColor(0, 0, 0) ren.AddActor(boundary_tubeActor) label_faces = False label_points = False label_face_ids = False sources = [] if draw_folding: sources.append(folding) if draw_plane: sources.append(plane) if draw_surface: sources.append(surface) for source in sources: if label_faces: cell_centers = vtk.vtkCellCenters() if vtk.vtkVersion.GetVTKMajorVersion() >= 6: cell_centers.SetInputData(source) else: cell_centers.SetInput(source) visible_only = vtk.vtkSelectVisiblePoints() visible_only.SetRenderer(ren) visible_only.SetInputConnection(cell_centers.GetOutputPort()) labels = vtk.vtkLabeledDataMapper() labels.SetInputConnection(visible_only.GetOutputPort()) labels.SetLabelModeToLabelScalars() labels.GetLabelTextProperty().SetJustificationToCentered() labels.GetLabelTextProperty().SetVerticalJustificationToCentered() labels_actor = vtk.vtkActor2D() labels_actor.SetMapper(labels) ren.AddActor(labels_actor)
visPts.SelectionWindowOn() visPts.SetSelection(xmin, xmin + xLength, ymin, ymin + yLength) ldm = vtk.vtkLabeledDataMapper() ldm.SetInputConnection(visPts.GetOutputPort()) # ldm.SetLabelFormat.("%g") # ldm.SetLabelModeToLabelScalars() # ldm.SetLabelModeToLabelNormals() ldm.SetLabelModeToLabelFieldData() # ldm.SetLabeledComponent(0) pointLabels = vtk.vtkActor2D() pointLabels.SetMapper(ldm) # Create labels for cells cc = vtk.vtkCellCenters() cc.SetInputConnection(ids.GetOutputPort()) visCells = vtk.vtkSelectVisiblePoints() visCells.SetInputConnection(cc.GetOutputPort()) visCells.SetRenderer(ren1) visCells.SelectionWindowOn() visCells.SetSelection(xmin, xmin + xLength, ymin, ymin + yLength) cellMapper = vtk.vtkLabeledDataMapper() cellMapper.SetInputConnection(visCells.GetOutputPort()) # cellMapper.SetLabelFormat("%g") # cellMapper.SetLabelModeToLabelScalars() # cellMapper.SetLabelModeToLabelNormals() cellMapper.SetLabelModeToLabelFieldData() cellMapper.GetLabelTextProperty().SetColor(0, 1, 0)
locals()[get_variable_name("", cell, "derivs")].SetVectorModeToComputeGradient() FileName = dir FileName += cell FileName += ".vtk" # make sure the directory is writeable first if (catch.catch(globals(),"""channel = open("" + str(dir) + "/test.tmp", "w")""") == 0): channel.close() file.delete("-force", "" + str(dir) + "/test.tmp") locals()[get_variable_name("", cell, "Writer")] = vtk.vtkUnstructuredGridWriter() locals()[get_variable_name("", cell, "Writer")].SetInputConnection(locals()[get_variable_name("", cell, "derivs")].GetOutputPort()) locals()[get_variable_name("", cell, "Writer")].SetFileName(FileName) locals()[get_variable_name("", cell, "Writer")].Write() # delete the file file.delete("-force", FileName) pass locals()[get_variable_name("", cell, "Centers")] = vtk.vtkCellCenters() locals()[get_variable_name("", cell, "Centers")].SetInputConnection(locals()[get_variable_name("", cell, "derivs")].GetOutputPort()) locals()[get_variable_name("", cell, "Centers")].VertexCellsOn() locals()[get_variable_name("", cell, "hog")] = vtk.vtkHedgeHog() locals()[get_variable_name("", cell, "hog")].SetInputConnection(locals()[get_variable_name("", cell, "Centers")].GetOutputPort()) locals()[get_variable_name("", cell, "mapHog")] = vtk.vtkPolyDataMapper() locals()[get_variable_name("", cell, "mapHog")].SetInputConnection(locals()[get_variable_name("", cell, "hog")].GetOutputPort()) locals()[get_variable_name("", cell, "mapHog")].SetScalarModeToUseCellData() locals()[get_variable_name("", cell, "mapHog")].ScalarVisibilityOff() locals()[get_variable_name("", cell, "hogActor")] = vtk.vtkActor() locals()[get_variable_name("", cell, "hogActor")].SetMapper(locals()[get_variable_name("", cell, "mapHog")]) locals()[get_variable_name("", cell, "hogActor")].GetProperty().SetColor(0,1,0) locals()[get_variable_name("", cell, "Glyph3D")] = vtk.vtkGlyph3D() locals()[get_variable_name("", cell, "Glyph3D")].SetInputConnection(locals()[get_variable_name("", cell, "Centers")].GetOutputPort()) locals()[get_variable_name("", cell, "Glyph3D")].SetSourceData(ball.GetOutput()) locals()[get_variable_name("", cell, "CentersMapper")] = vtk.vtkPolyDataMapper()
# Create directory for each time step output vtp file os.system("mkdir -p GBstep") for tstep in range(nt): # Get the time at tstep time = ((float(tstep) / float(nt))) * float(tFinal) # get time of output # Read geometry from disk torusReader = vtk.vtkXMLPolyDataReader() torusReader.SetFileName("torus_R" + majorCirc + "_r" + minorCirc + "_mesh" + thetaMesh + ".vtp") torusReader.Update() torus = torusReader.GetOutput() # Obtain cell centres cellCentresFilter = vtk.vtkCellCenters() cellCentresFilter.SetInputData(torus) cellCentresFilter.Update() cellCentres = cellCentresFilter.GetOutput() ZArray = vtk.vtkDoubleArray() ZArray.SetName("Cytosolic Calcium") if (varyBeta == 1): HopfArray = vtk.vtkDoubleArray() HopfArray.SetName("Hopf Bifurcations") if (includeAllVars == 1): YArray = vtk.vtkDoubleArray() YArray.SetName("Calcium in Stores")
def BuildViewWithTag(self): if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 self.vmtkRenderer.RegisterScript(self) if self.Actor: self.vmtkRenderer.Renderer.RemoveActor(self.Actor) if self.ScalarBarActor: self.vmtkRenderer.Renderer.RemoveActor(self.ScalarBarActor) if self.Surface.GetPointData().GetArray( self.RegionTagArrayName) == None and self.Surface.GetCellData( ).GetArray(self.RegionTagArrayName) == None: self.PrintError('Error: no regiontagarray with name specified') elif self.Surface.GetPointData().GetArray( self.RegionTagArrayName) != None: regionTagArray = self.Surface.GetPointData().GetArray( self.RegionTagArrayName) for j in range(self.Surface.GetNumberOfPoints()): if regionTagArray.GetTuple1(j) not in self.TagSet: self.TagSet.append(regionTagArray.GetTuple1(j)) self.TagSet.sort() self.NumberOfRegions = len(self.TagSet) tagSetCopy = list(self.TagSet) labelPoints = vtk.vtkPoints() labelPoints.SetNumberOfPoints(len(self.TagSet)) point = [0.0, 0.0, 0.0] for j in range(self.Surface.GetNumberOfPoints()): item = regionTagArray.GetTuple1(j) if item in tagSetCopy: self.Surface.GetPoint(j, point) labelPoints.SetPoint(self.TagSet.index(item), point) tagSetCopy.remove(item) self.Surface.GetPointData().SetActiveScalars( self.RegionTagArrayName) elif self.Surface.GetCellData().GetArray( self.RegionTagArrayName) != None: regionTagArray = self.Surface.GetCellData().GetArray( self.RegionTagArrayName) for j in range(self.Surface.GetNumberOfCells()): if regionTagArray.GetTuple1(j) not in self.TagSet: self.TagSet.append(regionTagArray.GetTuple1(j)) self.TagSet.sort() self.NumberOfRegions = len(self.TagSet) tagSetCopy = list(self.TagSet) labelPoints = vtk.vtkPoints() labelPoints.SetNumberOfPoints(len(self.TagSet)) point = [0.0, 0.0, 0.0] cellCenters = vtk.vtkCellCenters() cellCenters.SetInputData(self.Surface) cellCenters.Update() regionTagArrayCenters = cellCenters.GetOutput().GetPointData( ).GetArray(self.RegionTagArrayName) for j in range(cellCenters.GetOutput().GetNumberOfPoints()): item = regionTagArrayCenters.GetTuple1(j) if item in tagSetCopy: cellCenters.GetOutput().GetPoint(j, point) labelPoints.SetPoint(self.TagSet.index(item), point) tagSetCopy.remove(item) self.Surface.GetCellData().SetActiveScalars( self.RegionTagArrayName) labelPolyData = vtk.vtkPolyData() labelPolyData.SetPoints(labelPoints) labelArray = vtk.vtkIntArray() labelArray.SetNumberOfComponents(1) labelArray.SetNumberOfTuples(self.NumberOfRegions) labelArray.SetName('label') labelArray.FillComponent(0, 0) labelPolyData.GetPointData().AddArray(labelArray) for item in self.TagSet: labelArray.SetTuple1(self.TagSet.index(item), item) labelPolyData.GetPointData().SetActiveScalars('label') labelsMapper = vtk.vtkLabeledDataMapper() labelsMapper.SetInputData(labelPolyData) labelsMapper.SetLabelModeToLabelScalars() labelsMapper.GetLabelTextProperty().SetColor(1, 1, 1) labelsMapper.GetLabelTextProperty().SetFontSize(14) self.labelsActor = vtk.vtkActor2D() self.labelsActor.SetMapper(labelsMapper) self.vmtkRenderer.Renderer.AddActor(self.labelsActor) surfaceMapper = vtk.vtkPolyDataMapper() surfaceMapper.SetInputData(self.Surface) surfaceMapper.ScalarVisibilityOn() surfaceMapper.SetScalarRange(self.TagSet[0], self.TagSet[self.NumberOfRegions - 1]) self.Actor = vtk.vtkActor() self.Actor.SetMapper(surfaceMapper) self.Actor.GetProperty().SetOpacity(self.Opacity) self.Actor.GetProperty().SetLineWidth(self.LineWidth) if self.FlatInterpolation: self.Actor.GetProperty().SetInterpolationToFlat() self.SetSurfaceRepresentation(self.Representation) self.vmtkRenderer.Renderer.AddActor(self.Actor) self.vmtkRenderer.AddKeyBinding('w', 'Change surface representation.', self.RepresentationCallback) if self.Legend and self.Actor: self.ScalarBarActor = vtk.vtkScalarBarActor() self.ScalarBarActor.SetLookupTable( self.Actor.GetMapper().GetLookupTable()) self.ScalarBarActor.GetLabelTextProperty().ItalicOff() self.ScalarBarActor.GetLabelTextProperty().BoldOff() self.ScalarBarActor.GetLabelTextProperty().ShadowOff() ## self.ScalarBarActor.GetLabelTextProperty().SetColor(0.0,0.0,0.0) self.ScalarBarActor.SetLabelFormat('%.2f') self.ScalarBarActor.SetTitle(self.LegendTitle) self.vmtkRenderer.Renderer.AddActor(self.ScalarBarActor) if self.Display: self.vmtkRenderer.Render() ## self.vmtkRenderer.Renderer.RemoveActor(self.Actor) ## self.vmtkRenderer.Renderer.RemoveActor(self.ScalarBarActor) if self.OwnRenderer: self.vmtkRenderer.Deallocate()
def buildATPMesh(): # Report our CWD just for testing purposes. print "CWD:", os.getcwd() # Read in the mesh. meshReader = vtk.vtkXMLPolyDataReader() meshReader.SetFileName(meshFile) meshReader.Update() mesh = meshReader.GetOutput() print mesh.GetNumberOfCells() # Put it through centroids filter. # Use VTK centroid filter to get the centroids in the right order # from the reorderedECMeshBranch. centroidFilter = vtk.vtkCellCenters() centroidFilter.SetInput(mesh) # Create a vertex cell for each point. pointsToVerticesFilter = vtk.vtkVertexGlyphFilter() pointsToVerticesFilter.SetInputConnection(centroidFilter.GetOutputPort()) pointsToVerticesFilter.Update() atpDataset = pointsToVerticesFilter.GetOutput() # Here we are assuming that cell ordering has been preserved. gridCoords = mesh.GetCellData().GetArray("gridCoords") # Create a new cell data array "parametricDistance" in the centroids # dataset with the values from the previous step. This array is really not # needed for any computations but is good to have for verification. Also, # it is useful to know the max value for each branch. axialDist = vtk.vtkIntArray() axialDist.SetName("parametriDistance") # Iterate over all quad cells in the mesh and pull out the first component # of the "gridCoords" cell data array. Here we assuming the mesh contains # only quad cells. # If the branches were labelled properly here, it would be much simpler # to set the neganive axial distance values by examining the range first. for cellId in range(0, mesh.GetNumberOfCells()): axialDist.InsertNextValue(gridCoords.GetTuple(cellId)[0]) atpArray = vtk.vtkDoubleArray() atpArray.SetName("initialATP") axialDistRange = [0, 0] axialDist.GetRange(axialDistRange, 0) # Iterate over the "axialDist" cell array and for each value call # the agonistValue function and store the computed values in the new # "initialATP" cell data array. for cellId in range(0, axialDist.GetNumberOfTuples()): # Figure out the current branch id. branchId = cellId / (axialDist.GetNumberOfTuples() / 3) # For the first branch the parametric distance value must be in the # range [maxDist - 1, 0). Range values are required for this. # TODO: The ATP calculations here are repeated many times for the same value # of the parametric distnace. It would make sense to have a lookup table (dictionary) # for previously calculated values. if branchId == 0: distVal = axialDist.GetValue(cellId) - axialDistRange[1] - 1 atpVal = sigmoidATP(distVal) else: # This is for the 'normal' atp map. distVal = axialDist.GetValue(cellId) atpVal = sigmoidATP(distVal) atpArray.InsertNextValue(atpVal) # Assert the number of cells is equal to the number of items in the cell arrays. assert axialDist.GetNumberOfTuples() == atpDataset.GetNumberOfCells(), "Number of cells (%d) and cell data values (%d) mismatch." % (axialDist.GetNumberOfTuples(), atpDataset.GetNumberOfCells) assert atpArray.GetNumberOfTuples() == atpDataset.GetNumberOfCells(), "Number of cells (%d) and cell data values (%d) mismatch." % (atpArray.GetNumberOfTuples(), atpDataset.GetNumberOfCells()) atpDataset.GetCellData().AddArray(axialDist) atpDataset.GetCellData().AddArray(atpArray) atpMapWriter = vtk.vtkXMLPolyDataWriter() atpMapWriter.SetFileName(atpFile) atpMapWriter.SetInput(atpDataset) atpMapWriter.Update() # Provide a quick visualisation of the ATP profile for validation. pointsX = range(-int(axialDistRange[1] - 1), int(axialDistRange[1])) pointsY = [] for pt in pointsX: pointsY.append(sigmoidATP(pt)) pyplot.plot(pointsX, pointsY, 'b') pyplot.show()
import numpy as np ecReader = vtk.vtkXMLPolyDataReader() ecReader.SetFileName('quadMeshFullECc2000.vtp') ecReader.Update() polydata = ecReader.GetOutput() # Create new ATP map array. newMapArray = vtk.vtkDoubleArray() newMapArray.SetName('initialATP') newMapArray.SetNumberOfComponents(1) newMapArray.SetNumberOfTuples(polydata.GetNumberOfCells()) # Get cell centres. centresFilter = vtk.vtkCellCenters() centresFilter.SetInput(polydata) centresFilter.Update() centres = centresFilter.GetOutput() atp_min = 0.2 atp_max = 0.7 # High ATP rectange coordinates. r_x1 = 3000 r_x2 = 7000 r_y1 = 6000 r_y2 = 7000 _, _, y_min, y_max, _, _ = centres.GetBounds()
def Execute(self): if not self.Centerlines: self.PrintError('Error: No input centerlines.') return if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 self.vmtkRenderer.RegisterScript(self) if self.CellDataArrayName: cellCenters = vtk.vtkCellCenters() cellCenters.SetInput(self.Centerlines) cellCenters.Update() cellCenters.GetOutput().GetPointData().SetActiveScalars( self.CellDataArrayName) labelsMapper = vtk.vtkLabeledDataMapper() labelsMapper.SetInput(cellCenters.GetOutput()) labelsMapper.SetLabelModeToLabelScalars() labelsActor = vtk.vtkActor2D() labelsActor.SetMapper(labelsMapper) self.vmtkRenderer.Renderer.AddActor(labelsActor) centerlineMapper = vtk.vtkPolyDataMapper() centerlineMapper.SetInput(self.Centerlines) if self.CellDataArrayName and not self.PointDataArrayName: centerlineMapper.ScalarVisibilityOn() centerlineMapper.SetScalarModeToUseCellData() self.Centerlines.GetCellData().SetActiveScalars( self.CellDataArrayName) centerlineMapper.SetScalarRange( self.Centerlines.GetCellData().GetScalars().GetRange(0)) elif self.PointDataArrayName: centerlineMapper.ScalarVisibilityOn() centerlineMapper.SetScalarModeToUsePointData() self.Centerlines.GetPointData().SetActiveScalars( self.PointDataArrayName) centerlineMapper.SetScalarRange( self.Centerlines.GetPointData().GetScalars().GetRange(0)) else: centerlineMapper.ScalarVisibilityOff() if self.ColorMap == 'grayscale': lut = centerlineMapper.GetLookupTable() lut.SetNumberOfTableValues(self.NumberOfColors) lut.SetValueRange(0.0, 1.0) lut.SetSaturationRange(0.0, 0.0) lut.Build() centerlineMapper.SetLookupTable(lut) if self.ColorMap == 'rainbow': lut = centerlineMapper.GetLookupTable() lut.SetHueRange(0.666667, 0.0) lut.SetSaturationRange(0.75, 0.75) lut.SetValueRange(1.0, 1.0) lut.SetAlphaRange(1.0, 1.0) lut.SetNumberOfColors(self.NumberOfColors) lut.Build() centerlineMapper.SetLookupTable(lut) if self.ColorMap == 'blackbody': lut = centerlineMapper.GetLookupTable() lut.SetNumberOfTableValues(self.NumberOfColors) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.SetColorSpaceToRGB() colorTransferFunction.AddRGBPoint(0, 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(0.4, 0.901961, 0.0, 0.0) colorTransferFunction.AddRGBPoint(0.8, 0.901961, 0.901961, 0.0) colorTransferFunction.AddRGBPoint(1.0, 1.0, 1.0, 1.0) for ii, ss in enumerate([ float(xx) / float(self.NumberOfColors) for xx in range(self.NumberOfColors) ]): cc = colorTransferFunction.GetColor(ss) lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0) lut.Build() centerlineMapper.SetLookupTable(lut) if self.ColorMap == 'cooltowarm': lut = centerlineMapper.GetLookupTable() lut.SetNumberOfTableValues(self.NumberOfColors) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.SetColorSpaceToDiverging() colorTransferFunction.AddRGBPoint(0, 0.231373, 0.298039, 0.752941) colorTransferFunction.AddRGBPoint(0.5, 0.865003, 0.865003, 0.865003) colorTransferFunction.AddRGBPoint(1.0, 0.705882, 0.0156863, 0.14902) for ii, ss in enumerate([ float(xx) / float(self.NumberOfColors) for xx in range(self.NumberOfColors) ]): cc = colorTransferFunction.GetColor(ss) lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0) lut.Build() centerlineMapper.SetLookupTable(lut) centerlineActor = vtk.vtkActor() centerlineActor.SetMapper(centerlineMapper) self.vmtkRenderer.Renderer.AddActor(centerlineActor) scalarBarActor = None if self.Legend and centerlineActor and self.PointDataArrayName: scalarBarActor = vtk.vtkScalarBarActor() scalarBarActor.SetLookupTable( centerlineActor.GetMapper().GetLookupTable()) scalarBarActor.GetLabelTextProperty().ItalicOff() scalarBarActor.GetLabelTextProperty().BoldOff() scalarBarActor.GetLabelTextProperty().ShadowOff() scalarBarActor.SetLabelFormat('%.2f') scalarBarActor.SetTitle(self.PointDataArrayName) self.vmtkRenderer.Renderer.AddActor(scalarBarActor) if self.Display: self.vmtkRenderer.Render() if self.OwnRenderer: self.vmtkRenderer.Deallocate()
def writeLegacyVTK(): # This is where the data is for testing purposes. print "Current working directory:", os.getcwd() if os.path.isdir("vtk") == False: os.makedirs("vtk") print "Cretated vtk output directory..." if os.path.isdir("files") == False: os.makedirs("files") print "Created files ouptut directory..." # Working with the task mesh. taskMeshReader = vtk.vtkXMLPolyDataReader() taskMeshReader.SetFileName(meshSet[0]) taskMeshReader.Update() taskMesh = taskMeshReader.GetOutput() # Get the range of branch labels. labelRange = [0, 0] taskMesh.GetCellData().GetScalars().GetRange(labelRange, 0) # Convert label range to a list of labels. labelRange = range(int(labelRange[0]), int(labelRange[1]) + 1) print "Labels found in task mesh:", labelRange # Store the number of rings for each label. numRingsPerLabel = {} # For every label in the range of labels we want to extract all cells/quads. for label in labelRange: # Use this filter to extract the cells for a given label value. branchSelector = vtk.vtkThreshold() branchSelector.SetInputData(taskMesh) branchSelector.ThresholdBetween(label,label); branchSelector.Update() taskMeshBranch = branchSelector.GetOutput() # New vtkPoints for storing reordered points. reorderedPoints = vtk.vtkPoints() # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() numQuadRowsPerBranch = taskMeshBranch.GetNumberOfCells() / numQuadsPerRing; numRingsPerLabel[label] = numQuadRowsPerBranch ringIds = range(0, numQuadRowsPerBranch); # Working with rows in reverse order: UPSTREAM. ringIds.reverse() rowBase = 0 # Iterate over the rings in reverse order. for ringNum in ringIds: # Iterate over the cells in normal order. for cellNum in range(0, numQuadsPerRing): # Calculate the 'real' cell id and get the corresponding cell. cellId = ringNum * numQuadsPerRing + cellNum cell = taskMeshBranch.GetCell(cellId) # The ids to be written to the TXT file. pointIdList = [cell.GetNumberOfPoints()] # Write the appropriate points to TXT file. for pPos in range(0, cell.GetNumberOfPoints()): newPoint = False if ringNum == ringIds[0]: if cellNum == 0: newPoint = True elif pPos == 1 or pPos == 2: newPoint = True else: if cellNum == 0: if pPos == 0 or pPos == 1: newPoint = True else: if pPos == 1: newPoint = True if newPoint == True: # Inserting a new point... point = taskMeshBranch.GetPoint(cell.GetPointId(pPos)) # ... with a new id. newId = reorderedPoints.InsertNextPoint(point) pointIdList.append(newId) # To make it easier for remembering the number of points instered in a row. if cellNum == 0 and pPos == 0: rowBasePrev = newId else: # Perhaps this can be done in a nicer way. # Calculate the id of a previously inserted point. if ringNum == ringIds[0]: if cellNum == 1: if pPos == 0: pointIdList.append(1L) elif pPos == 3: pointIdList.append(2L) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 2)) elif pPos == 3: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 3)) elif ringNum == ringIds[1]: if cellNum == 0: if pPos == 2: pointIdList.append(1L) elif pPos == 3: pointIdList.append(0L) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append(long(cellNum * 2 + 2)) elif pPos == 3: if cellNum == 1: pointIdList.append(1L) else: pointIdList.append(long(cellNum * 2)) else: if cellNum == 0: if pPos == 2: pointIdList.append(long(rowBase + 1)) elif pPos == 3: pointIdList.append(long(rowBase)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append(long(rowBase + cellNum + 1)) elif pPos == 3: pointIdList.append(long(rowBase + cellNum)) # print pointIdList, rowBase # Insert the ids into the cell array. newCell = vtk.vtkQuad() newCell.GetPointIds().Reset() for id in pointIdList[1:]: newCell.GetPointIds().InsertNextId(id) reorderedCellArray.InsertNextCell(newCell) rowBase = rowBasePrev # print '\n' print "Inserted", reorderedPoints.GetNumberOfPoints(), "task mesh points for label", label, "..." print "Inserted", reorderedCellArray.GetNumberOfCells(), "task mesh cells for label", label, "..." # Create new vtkPolyData object for the new reordered mesh. reorderedTaskMeshBranch = vtk.vtkPolyData() # Put the reordered points and cells into the reordered mesh. reorderedTaskMeshBranch.SetPoints(reorderedPoints) reorderedTaskMeshBranch.SetPolys(reorderedCellArray) # Write the VTK file. reorderedMeshWriter = vtk.vtkXMLPolyDataWriter() reorderedMeshWriter.SetInputData(reorderedTaskMeshBranch) reorderedMeshWriter.SetFileName(taskVTKFiles[label]) reorderedMeshWriter.Update() print "Rings per label:", numRingsPerLabel, "..." ringsPerLabelVals = numRingsPerLabel.values() # Check all rings per label values are the same. assert ringsPerLabelVals[1:] == ringsPerLabelVals[:-1], "All values of rings per label must be identical. Generated output is invalid ..." # Working with EC mesh. ecMeshReader = vtk.vtkXMLPolyDataReader() ecMeshReader.SetFileName(meshSet[1]) ecMeshReader.Update() # Original ECs mesh to work with. ecMesh = ecMeshReader.GetOutput() print "There are", ecMesh.GetNumberOfCells(), "ECs in total ..." # For every label in the range of labels we want to extract all ECs. for label in labelRange: # Keep track of how many branches we need to skip. numECsPerLabel = numQuadsPerRing * numRingsPerLabel[label] * numECsPerQuad ecCellOffset = label * numECsPerLabel print "ecCellOffset", ecCellOffset # Collect cell ids to select. selectionIds = vtk.vtkIdTypeArray() for sId in range(0, numECsPerLabel): selectionIds.InsertNextValue(ecCellOffset + sId) # Create selecion node. selectionNode = vtk.vtkSelectionNode() selectionNode.SetFieldType(selectionNode.CELL) selectionNode.SetContentType(selectionNode.INDICES) selectionNode.SetSelectionList(selectionIds) # Create selection. selection = vtk.vtkSelection() selection.AddNode(selectionNode) # Use vtkSelection filter. selectionExtractor = vtk.vtkExtractSelection() selectionExtractor.SetInputData(0, ecMesh) selectionExtractor.SetInputData(1, selection) selectionExtractor.Update() extractedECs = selectionExtractor.GetOutput() # Ring ids list for traversal. ringIds = range(0, numRingsPerLabel[label]) ringIds.reverse() # Number of ECs rows is the number of ECs per quad. rowIds = range(0, numECsPerCol) rowIds.reverse() # The ECs are organised in rings of blocks of cells. # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() # Iterate over the rings in reverse order. for ringNum in ringIds: # Iterate over the 'imaginary' quads of cells in normal order. for quadNum in range(0, numQuadsPerRing): # Iterate over the rows of cells in reverse order. # Calculate the 'real' id for the 'imaginary' quad. quadId = ringNum * numQuadsPerRing + quadNum # Iterate over rows of cells in reverse order. for rowNum in rowIds: # Iterate over the rows of cells in normal order. for ecNum in range(0, numECsPerRow): # Calculate the 'real' ec cell id and get the corresponding cell. ecId = quadId * numECsPerQuad + rowNum * numECsPerRow + ecNum ecCell = extractedECs.GetCell(ecId) reorderedCellArray.InsertNextCell(ecCell) # Create new vtkPolyData object for the new reordered mesh. reorderedECMeshBranch = vtk.vtkPolyData() # Insert our new points. reorderedECMeshBranch.SetPoints(extractedECs.GetPoints()) # Set the reordered cells to the reordered ECs mesh. reorderedECMeshBranch.SetPolys(reorderedCellArray) # New vtkPoints for storing reordered points. reorderedPoints = vtk.vtkPoints() # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() rowBase = 0 # Iterate over quads in normal order because they have been reordered. for quadNum in range(0, numRingsPerLabel[label] * numQuadsPerRing): # Iterate over rows in normal order because they have been reordered. for rowNum in range(0, numECsPerCol): # Iterate over the ECs in the row in normal order. for ecNum in range(0, numECsPerRow): # Calculate the 'real' ec cell id and get the corresponding cell. ecId = quadNum * numECsPerQuad + rowNum * numECsPerRow + ecNum ecCell = reorderedECMeshBranch.GetCell(ecId) # The ids to be written to the TXT file. pointIdList = [ecCell.GetNumberOfPoints()] # Write the appropriate points to the TXT file. for pPos in range(0, ecCell.GetNumberOfPoints()): newPoint = False if rowNum == 0: if ecNum == 0: newPoint = True elif pPos == 1 or pPos == 2: newPoint = True else: if ecNum == 0: if pPos == 0 or pPos == 1: newPoint = True else: if pPos == 1: newPoint = True if newPoint == True: # Inserting a new point... point = reorderedECMeshBranch.GetPoint(ecCell.GetPointId(pPos)) # ... with a new id. newId = reorderedPoints.InsertNextPoint(point) pointIdList.append(newId) if ecNum == 0 and pPos == 0: rowBasePrev = newId else: # Perhaps this can be done in a nicer way. # Calculate the ide of a previously inserted point. if rowNum == 0: if ecNum == 1: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 3)) elif pPos == 3: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 4)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 2)) elif pPos == 3: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 3)) elif rowNum == 1: if ecNum == 0: if pPos == 2: pointIdList.append(long(rowBase + 1)) elif pPos == 3: pointIdList.append(long(rowBase)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append(long(rowBase + ecNum * 2 + 2)) elif pPos == 3: if ecNum == 1: pointIdList.append(long(rowBase + 1)) else: pointIdList.append(long(rowBase + ecNum * 2)) else: if ecNum == 0: if pPos == 2: pointIdList.append(long(rowBase + 1)) elif pPos == 3: pointIdList.append(long(rowBase)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append(long(rowBase + ecNum + 1)) elif pPos == 3: pointIdList.append(long(rowBase + ecNum)) # print pointIdList, rowBase # Insert the ids into the cell array. newCell = vtk.vtkQuad() newCell.GetPointIds().Reset() for id in pointIdList[1:]: newCell.GetPointIds().InsertNextId(id) reorderedCellArray.InsertNextCell(newCell) rowBase = rowBasePrev # print '\n' print "There are", reorderedPoints.GetNumberOfPoints(), "ECs points for label", label, "..." print "There are", reorderedCellArray.GetNumberOfCells(), "ECs cells for label", label, "..." # Create new vtkPolyData object for the new reordered mesh. reorderedECs = vtk.vtkPolyData() # Put the reordered points and cells into the mesh. reorderedECs.SetPoints(reorderedPoints) reorderedECs.SetPolys(reorderedCellArray) # Write the VTK EC mesh file. reorderedMeshWriter = vtk.vtkXMLPolyDataWriter() reorderedMeshWriter.SetInputData(reorderedECs) reorderedMeshWriter.SetFileName(ecVTKFiles[label]) reorderedMeshWriter.Update() # Use VTK centroid filter to get the centroids in the right order # from the reorderedECMeshBranch. centroidFilter = vtk.vtkCellCenters() centroidFilter.SetInputData(reorderedECs) centroidFilter.Update() # Create a vertex cell for each point. pointsToVerticesFilter = vtk.vtkVertexGlyphFilter() pointsToVerticesFilter.SetInputData(centroidFilter.GetOutput()) pointsToVerticesFilter.Update() reorderedCentroidBranch = pointsToVerticesFilter.GetOutput() # Write the VTK EC centrouid file. centroidWriter = vtk.vtkXMLPolyDataWriter() centroidWriter.SetInputData(reorderedCentroidBranch) centroidWriter.SetFileName(ecCentroidVTKFiles[label]) centroidWriter.Update() # Write the centroids to the TXT points and cells files. for cId in range(0, reorderedCentroidBranch.GetNumberOfCells()): centCell = reorderedCentroidBranch.GetCell(cId) centIds = [centCell.GetNumberOfPoints()] # Write centroid ids. ptId = centCell.GetPointId(0) centIds.append(ptId) # Write centroid points. point = reorderedCentroidBranch.GetPoint(ptId) # Working with SMC mesh. # Working with SMC mesh. # Working with SMC mesh. smcMeshReader = vtk.vtkXMLPolyDataReader() smcMeshReader.SetFileName(meshSet[2]) smcMeshReader.Update() # Original SMCs mesh to work with. smcMesh = smcMeshReader.GetOutput() print "There are", smcMesh.GetNumberOfCells(), "SMCs in total ..." # For every label in the range of labels we want to extract all SMCs. for label in labelRange: # Keep track of how many branches we need to skip. numSMCsPerLabel = numQuadsPerRing * numRingsPerLabel[label] * numSMCsPerQuad smcCellOffset = label * numSMCsPerLabel print "smcCellOffset", smcCellOffset # Collect cell ids to select. selectionIds = vtk.vtkIdTypeArray() for sId in range(0, numSMCsPerLabel): selectionIds.InsertNextValue(smcCellOffset + sId) # Create selecion node. selectionNode = vtk.vtkSelectionNode() selectionNode.SetFieldType(selectionNode.CELL) selectionNode.SetContentType(selectionNode.INDICES) selectionNode.SetSelectionList(selectionIds) # Create selection. selection = vtk.vtkSelection() selection.AddNode(selectionNode) # Use vtkSelection filter. selectionExtractor = vtk.vtkExtractSelection() selectionExtractor.SetInputData(0, smcMesh) selectionExtractor.SetInputData(1, selection) selectionExtractor.Update() extractedSMCs = selectionExtractor.GetOutput() # Ring ids list for traversal. ringIds = range(0, numRingsPerLabel[label]) ringIds.reverse() # Number of SMCs rows is the number of ECs per quad times 13. rowIds = range(0, numSMCsPerCol) rowIds.reverse() # The SMCs are organised in rings of blocks of cells. # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() # Iterate over the rings in reverse order. for ringNum in ringIds: # Iterate over the 'imaginary' quads of cells in normal order. for quadNum in range(0, numQuadsPerRing): # Iterate over the rows of cells in reverse order. # Calculate the 'real' id for the 'imaginary' quad. quadId = ringNum * numQuadsPerRing + quadNum # Iterate over rows of cells in reverse order. for rowNum in rowIds: # Iterate over the rows of cells in normal order. for smcNum in range(0, numSMCsPerRow): # Calculate the 'real' smc cell id and get the corresponding cell. smcId = quadId * numSMCsPerQuad + rowNum * numSMCsPerRow + smcNum smcCell = extractedSMCs.GetCell(smcId) reorderedCellArray.InsertNextCell(smcCell) # Create new vtkPolyData object for the new reordered mesh. reorderedSMCMeshBranch = vtk.vtkPolyData() # Insert our new points. reorderedSMCMeshBranch.SetPoints(extractedSMCs.GetPoints()) # Set the reordered cells to the reordered SMCs mesh. reorderedSMCMeshBranch.SetPolys(reorderedCellArray) # New vtkPoints for storing reordered points. reorderedPoints = vtk.vtkPoints() # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() rowBase = 0 # Iterate over quads in normal order because they have been reordered. for quadNum in range(0, numRingsPerLabel[label] * numQuadsPerRing): # Iterate over rows in normal order because they have been reordered. for rowNum in range(0, numSMCsPerCol): # Iterate over the SMCs in the row in normal order. for smcNum in range(0, numSMCsPerRow): # Calculate the 'real' smc cell id and get the corresponding cell. smcId = quadNum * numSMCsPerQuad + rowNum * numSMCsPerRow + smcNum smcCell = reorderedSMCMeshBranch.GetCell(smcId) # The ids to be written to the TXT file. pointIdList = [smcCell.GetNumberOfPoints()] # Write the appropriate points to the TXT file. for pPos in range(0, smcCell.GetNumberOfPoints()): newPoint = False if rowNum == 0: if smcNum == 0: newPoint = True elif pPos == 1 or pPos == 2: newPoint = True else: if smcNum == 0: if pPos == 0 or pPos == 1: newPoint = True else: if pPos == 1: newPoint = True if newPoint == True: # Inserting a new point... point = reorderedSMCMeshBranch.GetPoint(smcCell.GetPointId(pPos)) # with a new id. newId = reorderedPoints.InsertNextPoint(point) pointIdList.append(newId) if smcNum == 0 and pPos == 0: rowBasePrev = newId else: # Perhaps this can be done in a nicer way. # Calculate the ide of a previously inserted point. if rowNum == 0: if smcNum == 1: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 3)) elif pPos == 3: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 4)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 2)) elif pPos == 3: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 3)) elif rowNum == 1: if smcNum == 0: if pPos == 2: pointIdList.append(long(rowBase + 1)) elif pPos == 3: pointIdList.append(long(rowBase)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append(long(rowBase + smcNum * 2 + 2)) elif pPos == 3: if smcNum == 1: pointIdList.append(long(rowBase + 1)) else: pointIdList.append(long(rowBase + smcNum * 2)) else: if smcNum == 0: if pPos == 2: pointIdList.append(long(rowBase + 1)) elif pPos == 3: pointIdList.append(long(rowBase)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append(long(rowBase + smcNum + 1)) elif pPos == 3: pointIdList.append(long(rowBase + smcNum)) # print pointIdList, rowBase # Insert the ids into the cell array. newCell = vtk.vtkQuad() newCell.GetPointIds().Reset() for id in pointIdList[1:]: newCell.GetPointIds().InsertNextId(id) reorderedCellArray.InsertNextCell(newCell) rowBase = rowBasePrev # print '\n' print "There are", reorderedPoints.GetNumberOfPoints(), "SMCs points for label", label, "..." print "There are", reorderedCellArray.GetNumberOfCells(), "SMCs cells for label", label, "..." # Create new vtkPolyData object for the new reordered mesh. reorderedSMCs = vtk.vtkPolyData() # Put the reordered points and cells in to the mesh. reorderedSMCs.SetPoints(reorderedPoints) reorderedSMCs.SetPolys(reorderedCellArray) # Write the VTK SMC mesh file. reorderedMeshWriter = vtk.vtkXMLPolyDataWriter() reorderedMeshWriter.SetInputData(reorderedSMCs) reorderedMeshWriter.SetFileName(smcVTKFiles[label]) reorderedMeshWriter.Update() print "All done ..." print "... Except the last configuration_info.txt file ..." configFile = open("files/configuration_info.txt", 'w') configFile.write("Processors information\n") configFile.write("Total number of points per branch (vtk points) = %d\t\tm = %d n = %d\n" \ % ((numQuadsPerRing + 1) * (numRingsPerLabel[0] + 1), (numQuadsPerRing + 1), (numRingsPerLabel[0] + 1))) configFile.write("Total number of cells per branch (vtk cells) = %d\t\tm = %d n = %d\n" \ % (numQuadsPerRing * numRingsPerLabel[0], numQuadsPerRing, numRingsPerLabel[0])) configFile.write("Total number of SMC mesh points per processor mesh (vtk points) = %d\t\tm = %d n = %d\n" \ % ((numSMCsPerCol + 1) * (numSMCsPerRow + 1), (numSMCsPerCol + 1), (numSMCsPerRow + 1))) configFile.write("Total number of SMC mesh cells per processor mesh (vtk cells) = %d\t\tm = %d n = %d\n" \ % (numSMCsPerCol * numSMCsPerRow, numSMCsPerCol, numSMCsPerRow)) configFile.write("Total number of EC mesh points per processor mesh (vtk points) = %d\t\tm = %d n = %d\n" \ % ((numECsPerCol + 1) * (numECsPerRow + 1), (numECsPerCol + 1), (numECsPerRow + 1))) configFile.write("Total number of EC mesh cells per processor mesh (vtk cells) = %d\t\tm = %d n = %d\n" \ % (numECsPerCol *numECsPerRow, numECsPerCol, numECsPerRow)) configFile.write("Total number of EC mesh centeroid points per processor mesh (vtk points) = %d\t\tm = %d n = %d\n" \ % (numECsPerCol *numECsPerRow, numECsPerCol, numECsPerRow)) configFile.write("Total number of EC mesh centeroid cells per processor mesh (vtk cells) = %d\t\tm = %d n = %d\n" \ % (numECsPerCol *numECsPerRow, numECsPerCol, numECsPerRow)) configFile.close() print "Now it is all done for real ..."
def get_cell_centers(out): centers = vtk.vtkCellCenters() centers.AddInputData(out) centers.Update() return get_points(centers.GetOutput())
def mark_boundary_cells(patchData, patchPolys, debug): """Find the internal cell adjacent to each cell in the boundary data. Goes through each cell center for all boundary polydata and attempts to find the adjacent cell in the interalField. Creates a connectivity array and adds it as field data to the internal field polydata. """ boundaryCellsConn = OrderedDict() cellCenters = vtk.vtkCellCenters() for boundary in patchPolys: boundaryCellsConn[boundary] = -1*np.ones(patchPolys[boundary].GetNumberOfCells(), dtype=np.int32) locator = vtk.vtkCellLocator() locator.SetDataSet(patchData) locator.Update() for boundary in patchPolys: if debug: print(" Marking cells for patch", boundary) if debug: print(" Computing edge centers") polyI = patchPolys[boundary] cellCenters.SetInputData(polyI) cellCenters.Update() points = dsa.WrapDataObject(cellCenters.GetOutput()).Points if debug: print(" Found", points.shape[0], "centers") if debug: print(" Computing normals") normals = np.zeros(points.shape) for i in range(polyI.GetNumberOfCells()): cellI = polyI.GetCell(i) tan = np.array(cellI.GetPoints().GetPoint(1)) - np.array(cellI.GetPoints().GetPoint(0)[:]) normals[i] = np.cross(tan, [0, 0, 1]) normals[i] /= np.linalg.norm(normals[i]) if debug: print(" The mean normal is ", np.mean(normals, axis=0)) cell = vtk.vtkGenericCell() tol2 = 0.0 pcoords = [0, 0, 0] weights = [0, 0, 0] for i in range(points.shape[0]): pointI = points[i, :] foundCellId = locator.FindCell(pointI, tol2, cell, pcoords, weights) # Attmept going along the normal if foundCellId == -1: print(" Failed to find adjacent cell for boundary point", pointI, "on boundary", boundary) print(" Attempting to perturb location along the normal") pointI += 1e-6*normals[i] foundCellId = locator.FindCell(pointI, tol2, cell, pcoords, weights) if foundCellId == -1: pointI -= 2e-6*normals[i] foundCellId = locator.FindCell(pointI, tol2, cell, pcoords, weights) boundaryCellsConn[boundary][i] = foundCellId if foundCellId == -1: print(" Attempting with slow algorithm based on minimum" " distance") foundCellId, distance = get_closest_cell(pointI, patchData, debug) print(" Found cell with id", foundCellId, "located", distance, "away.") boundaryCellsConn[boundary][i] = foundCellId if debug: print(" Assigning the connectivity lists as FieldData") for key in boundaryCellsConn: if np.any(boundaryCellsConn[key] == -1): print("ERROR: some connectivity not established for boundary "+key) wrappedData = dsa.WrapDataObject(patchData) wrappedData.FieldData.append(boundaryCellsConn[key], key)
def writeLegacyVTK(): # This is where the data is for testing purposes. print("Current working directory:", os.getcwd()) if os.path.isdir("vtk") == False: os.makedirs("vtk") print("Cretated vtk output directory...") if os.path.isdir("files") == False: os.makedirs("files") print("Created files ouptut directory...") # Working with the task mesh. taskMeshReader = vtk.vtkXMLPolyDataReader() taskMeshReader.SetFileName(meshSet[0]) taskMeshReader.Update() taskMesh = taskMeshReader.GetOutput() # Get the range of branch labels. labelRange = [0, 0] taskMesh.GetCellData().GetScalars().GetRange(labelRange, 0) # Convert label range to a list of labels. labelRange = range(int(labelRange[0]), int(labelRange[1]) + 1) print("Labels found in task mesh:", labelRange) # Store the number of rings for each label. numRingsPerLabel = {} # For every label in the range of labels we want to extract all cells/quads. for label in labelRange: # Use this filter to extract the cells for a given label value. branchSelector = vtk.vtkThreshold() branchSelector.SetInputData(taskMesh) branchSelector.ThresholdBetween(label, label) branchSelector.Update() taskMeshBranch = branchSelector.GetOutput() # New vtkPoints for storing reordered points. reorderedPoints = vtk.vtkPoints() # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() numQuadRowsPerBranch = taskMeshBranch.GetNumberOfCells( ) / numQuadsPerRing numRingsPerLabel[label] = numQuadRowsPerBranch # Working with rows in reverse order: UPSTREAM. ringIds = range(0, int(numQuadRowsPerBranch)) ringIds = list(ringIds) ringIds.reverse() rowBase = 0 # Iterate over the rings in reverse order. for ringNum in ringIds: # print("ringNum", ringNum) # Iterate over the cells in normal order. for cellNum in range(0, int(numQuadsPerRing)): # Calculate the 'real' cell id and get the corresponding cell. cellId = ringNum * numQuadsPerRing + cellNum cell = taskMeshBranch.GetCell(cellId) # The ids to be written to the TXT file. pointIdList = [cell.GetNumberOfPoints()] # Write the appropriate points to TXT file. for pPos in range(0, cell.GetNumberOfPoints()): newPoint = False if ringNum == ringIds[0]: if cellNum == 0: newPoint = True elif pPos == 1 or pPos == 2: newPoint = True else: if cellNum == 0: if pPos == 0 or pPos == 1: newPoint = True else: if pPos == 1: newPoint = True if newPoint == True: # Inserting a new point... point = taskMeshBranch.GetPoint(cell.GetPointId(pPos)) # ... with a new id. newId = reorderedPoints.InsertNextPoint(point) pointIdList.append(newId) # To make it easier for remembering the number of points instered in a row. if cellNum == 0 and pPos == 0: rowBasePrev = newId else: # Perhaps this can be done in a nicer way. # Calculate the id of a previously inserted point. if ringNum == ringIds[0]: if cellNum == 1: if pPos == 0: pointIdList.append(1) elif pPos == 3: pointIdList.append(2) else: if pPos == 0: pointIdList.append( int(reorderedPoints.GetNumberOfPoints( ) - 2)) elif pPos == 3: pointIdList.append( int(reorderedPoints.GetNumberOfPoints( ) - 3)) elif ringNum == ringIds[1]: if cellNum == 0: if pPos == 2: pointIdList.append(1) elif pPos == 3: pointIdList.append(0) else: if pPos == 0: pointIdList.append( int(reorderedPoints.GetNumberOfPoints( ) - 1)) elif pPos == 2: pointIdList.append(int(cellNum * 2 + 2)) elif pPos == 3: if cellNum == 1: pointIdList.append(1) else: pointIdList.append(int(cellNum * 2)) else: if cellNum == 0: if pPos == 2: pointIdList.append(int(rowBase + 1)) elif pPos == 3: pointIdList.append(int(rowBase)) else: if pPos == 0: pointIdList.append( int(reorderedPoints.GetNumberOfPoints( ) - 1)) elif pPos == 2: pointIdList.append( int(rowBase + cellNum + 1)) elif pPos == 3: pointIdList.append(int(rowBase + cellNum)) # print(pointIdList, rowBase) # Insert the ids into the cell array. newCell = vtk.vtkQuad() newCell.GetPointIds().Reset() for id in pointIdList[1:]: newCell.GetPointIds().InsertNextId(id) reorderedCellArray.InsertNextCell(newCell) rowBase = rowBasePrev # print('\n') print("Inserted", reorderedPoints.GetNumberOfPoints(), "task mesh points for label", label, "...") print("Inserted", reorderedCellArray.GetNumberOfCells(), "task mesh cells for label", label, "...") # Create new vtkPolyData object for the new reordered mesh. reorderedTaskMeshBranch = vtk.vtkPolyData() # Put the reordered points and cells into the reordered mesh. reorderedTaskMeshBranch.SetPoints(reorderedPoints) reorderedTaskMeshBranch.SetPolys(reorderedCellArray) # Write the VTK file. reorderedMeshWriter = vtk.vtkXMLPolyDataWriter() reorderedMeshWriter.SetInputData(reorderedTaskMeshBranch) reorderedMeshWriter.SetFileName(taskVTKFiles[label]) reorderedMeshWriter.Update() print("Rings per label:", numRingsPerLabel, "...") ringsPerLabelVals = numRingsPerLabel.values() # Check all rings per label values are the same. # assert ringsPerLabelVals[1:] == ringsPerLabelVals[:-1], "All values of rings per label must be identical. Generated output is invalid ..." print(ringsPerLabelVals) # Working with EC mesh. ecMeshReader = vtk.vtkXMLPolyDataReader() ecMeshReader.SetFileName(meshSet[1]) ecMeshReader.Update() # Original ECs mesh to work with. ecMesh = ecMeshReader.GetOutput() print("There are", ecMesh.GetNumberOfCells(), "ECs in total ...") # For every label in the range of labels we want to extract all ECs. for label in labelRange: # Keep track of how many branches we need to skip. numECsPerLabel = numQuadsPerRing * numRingsPerLabel[ label] * numECsPerQuad ecCellOffset = label * numECsPerLabel print("ecCellOffset", ecCellOffset) # Collect cell ids to select. selectionIds = vtk.vtkIdTypeArray() for sId in range(0, int(numECsPerLabel)): selectionIds.InsertNextValue(int(ecCellOffset) + sId) # Create selecion node. selectionNode = vtk.vtkSelectionNode() selectionNode.SetFieldType(selectionNode.CELL) selectionNode.SetContentType(selectionNode.INDICES) selectionNode.SetSelectionList(selectionIds) # Create selection. selection = vtk.vtkSelection() selection.AddNode(selectionNode) # Use vtkSelection filter. selectionExtractor = vtk.vtkExtractSelection() selectionExtractor.SetInputData(0, ecMesh) selectionExtractor.SetInputData(1, selection) selectionExtractor.Update() extractedECs = selectionExtractor.GetOutput() # Ring ids list for traversal. ringIds = range(0, int(numRingsPerLabel[label])) ringIds = list(ringIds) ringIds.reverse() # Number of ECs rows is the number of ECs per quad. rowIds = range(0, numECsPerCol) rowIds = list(rowIds) rowIds.reverse() # The ECs are organised in rings of blocks of cells. # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() # Iterate over the rings in reverse order. for ringNum in ringIds: # Iterate over the 'imaginary' quads of cells in normal order. for quadNum in range(0, numQuadsPerRing): # Iterate over the rows of cells in reverse order. # Calculate the 'real' id for the 'imaginary' quad. quadId = ringNum * numQuadsPerRing + quadNum # Iterate over rows of cells in reverse order. for rowNum in rowIds: # Iterate over the rows of cells in normal order. for ecNum in range(0, numECsPerRow): # Calculate the 'real' ec cell id and get the corresponding cell. ecId = quadId * numECsPerQuad + rowNum * numECsPerRow + ecNum ecCell = extractedECs.GetCell(ecId) reorderedCellArray.InsertNextCell(ecCell) # Create new vtkPolyData object for the new reordered mesh. reorderedECMeshBranch = vtk.vtkPolyData() # Insert our new points. reorderedECMeshBranch.SetPoints(extractedECs.GetPoints()) # Set the reordered cells to the reordered ECs mesh. reorderedECMeshBranch.SetPolys(reorderedCellArray) # New vtkPoints for storing reordered points. reorderedPoints = vtk.vtkPoints() # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() rowBase = 0 # Iterate over quads in normal order because they have been reordered. for quadNum in range(0, int(numRingsPerLabel[label]) * numQuadsPerRing): # Iterate over rows in normal order because they have been reordered. for rowNum in range(0, numECsPerCol): # Iterate over the ECs in the row in normal order. for ecNum in range(0, numECsPerRow): # Calculate the 'real' ec cell id and get the corresponding cell. ecId = quadNum * numECsPerQuad + rowNum * numECsPerRow + ecNum ecCell = reorderedECMeshBranch.GetCell(ecId) # The ids to be written to the TXT file. pointIdList = [ecCell.GetNumberOfPoints()] # Write the appropriate points to the TXT file. for pPos in range(0, ecCell.GetNumberOfPoints()): newPoint = False if rowNum == 0: if ecNum == 0: newPoint = True elif pPos == 1 or pPos == 2: newPoint = True else: if ecNum == 0: if pPos == 0 or pPos == 1: newPoint = True else: if pPos == 1: newPoint = True if newPoint == True: # Inserting a new point... point = reorderedECMeshBranch.GetPoint( ecCell.GetPointId(pPos)) # ... with a new id. newId = reorderedPoints.InsertNextPoint(point) pointIdList.append(newId) if ecNum == 0 and pPos == 0: rowBasePrev = newId else: # Perhaps this can be done in a nicer way. # Calculate the ide of a previously inserted point. if rowNum == 0: if ecNum == 1: if pPos == 0: pointIdList.append( int(reorderedPoints. GetNumberOfPoints() - 3)) elif pPos == 3: pointIdList.append( int(reorderedPoints. GetNumberOfPoints() - 4)) else: if pPos == 0: pointIdList.append( int(reorderedPoints. GetNumberOfPoints() - 2)) elif pPos == 3: pointIdList.append( int(reorderedPoints. GetNumberOfPoints() - 3)) elif rowNum == 1: if ecNum == 0: if pPos == 2: pointIdList.append(int(rowBase + 1)) elif pPos == 3: pointIdList.append(int(rowBase)) else: if pPos == 0: pointIdList.append( int(reorderedPoints. GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append( int(rowBase + ecNum * 2 + 2)) elif pPos == 3: if ecNum == 1: pointIdList.append(int(rowBase + 1)) else: pointIdList.append( int(rowBase + ecNum * 2)) else: if ecNum == 0: if pPos == 2: pointIdList.append(int(rowBase + 1)) elif pPos == 3: pointIdList.append(int(rowBase)) else: if pPos == 0: pointIdList.append( int(reorderedPoints. GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append( int(rowBase + ecNum + 1)) elif pPos == 3: pointIdList.append(int(rowBase + ecNum)) # print(pointIdList, rowBase) # Insert the ids into the cell array. newCell = vtk.vtkQuad() newCell.GetPointIds().Reset() for id in pointIdList[1:]: newCell.GetPointIds().InsertNextId(id) reorderedCellArray.InsertNextCell(newCell) rowBase = rowBasePrev # print('\n') print("There are", reorderedPoints.GetNumberOfPoints(), "ECs points for label", label, "...") print("There are", reorderedCellArray.GetNumberOfCells(), "ECs cells for label", label, "...") # Create new vtkPolyData object for the new reordered mesh. reorderedECs = vtk.vtkPolyData() # Put the reordered points and cells into the mesh. reorderedECs.SetPoints(reorderedPoints) reorderedECs.SetPolys(reorderedCellArray) # Write the VTK EC mesh file. reorderedMeshWriter = vtk.vtkXMLPolyDataWriter() reorderedMeshWriter.SetInputData(reorderedECs) reorderedMeshWriter.SetFileName(ecVTKFiles[label]) reorderedMeshWriter.Update() # Use VTK centroid filter to get the centroids in the right order # from the reorderedECMeshBranch. centroidFilter = vtk.vtkCellCenters() centroidFilter.SetInputData(reorderedECs) centroidFilter.Update() # Create a vertex cell for each point. pointsToVerticesFilter = vtk.vtkVertexGlyphFilter() pointsToVerticesFilter.SetInputData(centroidFilter.GetOutput()) pointsToVerticesFilter.Update() reorderedCentroidBranch = pointsToVerticesFilter.GetOutput() # Write the VTK EC centrouid file. centroidWriter = vtk.vtkXMLPolyDataWriter() centroidWriter.SetInputData(reorderedCentroidBranch) centroidWriter.SetFileName(ecCentroidVTKFiles[label]) centroidWriter.Update() # Write the centroids to the TXT points and cells files. for cId in range(0, reorderedCentroidBranch.GetNumberOfCells()): centCell = reorderedCentroidBranch.GetCell(cId) centIds = [centCell.GetNumberOfPoints()] # Write centroid ids. ptId = centCell.GetPointId(0) centIds.append(ptId) # Write centroid points. point = reorderedCentroidBranch.GetPoint(ptId) # Working with SMC mesh. # Working with SMC mesh. # Working with SMC mesh. smcMeshReader = vtk.vtkXMLPolyDataReader() smcMeshReader.SetFileName(meshSet[2]) smcMeshReader.Update() # Original SMCs mesh to work with. smcMesh = smcMeshReader.GetOutput() print("There are", smcMesh.GetNumberOfCells(), "SMCs in total ...") # For every label in the range of labels we want to extract all SMCs. for label in labelRange: # Keep track of how many branches we need to skip. numSMCsPerLabel = numQuadsPerRing * numRingsPerLabel[ label] * numSMCsPerQuad smcCellOffset = label * numSMCsPerLabel print("smcCellOffset", smcCellOffset) # Collect cell ids to select. selectionIds = vtk.vtkIdTypeArray() for sId in range(0, int(numSMCsPerLabel)): selectionIds.InsertNextValue(int(smcCellOffset) + sId) # Create selecion node. selectionNode = vtk.vtkSelectionNode() selectionNode.SetFieldType(selectionNode.CELL) selectionNode.SetContentType(selectionNode.INDICES) selectionNode.SetSelectionList(selectionIds) # Create selection. selection = vtk.vtkSelection() selection.AddNode(selectionNode) # Use vtkSelection filter. selectionExtractor = vtk.vtkExtractSelection() selectionExtractor.SetInputData(0, smcMesh) selectionExtractor.SetInputData(1, selection) selectionExtractor.Update() extractedSMCs = selectionExtractor.GetOutput() # Ring ids list for traversal. ringIds = range(0, int(numRingsPerLabel[label])) ringIds = list(ringIds) ringIds.reverse() # Number of SMCs rows is the number of ECs per quad times 13. rowIds = range(0, numSMCsPerCol) rowIds = list(rowIds) rowIds.reverse() # The SMCs are organised in rings of blocks of cells. # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() # Iterate over the rings in reverse order. for ringNum in ringIds: # Iterate over the 'imaginary' quads of cells in normal order. for quadNum in range(0, numQuadsPerRing): # Iterate over the rows of cells in reverse order. # Calculate the 'real' id for the 'imaginary' quad. quadId = ringNum * numQuadsPerRing + quadNum # Iterate over rows of cells in reverse order. for rowNum in rowIds: # Iterate over the rows of cells in normal order. for smcNum in range(0, numSMCsPerRow): # Calculate the 'real' smc cell id and get the corresponding cell. smcId = quadId * numSMCsPerQuad + rowNum * numSMCsPerRow + smcNum smcCell = extractedSMCs.GetCell(smcId) reorderedCellArray.InsertNextCell(smcCell) # Create new vtkPolyData object for the new reordered mesh. reorderedSMCMeshBranch = vtk.vtkPolyData() # Insert our new points. reorderedSMCMeshBranch.SetPoints(extractedSMCs.GetPoints()) # Set the reordered cells to the reordered SMCs mesh. reorderedSMCMeshBranch.SetPolys(reorderedCellArray) # New vtkPoints for storing reordered points. reorderedPoints = vtk.vtkPoints() # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() rowBase = 0 # Iterate over quads in normal order because they have been reordered. for quadNum in range(0, int(numRingsPerLabel[label]) * numQuadsPerRing): # Iterate over rows in normal order because they have been reordered. for rowNum in range(0, numSMCsPerCol): # Iterate over the SMCs in the row in normal order. for smcNum in range(0, numSMCsPerRow): # Calculate the 'real' smc cell id and get the corresponding cell. smcId = quadNum * numSMCsPerQuad + rowNum * numSMCsPerRow + smcNum smcCell = reorderedSMCMeshBranch.GetCell(smcId) # The ids to be written to the TXT file. pointIdList = [smcCell.GetNumberOfPoints()] # Write the appropriate points to the TXT file. for pPos in range(0, smcCell.GetNumberOfPoints()): newPoint = False if rowNum == 0: if smcNum == 0: newPoint = True elif pPos == 1 or pPos == 2: newPoint = True else: if smcNum == 0: if pPos == 0 or pPos == 1: newPoint = True else: if pPos == 1: newPoint = True if newPoint == True: # Inserting a new point... point = reorderedSMCMeshBranch.GetPoint( smcCell.GetPointId(pPos)) # with a new id. newId = reorderedPoints.InsertNextPoint(point) pointIdList.append(newId) if smcNum == 0 and pPos == 0: rowBasePrev = newId else: # Perhaps this can be done in a nicer way. # Calculate the ide of a previously inserted point. if rowNum == 0: if smcNum == 1: if pPos == 0: pointIdList.append( int(reorderedPoints. GetNumberOfPoints() - 3)) elif pPos == 3: pointIdList.append( int(reorderedPoints. GetNumberOfPoints() - 4)) else: if pPos == 0: pointIdList.append( int(reorderedPoints. GetNumberOfPoints() - 2)) elif pPos == 3: pointIdList.append( int(reorderedPoints. GetNumberOfPoints() - 3)) elif rowNum == 1: if smcNum == 0: if pPos == 2: pointIdList.append(int(rowBase + 1)) elif pPos == 3: pointIdList.append(int(rowBase)) else: if pPos == 0: pointIdList.append( int(reorderedPoints. GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append( int(rowBase + smcNum * 2 + 2)) elif pPos == 3: if smcNum == 1: pointIdList.append(int(rowBase + 1)) else: pointIdList.append( int(rowBase + smcNum * 2)) else: if smcNum == 0: if pPos == 2: pointIdList.append(int(rowBase + 1)) elif pPos == 3: pointIdList.append(int(rowBase)) else: if pPos == 0: pointIdList.append( int(reorderedPoints. GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append( int(rowBase + smcNum + 1)) elif pPos == 3: pointIdList.append( int(rowBase + smcNum)) # print(pointIdList, rowBase) # Insert the ids into the cell array. newCell = vtk.vtkQuad() newCell.GetPointIds().Reset() for id in pointIdList[1:]: newCell.GetPointIds().InsertNextId(id) reorderedCellArray.InsertNextCell(newCell) rowBase = rowBasePrev # print('\n') print("There are", reorderedPoints.GetNumberOfPoints(), "SMCs points for label", label, "...") print("There are", reorderedCellArray.GetNumberOfCells(), "SMCs cells for label", label, "...") # Create new vtkPolyData object for the new reordered mesh. reorderedSMCs = vtk.vtkPolyData() # Put the reordered points and cells in to the mesh. reorderedSMCs.SetPoints(reorderedPoints) reorderedSMCs.SetPolys(reorderedCellArray) # Write the VTK SMC mesh file. reorderedMeshWriter = vtk.vtkXMLPolyDataWriter() reorderedMeshWriter.SetInputData(reorderedSMCs) reorderedMeshWriter.SetFileName(smcVTKFiles[label]) reorderedMeshWriter.Update() print("All done ...") print("... Except the last configuration_info.txt file ...") configFile = open("files/configuration_info.txt", 'w') configFile.write("Processors information\n") configFile.write("Total number of points per branch (vtk points) = %d\t\tm = %d n = %d\n" \ % ((numQuadsPerRing + 1) * (numRingsPerLabel[0] + 1), (numQuadsPerRing + 1), (numRingsPerLabel[0] + 1))) configFile.write("Total number of cells per branch (vtk cells) = %d\t\tm = %d n = %d\n" \ % (numQuadsPerRing * numRingsPerLabel[0], numQuadsPerRing, numRingsPerLabel[0])) configFile.write("Total number of SMC mesh points per processor mesh (vtk points) = %d\t\tm = %d n = %d\n" \ % ((numSMCsPerCol + 1) * (numSMCsPerRow + 1), (numSMCsPerCol + 1), (numSMCsPerRow + 1))) configFile.write("Total number of SMC mesh cells per processor mesh (vtk cells) = %d\t\tm = %d n = %d\n" \ % (numSMCsPerCol * numSMCsPerRow, numSMCsPerCol, numSMCsPerRow)) configFile.write("Total number of EC mesh points per processor mesh (vtk points) = %d\t\tm = %d n = %d\n" \ % ((numECsPerCol + 1) * (numECsPerRow + 1), (numECsPerCol + 1), (numECsPerRow + 1))) configFile.write("Total number of EC mesh cells per processor mesh (vtk cells) = %d\t\tm = %d n = %d\n" \ % (numECsPerCol *numECsPerRow, numECsPerCol, numECsPerRow)) configFile.write("Total number of EC mesh centeroid points per processor mesh (vtk points) = %d\t\tm = %d n = %d\n" \ % (numECsPerCol *numECsPerRow, numECsPerCol, numECsPerRow)) configFile.write("Total number of EC mesh centeroid cells per processor mesh (vtk cells) = %d\t\tm = %d n = %d\n" \ % (numECsPerCol *numECsPerRow, numECsPerCol, numECsPerRow)) configFile.close() print("Now it is all done for real ...")
def resample_to_2d_1d(pdi, pdo, geom): # geom_types = ns.vtk_to_numpy(geom.GetCellTypesArray()) geom_locations = ns.vtk_to_numpy(geom.GetCellLocationsArray()) geom_2d_id = np.where(geom_types == VTK_TRIANGLE)[0] n_2d_cells = geom_2d_id.size #print geom_2d_id geom_2d_locations = geom_locations[geom_2d_id] geom_1d_id = np.where(geom_types == VTK_LINE)[0] n_1d_cells = geom_1d_id.size #print geom_1d_id geom_1d_locations = geom_locations[geom_1d_id] # should check that there are both 2d and 1d elements other # similarly we should check that there are only triangles in the pdi # create a sampling dataset aux_dataset = vtk.vtkUnstructuredGrid() # compute centroids input_copy = geom.NewInstance() input_copy.UnRegister(None) input_copy.ShallowCopy(geom) geom_centers = vtk.vtkCellCenters() geom_centers.SetInputData(geom) geom_centers.Update() output = geom_centers.GetOutput() barycenters = ns.vtk_to_numpy(output.GetPoints().GetData()).reshape(-1, 3) barycenters_2d = barycenters[geom_2d_id] #print barycenters_2d # shift right half of points barycenters_2d[:, 0] = np.where(barycenters_2d[:, 0] < 0, barycenters_2d[:, 0] + LEFT_SHIFT, barycenters_2d[:, 0] + RIGHT_SHIFT) # compute 1d avarage points cell_data = ns.vtk_to_numpy(geom.GetCells().GetData()) grid = np.meshgrid([0, 1, 2], geom_1d_locations) grid = map(np.ravel, grid) cell_data_selection = grid[0] + grid[1] array_of_1d_cells = (cell_data[cell_data_selection]) assert (len(array_of_1d_cells) > 0) geom_points_y = ns.vtk_to_numpy(geom.GetPoints().GetData())[:, 1] x_points = np.array((0)) y_points = np.array((0)) # reference grid x = np.linspace(LEFT_SHIFT, RIGHT_SHIFT, AVERAGE_POINTS) y = np.linspace(0, 1, AVERAGE_POINTS) ref_x, ref_y = map(np.ravel, np.meshgrid(x, y)) assert (np.all(array_of_1d_cells[0::3] == 2)) p0 = geom_points_y[array_of_1d_cells[1::3]] p1 = geom_points_y[array_of_1d_cells[2::3]] x_points = np.tile(ref_x, geom_1d_id.size) yy, y0 = np.meshgrid(ref_y, p0) yy, y1 = np.meshgrid(ref_y, p1) y_points = (y0 * yy + y1 * (1 - yy)).ravel() assert (x_points.size == y_points.size) z_points = np.zeros(len(x_points)) points_1d = np.hstack((x_points.reshape((-1, 1)), y_points.reshape( (-1, 1)), z_points.reshape((-1, 1)))) #print points_1d all_points = append(barycenters_2d, points_1d) all_points.shape = (-1, 3) # make a probe dataset points = vtk.vtkPoints() points.SetData(make_vtk_array(all_points, "points")) point_set = vtk.vtkUnstructuredGrid() point_set.SetPoints(points) probe = vtk.vtkProbeFilter() probe.SetSourceData(pdi) probe.SetInputData(point_set) probe.Update() out = probe.GetOutput() probe_data = out.GetPointData() # reconstruct element arrays pdo.DeepCopy(geometry) cell_data = pdo.GetCellData() for i_array in range(probe_data.GetNumberOfArrays()): # make interpolation array vtk_array = probe_data.GetArray(i_array) array_name = vtk_array.GetName() n_components = vtk_array.GetNumberOfComponents() n_tuples = vtk_array.GetNumberOfTuples() array = ns.vtk_to_numpy(vtk_array) array.shape = (n_tuples, n_components) new_array = np.zeros((pdo.GetNumberOfCells(), n_components), dtype=array.dtype) new_array[geom_2d_id, :] = array[0:n_2d_cells, :] array_1d = array[n_2d_cells:, :].reshape( n_1d_cells, AVERAGE_POINTS * AVERAGE_POINTS, n_components) new_array[geom_1d_id, :] = np.average(array_1d, axis=1) new_vtk_array = ns.numpy_to_vtk(new_array, deep=1) cell_data.AddArray( make_vtk_array(new_array, "interpol_" + vtk_array.GetName())) # compute difference array vtk_geometry_array = pdo.GetCellData().GetArray(array_name) if vtk_geometry_array: assert_eq(vtk_geometry_array.GetNumberOfComponents(), new_array.shape[1]) assert_eq(vtk_geometry_array.GetNumberOfTuples(), new_array.shape[0]) geometry_array = ns.vtk_to_numpy(vtk_geometry_array) geometry_array.shape = new_array.shape difference = geometry_array - new_array cell_data.AddArray( make_vtk_array(difference, "diff_" + vtk_array.GetName()))
def cellCenters(actor): '''Get the list of cell centers of the mesh surface''' vcen = vtk.vtkCellCenters() setInput(vcen, polydata(actor, True)) vcen.Update() return coordinates(vcen.GetOutput())
def buildATPMesh(): # Report our CWD just for testing purposes. print "CWD:", os.getcwd() # Read in the mesh. print 'Reading', meshFile meshReader = vtk.vtkXMLPolyDataReader() meshReader.SetFileName(meshFile) meshReader.Update() ecMesh = meshReader.GetOutput() # Read in the centreline. print 'Reading', centrelineFile centrelineReader = vtk.vtkPolyDataReader() centrelineReader.SetFileName(centrelineFile) centrelineReader.Update() centreline = centrelineReader.GetOutput() origin = centreline.GetPoint(0) print 'origin:', origin # Put the ecMesh through centroids filter. centroidFilter = vtk.vtkCellCenters() centroidFilter.SetInputData(ecMesh) centroidFilter.Update() centroids = centroidFilter.GetOutput() # Iterate over each centroid and find the closest segment centroidPoints = centroids.GetPoints() # Only for DEBUG output. distArray = vtk.vtkDoubleArray() distArray.SetName("Dist") # For each point calculate the distance from origin. totalPoints = centroidPoints.GetNumberOfPoints() for ptId in range(totalPoints): distance = vtk.vtkMath.Distance2BetweenPoints(origin, centroidPoints.GetPoint(ptId)) distArray.InsertNextValue(math.sqrt(distance)) # Get the range of the distance values. inMin, inMax = distArray.GetRange() atpArray = vtk.vtkFloatArray() atpArray.SetName('initialATP') # Normalise distance values. for i in range(distArray.GetNumberOfTuples()): dist = distArray.GetTuple(i)[0] distRescaled = rescale(dist, inMin, inMax) atpVal = sigmoidATP(distRescaled) atpArray.InsertNextValue(atpVal) # Prepare debug ATP mesh. debugAtpDataset = ecMesh debugAtpDataset.GetCellData().AddArray(distArray) debugAtpDataset.GetCellData().AddArray(atpArray) # Save the debug ATP mesh. debugAtpMapWriter = vtk.vtkXMLPolyDataWriter() debugAtpMapWriter.SetFileName(debugAtpFile) debugAtpMapWriter.SetInputData(debugAtpDataset) debugAtpMapWriter.Update() # Prepare the ATP mesh by converting all points to vercices. pointsToVerticesFilter = vtk.vtkVertexGlyphFilter() pointsToVerticesFilter.SetInputData(centroids) pointsToVerticesFilter.Update() atpDataset = pointsToVerticesFilter.GetOutput() atpDataset.GetCellData().AddArray(atpArray) # Assert the number of cells is equal to the number of items in the cell arrays. assert atpArray.GetNumberOfTuples() == debugAtpDataset.GetNumberOfCells(), "Number of cells (%d) and cell data values (%d) mismatch." % (atpArray.GetNumberOfTuples(), debugAtpDataset.GetNumberOfCells()) atpMapWriter = vtk.vtkXMLPolyDataWriter() atpMapWriter.SetFileName(atpFile) atpMapWriter.SetInputData(atpDataset) atpMapWriter.Update() # Provide a quick visualisation of the ATP profile for validation. pointsX = numpy.arange(outMin, outMax, 0.001) pointsY = [] for pt in pointsX: pointsY.append(sigmoidATP(pt)) pyplot.plot(pointsX, pointsY, 'b') pyplot.show()