def __init__(self, pdata): """ Constructor @param pdata vtkPolyData instance """ self.polydata = pdata # save the points and point data as separate class members # so as not to pollute pdata self.points = vtk.vtkPoints() self.points.DeepCopy(pdata.GetPoints()) self.pointData = {} pd = pdata.GetPointData() for i in range(pd.GetNumberOfArrays()): arr = pd.GetArray(i) name = arr.GetName() self.pointData[name] = vtk.vtkDoubleArray() self.pointData[name].DeepCopy(arr) self.cellData = {} cd = pdata.GetCellData() for i in range(cd.GetNumberOfArrays()): name = cd.GetArray(i).GetName() self.cellData[name] = vtk.vtkDoubleArray() self.cellData[name].SetName(name)
def initializearray(polydata, arrayname, isscalar=True, ispointdata=True): """Initialize a data array. Choose pointdata or celldata and scalar or vector. Array values are initialized with 0.0 or [0.0, 0.0, 0.0].""" if ispointdata: # add array to pointdata numberofpoints = polydata.GetNumberOfPoints() array = vtk.vtkDoubleArray() array.SetName(arrayname) if isscalar: # array holds scalars array.SetNumberOfValues(numberofpoints) array.FillComponent(0, 0.0) polydata.GetPointData().AddArray(array) else: # array holds vectors array.SetNumberOfComponents(3) array.SetNumberOfTuples(numberofpoints) for j in range(3): array.FillComponent(j, 0.0) polydata.GetPointData().AddArray(array) else: # add array to celldata numberofcells = polydata.GetNumberOfCells() array = vtk.vtkDoubleArray() array.SetName(arrayname) if isscalar: # array holds scalars array.SetNumberOfValues(numberofcells) array.FillComponent(0, 0.0) polydata.GetCellData().AddArray(array) else: # array holds vectors array.SetNumberOfComponents(3) array.SetNumberOfTuples(numberofcells) for j in range(3): array.FillComponent(j, 0.0) polydata.GetCellData().AddArray(array) return array
def initVTK(self, key): print "initializing VTK objects" self.__setMinMaxRange(key) self.__normalize(key) # Create our Data object vtk.vtkStructuredGrid() self.vtkStructuredGrid = vtk.vtkStructuredGrid() self.vtkStructuredGrid.SetDimensions([128]*3) # Set up Points self.vtkPoints = vtk.vtkPoints() self.vtkPoints.Allocate(128*3) # Set up Cells # self.vtkCells = vtk.vtkCellArray() # Setup the velocity vectors self.vtkVectors = vtk.vtkDoubleArray() self.vtkVectors.SetNumberOfComponents(3) self.vtkVectors.SetNumberOfTuples(self.sdfIdent.size) # Setup the Scalars self.vtkScalars = vtk.vtkDoubleArray() self.vtkScalars.SetName(key) # Allocate points, cells, scalars, and vector fields self.AllocateData(self.sdfIdent.size, key) # Now attach newly allocated objects to the grid self.vtkStructuredGrid.SetPoints(self.vtkPoints) # self.vtkStructuredGrid.SetVerts(self.vtkCells) self.vtkStructuredGrid.GetPointData().SetVectors(self.vtkVectors) self.vtkStructuredGrid.GetPointData().SetScalars(self.vtkScalars) self.vtkStructuredGrid.GetPointData().SetActiveScalars(key)
def SetVtkGrid(x,y,z): """Set up the vtk rectilinear grid using x, y, z data. Parameters: x, y, z -- the points in the x, y and z directions respectively Returns: grid -- a vtkRectilinearGrid object """ grid = vtkRectilinearGrid(); grid.SetDimensions(len(x),len(y),len(z)); xArray = vtkDoubleArray(); for xCoord in x: xArray.InsertNextValue(xCoord) yArray = vtkDoubleArray(); for yCoord in y: yArray.InsertNextValue(yCoord) zArray = vtkDoubleArray(); for zCoord in z: zArray.InsertNextValue(zCoord) grid.SetXCoordinates(xArray); grid.SetYCoordinates(yArray); grid.SetZCoordinates(zArray); print "There are " + str(grid.GetNumberOfPoints()) + " points."; print "There are " + str(grid.GetNumberOfCells()) + " cells."; return grid
def cell_average(model, bucket): """ Calculate a volume fraction estimate at the level of the grid.""" ugrid = vtk.vtkUnstructuredGrid() ugrid.DeepCopy(model) locator = vtk.vtkCellLocator() locator.SetDataSet(ugrid) locator.BuildLocator() volfrac = numpy.zeros(ugrid.GetNumberOfCells()) volume = numpy.zeros(ugrid.GetNumberOfCells()) temperature = numpy.zeros(ugrid.GetNumberOfCells()) velocity = numpy.zeros((ugrid.GetNumberOfCells(),3)) for particle in bucket.particles: cell_id = locator.FindCell(particle.pos) volume[cell_id] += particle.volume velocity[cell_id, :] += particle.volume*particle.vel for _ in range(ugrid.GetNumberOfCells()): if volume[_] >1.0e-12: velocity[_, :] /= volume[_] volfrac[_] = volume[_] / get_measure(ugrid.GetCell(_)) for particle in bucket.particles: cell_id = locator.FindCell(particle.pos) temperature[cell_id] += particle.volume*distance2(particle.vel,velocity[cell_id, :]) for _ in range(ugrid.GetNumberOfCells()): if volume[_] >1.0e-12: temperature[_] /= volume[_] data = [vtk.vtkDoubleArray()] data[0].SetName('SolidVolumeFraction') data.append(vtk.vtkDoubleArray()) data[1].SetName('SolidVolumeVelocity') data[1].SetNumberOfComponents(3) data.append(vtk.vtkDoubleArray()) data[2].SetName('GranularTemperature') # data.append(vtk.vtkDoubleArray()) # data[3].SetName('SolidPressure') for _ in range(ugrid.GetNumberOfCells()): data[0].InsertNextValue(volume[_]) data[1].InsertNextTuple3(*(velocity[_])) data[2].InsertNextValue(temperature[_]) # data[3].InsertNextValue(solid_pressure[_]) pdata = vtk.vtkDoubleArray() pdata.SetName('Time') for _ in range(ugrid.GetNumberOfPoints()): pdata.InsertNextValue(bucket.time) for _ in data: ugrid.GetCellData().AddArray(_) ugrid.GetPointData().AddArray(pdata) return ugrid
def __init__(self): pypes.pypeScript.__init__(self) self.Surface = None self.DeformedSurface = None self.SourcePoints = vtk.vtkPoints() self.TargetPoints = vtk.vtkPoints() self.DisplacementNorms = vtk.vtkDoubleArray() self.Displacements = vtk.vtkDoubleArray() self.Displacements.SetNumberOfComponents(3) self.SourceSpheres = vtk.vtkPolyData() self.TargetSpheres = vtk.vtkPolyData() self.SourceSpheres.SetPoints(self.SourcePoints) self.TargetSpheres.SetPoints(self.TargetPoints) self.SourceSpheres.GetPointData().SetScalars(self.DisplacementNorms) self.SourceSpheres.GetPointData().SetVectors(self.Displacements) self.vmtkRenderer = None self.OwnRenderer = 0 self.DisplayDeformed = False self.SurfaceMapper = None self.Opacity = 1.0 self.SourceSpheresActor = None self.TargetSpheresActor = None self.SetScriptName("vmtkthinplatesplinedeformation") self.SetInputMembers( [ ["Surface", "i", "vtkPolyData", 1, "", "the input surface", "vmtksurfacereader"], ["Opacity", "opacity", "float", 1, "(0.0,1.0)", "object opacities in the scene"], ["vmtkRenderer", "renderer", "vmtkRenderer", 1, "", "external renderer"], ] ) self.SetOutputMembers([["DeformedSurface", "o", "vtkPolyData", 1, "", "", "vmtksurfacewriter"]])
def Gather(c, arr, root): vtkArr = vtk.vtkDoubleArray() count = len(arr) vtkArr.SetNumberOfTuples(count) for i in range(count): vtkArr.SetValue(i, arr[i]) vtkResult = vtk.vtkDoubleArray() c.Gather(vtkArr, vtkResult, root) result = [vtkResult.GetValue(i) for i in range(vtkResult.GetNumberOfTuples())] return [ tuple(result[i : i + count]) \ for i in range(0, vtkResult.GetNumberOfTuples(), count) ]
def make_unstructured_grid(mesh, velocity, pressure, time, outfile=None): """Given a mesh (in Gmsh format), velocity and pressure fields, and a time level, store the data in a vtkUnstructuredGridFormat.""" pnts = vtk.vtkPoints() pnts.Allocate(len(mesh.nodes)) node2id = {} for k, point in mesh.nodes.items(): node2id[k] = pnts.InsertNextPoint(point) ugrid = vtk.vtkUnstructuredGrid() ugrid.SetPoints(pnts) for element in mesh.elements.values(): id_list = vtk.vtkIdList() for node in element[2]: id_list.InsertNextId(node2id[node]) ugrid.InsertNextCell(TYPE_DICT[element[0]], id_list) data = [] data.append(vtk.vtkDoubleArray()) data[0].SetNumberOfComponents(3) data[0].Allocate(3*pnts.GetNumberOfPoints()) data[0].SetName('Velocity') data.append(vtk.vtkDoubleArray()) data[1].Allocate(pnts.GetNumberOfPoints()) data[1].SetName('Pressure') data.append(vtk.vtkDoubleArray()) data[2].Allocate(pnts.GetNumberOfPoints()) data[2].SetName('Time') for k in range(len(mesh.nodes)): if hasattr(velocity, '__call__'): data[0].InsertNextTuple3(*velocity(ugrid.GetPoints().GetPoint(k))) else: data[0].InsertNextTuple3(*velocity[k, :]) if hasattr(pressure, '__call__'): data[1].InsertNextValue(pressure(ugrid.GetPoints().GetPoint(k))) else: data[1].InsertNextValue(pressure[k]) data[2].InsertNextValue(time) for _ in data: ugrid.GetPointData().AddArray(_) if outfile: write_to_file(ugrid, outfile) return ugrid
def CreateParentArteryPatches(parentCenterlines, clipPoints): numberOfDaughterPatches = parentCenterlines.GetNumberOfCells() patchedCenterlines = vtk.vtkPolyData() patchedCenterlinesPoints = vtk.vtkPoints() patchedCenterlinesCellArray = vtk.vtkCellArray() patchedRadiusArray = vtk.vtkDoubleArray() clipIds, numberOfPatchedCenterlinesPoints = ExtractPatchesIds(parentCenterlines, clipPoints) print "Clipping Point Ids ", clipIds radiusArray = vtk.vtkDoubleArray() radiusArray.SetNumberOfComponents(1) radiusArray.SetName(radiusArrayName) radiusArray.SetNumberOfTuples(numberOfPatchedCenterlinesPoints) radiusArray.FillComponent(0, 0.0) numberOfCommonPatch = clipIds[0] + 1 patchedCenterlinesCellArray.InsertNextCell(numberOfCommonPatch) count = 0 for i in range(0, numberOfCommonPatch): patchedCenterlinesPoints.InsertNextPoint(parentCenterlines.GetPoint(i)) patchedCenterlinesCellArray.InsertCellPoint(i) radiusArray.SetTuple1(i, parentCenterlines.GetPointData().GetArray(radiusArrayName).GetTuple1(i)) count += 1 for j in range(numberOfDaughterPatches): cell = vtk.vtkGenericCell() parentCenterlines.GetCell(j, cell) numberOfCellPoints = cell.GetNumberOfPoints() startId = clipIds[j + 1] patchNumberOfPoints = numberOfCellPoints - startId patchedCenterlinesCellArray.InsertNextCell(patchNumberOfPoints) for i in range(startId, cell.GetNumberOfPoints()): point = cell.GetPoints().GetPoint(i) patchedCenterlinesPoints.InsertNextPoint(point) patchedCenterlinesCellArray.InsertCellPoint(count) radiusArray.SetTuple1( count, parentCenterlines.GetPointData().GetArray(radiusArrayName).GetTuple1(cell.GetPointId(i)) ) count += 1 patchedCenterlines.SetPoints(patchedCenterlinesPoints) patchedCenterlines.SetLines(patchedCenterlinesCellArray) patchedCenterlines.GetPointData().AddArray(radiusArray) return patchedCenterlines
def vtkbasis(mesh, etob, fname, coeffs): ''' Find the directions from a (non-uniform) plane wave basis and output a VTK-compatible file It's possible that this needs to be updated to work with recent changes to ElementToBasis ''' try: import vtk points = vtk.vtkPoints() vectors = vtk.vtkDoubleArray() vectors.SetNumberOfComponents(3) scalars = vtk.vtkDoubleArray() nc = 0 for e in range(mesh.nelements): c = paa.origin(mesh, e) bs = etob[e] cc = np.zeros(3) cc[:len(c)] = c nondir = 0 ndir = 0 for b in bs: if hasattr(b, "directions"): for d in b.directions.transpose(): dd = np.zeros(3) dd[:len(d)] = d if coeffs is not None: dd *= abs(coeffs[nc]) points.InsertNextPoint(*cc) vectors.InsertNextTuple3(*dd) ndir+=1 nc+=1 else: nondir += np.sqrt(np.sum(coeffs[nc:nc+b.n]**2)) nc += b.n for _ in range(ndir): scalars.InsertNextValue(nondir) g = vtk.vtkUnstructuredGrid() g.SetPoints(points) gpd = g.GetPointData() gpd.SetVectors(vectors) gpd.SetScalars(scalars) writer = vtk.vtkXMLUnstructuredGridWriter() writer.SetFileName(fname) writer.SetInput(g) writer.Write() except ImportError as e: print "Unable to write basis to file: ",e
def addVectorToCell(self,fieldValues,name): datas = vtk.vtkDoubleArray() datas.SetNumberOfComponents(3) datas.SetName(name) for value in fieldValues: datas.InsertNextTuple3(value[0],value[1],value[2]) self._resultsCell.append(datas)
def setSourceFromExpression(self, expression): """ Set the source from expression @param expression expression of x, y, and z """ from math import sqrt, pi, sin, cos, tan, log, exp n = self.pdata.GetNumberOfPolys() sourceData = vtk.vtkDoubleArray() sourceData.SetNumberOfComponents(1) sourceData.SetNumberOfTuples(n) sourceData.SetName(self.sourceName) midPoint = numpy.zeros((3,), numpy.float64) ptIds = vtk.vtkIdList() cells = self.pdata.GetPolys() cells.InitTraversal() for i in range(n): cell = cells.GetNextCell(ptIds) npts = ptIds.GetNumberOfIds() midPoint *= 0 # reset for j in range(npts): midPoint += self.points.GetPoint(ptIds.GetId(j)) midPoint /= float(npts) x, y, z = midPoint v = eval(expression) sourceData.SetTuple(i, [v]) self.pdata.GetCellData().AddArray(sourceData)
def addVectorToNode(self,fieldValues,name): datas = vtk.vtkDoubleArray() datas.SetNumberOfComponents(3) datas.SetName(name) for value in fieldValues: datas.InsertNextTuple3(value[0],value[1],value[2]) self._hexs.GetPointData().AddArray(datas)
def ExtractSingleLine(centerlines,id): cell = vtk.vtkGenericCell() centerlines.GetCell(id,cell) line = vtk.vtkPolyData() points = vtk.vtkPoints() cellArray = vtk.vtkCellArray() cellArray.InsertNextCell(cell.GetNumberOfPoints()) radiusArray = vtk.vtkDoubleArray() radiusArray.SetName(radiusArrayName) radiusArray.SetNumberOfComponents(1) radiusArray.SetNumberOfTuples(cell.GetNumberOfPoints()) radiusArray.FillComponent(0,0.0) for i in range(cell.GetNumberOfPoints()): point = [0.0,0.0,0.0] point = cell.GetPoints().GetPoint(i) points.InsertNextPoint(point) cellArray.InsertCellPoint(i) radius = centerlines.GetPointData().GetArray(radiusArrayName).GetTuple1(cell.GetPointId(i)) radiusArray.SetTuple1(i,radius) line.SetPoints(points) line.SetLines(cellArray) line.GetPointData().AddArray(radiusArray) return line
def createTrail(ts): Points = vtk.vtkPoints() id_array = vtk.vtkIntArray() #id_array.SetNumberofComponents(1) id_array.SetName("haloid") phi_array = vtk.vtkDoubleArray() phi_array.SetName("phi") for i in range(0,ts+1): px,py,pz,phid,pphi = readParticle(i) for j in range(0,len(px)): Points.InsertNextPoint(px[j],py[j],pz[j]) id_array.InsertNextTuple1(phid[j]) phi_array.InsertNextTuple1(pphi[j]) polydata = vtk.vtkPolyData() polydata.SetPoints(Points) polydata.GetPointData().AddArray(id_array) polydata.GetPointData().AddArray(phi_array) if vtk.VTK_MAJOR_VERSION <= 5: polydata.Update() outputFile = "/home/subhashis/VisData/merger_trees/particleTrail/time" + str(ts) + ".vtp" writer = vtk.vtkXMLPolyDataWriter(); writer.SetFileName(outputFile); if vtk.VTK_MAJOR_VERSION <= 5: writer.SetInput(polydata) else: writer.SetInputData(polydata) writer.Write() print "Done generating output for time %d" %ts
def SaveParentArtery(centerlines): numberOfCells = centerlines.GetNumberOfCells() cell0 = centerlines.GetCell(0) numberOfArteryPoints = centerlines.GetNumberOfPoints()-cell0.GetNumberOfPoints() artery = vtk.vtkPolyData() arteryPoints = vtk.vtkPoints() arteryCellArray = vtk.vtkCellArray() radiusArray = vtk.vtkDoubleArray() radiusArray.SetName(radiusArrayName) radiusArray.SetNumberOfComponents(1) radiusArray.SetNumberOfTuples(numberOfArteryPoints) radiusArray.FillComponent(0,0.0) count = 0 for i in range(1,numberOfCells): # cell0 is the one that goes to the aneurysm dome cell = vtk.vtkGenericCell() centerlines.GetCell(i,cell) arteryCellArray.InsertNextCell(cell.GetNumberOfPoints()) for j in range(cell.GetNumberOfPoints()): arteryPoints.InsertNextPoint(cell.GetPoints().GetPoint(j)) radiusArray.SetTuple1(count,centerlines.GetPointData().GetArray(radiusArrayName).GetTuple1(cell.GetPointId(j))) arteryCellArray.InsertCellPoint(count) count+=1 artery.SetPoints(arteryPoints) artery.SetLines(arteryCellArray) artery.GetPointData().AddArray(radiusArray) return artery
def Execute(self): if self.Surface == None: self.PrintError("Error: No input surface.") if self.PolyBall == None: self.PrintError("Error: No input polyball.") evaluationArray = vtk.vtkDoubleArray() evaluationArray.SetName(self.EvaluationArrayName) evaluationArray.SetNumberOfComponents(1) evaluationArray.SetNumberOfTuples(self.Surface.GetNumberOfPoints()) polyball = None if self.Type == "polyball": polyball = vtkvmtk.vtkvmtkPolyBall() elif self.Type == "tubes": polyball = vtkvmtk.vtkvmtkPolyBallLine() polyball.SetInputData(self.PolyBall) polyball.SetPolyBallRadiusArrayName(self.RadiusArrayName) for i in xrange(self.Surface.GetNumberOfPoints()): point = self.Surface.GetPoint(i) value = polyball.EvaluateFunction(point) evaluationArray.SetValue(i, value) self.Surface.GetPointData().AddArray(evaluationArray)
def GridSurface(self): #---------------------------------------------------------------------- # ELECTRODE CONTACT DELAUNAY TRIANGULATION ---------------------------- deln = vtk.vtkDelaunay3D() deln.SetInput(self.electrodePolyData) deln.SetTolerance(0.01) tmapper = vtk.vtkTextureMapToSphere() tmapper.SetInputConnection(deln.GetOutputPort()) #tmapper.PreventSeamOn() mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(tmapper.GetOutputPort()) # TEST TEXTURE PART atext = vtk.vtkOpenGLTexture() self.contactScalarData = vtk.vtkDoubleArray() self.contactScalarData.SetNumberOfComponents(1) for tupleID in range(self.electrodePolyData.GetNumberOfPoints()): self.contactScalarData.InsertNextValue(random.uniform(0, 1)) self.UpdateGridSurface() atext.SetInput(self.electrodePolyData) self.triangulation = vtk.vtkOpenGLActor() self.triangulation.SetMapper(mapper) self.triangulation.SetTexture(atext) self.triangulation.GetProperty().SetOpacity(1)
def simpleVtkDiGraph(): g = vtk.vtkMutableDirectedGraph() # Create 3 vertices v1 = g.AddVertex() v2 = g.AddVertex() v3 = g.AddVertex() # Create a fully connected graph g.AddGraphEdge(v1, v2) g.AddGraphEdge(v2, v3) g.AddGraphEdge(v1, v3) # Create the edge weight array weights = vtk.vtkDoubleArray() weights.SetNumberOfComponents(1) weights.SetName("Weights") # Set the edge weights weights.InsertNextValue(1.0) weights.InsertNextValue(1.0) weights.InsertNextValue(2.0) # Add the edge weight array to the graph g.GetEdgeData().AddArray(weights) return g
def addVectorToNode(self,fieldValues,name): datas = vtk.vtkDoubleArray() datas.SetNumberOfComponents(2) datas.SetName(name) for value in fieldValues: datas.InsertNextTuple2(value[0],value[1]) self._resultsPoint.append(datas)
def make_pData_periodic (np, x, a, lattice): pos = vtk.vtkPoints() diameter = vtk.vtkDoubleArray() diameter.SetNumberOfComponents(1) # primary cell for i in range(np): pos.InsertNextPoint(x[i*3], x[i*3+1], x[i*3+2]) if a != []: diameter.InsertNextTuple1(2.0*a[i]) else: diameter.InsertNextTuple1(2.0) # image cells for ix in range(-1,2): for iy in range(-1,2): for iz in range(-1,2): if ix == 0 and iy == 0 and iz == 0: continue for i in range(np): pos.InsertNextPoint(x[i*3 ]+float(ix)*lattice[0], x[i*3+1]+float(iy)*lattice[1], x[i*3+2]+float(iz)*lattice[2]) if a != []: diameter.InsertNextTuple1(2.0*a[i]) else: diameter.InsertNextTuple1(2.0) # first make pData containing particle coordinates pData = vtk.vtkPolyData() pData.SetPoints(pos) pData.GetPointData().SetScalars(diameter) return pData
def convertArray2vtkImage(self, nparray, t_ImagedataVTK, npImagesandMask): """ Takes a numpy.ndarray and converts it to a vtkimageData. require npImagesandMask to pass on image info """ # Create vtk object size_array = npImagesandMask['dims'][0]*npImagesandMask['dims'][1]*npImagesandMask['dims'][2] flatim = nparray.transpose(2,1,0) flatim = flatim.flatten() # create vtk image vtk_image = vtk.vtkImageData() vtk_image.DeepCopy(t_ImagedataVTK) vtk_image.SetNumberOfScalarComponents(1) vtk_image.SetScalarTypeToDouble() vtk_image.AllocateScalars() # Get scalars from numpy image_array = vtk.vtkDoubleArray() image_array.SetNumberOfValues(size_array) image_array.SetNumberOfComponents(1) # not too efficient convertion of np.array to vtk. Far from ideal for k in range(size_array): image_array.InsertTuple1(k,flatim[k]) vtk_image.GetPointData().SetScalars(image_array) vtk_image.Update() return vtk_image
def compute(self): a = self.getInputFromPort("Array") ds = self.getInputFromPort("VTK Data") scalar_name = '' if self.hasInputFromPort("Scalar Name"): scalar_name = self.getInputFromPort("Scalar Name") else: scalar_name = 'scalars' s_ar = a.get_array().flatten() np = ds.vtkInstance.GetNumberOfPoints() # if s_ar.size != np: # raise ModuleError("Could not assign scalars to VTK dataset with different number of elements") pd = ds.vtkInstance.GetPointData() vtk_ar = vtk.vtkDoubleArray() vtk_ar.SetNumberOfValues(np) for i in xrange(np): vtk_ar.SetValue(i, s_ar[i]) vtk_ar.SetName(scalar_name) ds.vtkInstance.GetPointData().AddArray(vtk_ar) # ds.vtkinstance.GetPointData().SetActiveScalars(scalar_name) ds.vtkInstance.GetPointData().SetScalars(vtk_ar) self.setResult("Output", ds)
def make_sphereActor (x, r, rgb, opacity): points = vtk.vtkPoints() points.InsertNextPoint(x[0], x[1], x[2]) diameter = vtk.vtkDoubleArray() diameter.SetNumberOfComponents(1) diameter.InsertNextTuple1(2.0*r) pData = vtk.vtkPolyData() pData.SetPoints(points) pData.GetPointData().SetScalars(diameter) pSource = vtk.vtkSphereSource() pSource.SetPhiResolution(16) pSource.SetThetaResolution(16) pGlyph = vtk.vtkGlyph3D() pGlyph.SetSource(pSource.GetOutput()) pGlyph.SetInput(pData) pGlyph.ScalingOn() pGlyph.SetScaleModeToScaleByScalar() pMapper = vtk.vtkPolyDataMapper() pMapper.ScalarVisibilityOff() pMapper.SetInput(pGlyph.GetOutput()) pActor = vtk.vtkActor() pActor.SetMapper(pMapper) pActor.GetProperty().SetColor(rgb[0], rgb[1], rgb[2]) pActor.GetProperty().SetOpacity(opacity) return pActor
def createPolyData(faces, vtList, verts, tcoords): points = vtk.vtkPoints() points.SetDataTypeToDouble() points.SetNumberOfPoints(len(vtList)) tcoordArray = vtk.vtkDoubleArray() tcoordArray.SetName('tcoords') tcoordArray.SetNumberOfComponents(2) tcoordArray.SetNumberOfTuples(len(vtList)) for i, vt in enumerate(vtList): vi, ti = vt xyz = verts[vi] uv = tcoords[ti] points.SetPoint(i, xyz) tcoordArray.SetTuple2(i, uv[0], uv[1]) cells = vtk.vtkCellArray() for i, face in enumerate(faces): tri = vtk.vtkTriangle() tri.GetPointIds().SetId(0, face[0]) tri.GetPointIds().SetId(1, face[1]) tri.GetPointIds().SetId(2, face[2]) cells.InsertNextCell(tri) polyData = vtk.vtkPolyData() polyData.SetPoints(points) polyData.SetPolys(cells) polyData.GetPointData().SetTCoords(tcoordArray) return polyData
def array_to_vtk(array_in, dtype=None): """Get vtkFloatArray/vtkDoubleArray from the input numpy array.""" if dtype == None: dtype = _numpy.dtype(array_in.dtype) else: dtype = _numpy.dtype(dtype) if dtype == _numpy.float32: float_array = _vtk.vtkFloatArray() elif dtype == _numpy.float64: float_array = _vtk.vtkDoubleArray() elif dtype == _numpy.uint8: float_array = _vtk.vtkUnsignedCharArray() elif dtype == _numpy.int8: float_array = _vtk.vtkCharArray() else: raise ValueError("Wrong format of input array, must be float32 or float64") if len(array_in.shape) != 1 and len(array_in.shape) != 2: raise ValueError("Wrong shape: array must be 1D or 2D.") #float_array.SetNumberOfComponents(_numpy.product(array_in.shape)) # if len(array_in.shape) == 2: # float_array.SetNumberOfComponents(array_in.shape[1]) # elif len(array_in.shape) == 1: # float_array.SetNumberOfComponents(1) float_array.SetNumberOfComponents(1) array_contiguous = _numpy.ascontiguousarray(array_in, dtype) float_array.SetVoidArray(array_contiguous, _numpy.product(array_in.shape), 1) float_array._contiguous_array = array_contiguous # Hack to keep the array of being garbage collected # if len(array_in.shape) == 2: # print "set tuple to {0}".format(array_in.shape[1]) # #float_array.SetNumberOfTuples(array_in.shape[1]) # float_array.Resize(array_in.shape[1]) # float_array.Squeeze() return float_array
def ReadTetrIniFile(self,filename,arrayname): self.PrintLog('Reading '+filename+'.') if (self.Compressed == 1): f=gzip.open(filename, 'r') else: f=open(filename, 'r') line = f.readline() while (line!='$vel_old1'): line = f.readline() line = f.readline() line = f.readline() numberOfTuples = int(line) outputArray = vtk.vtkDoubleArray() outputArray.SetName(arrayname) outputArray.SetNumberOfComponents(3) outputArray.SetNumberOfTuples(numberOfTuples) for i in range(numberOfTuples): line = f.readline() splitline = line.split(' ') value0 = float(splitline[0]) value1 = float(splitline[1]) value2 = float(splitline[2]) outputArray.SetComponent(i,0,value0) outputArray.SetComponent(i,1,value1) outputArray.SetComponent(i,2,value2) self.Mesh.GetPointData().AddArray(outputArray)
def ReadTetrVelFile(self,filename,arrayname): self.PrintLog('Reading '+filename+'.') if self.UnNormalize == 1: self.ReadTetrInDimensionalParameters() if (self.Compressed == 1): f=gzip.open(filename, 'r') else: f=open(filename, 'r') lines = f.readlines() line = lines[0] lineoffset = 1 splitline = line.split(' ') numberOfTuples = int(splitline[0]) iteration = float(splitline[1]) outputArray = vtk.vtkDoubleArray() outputArray.SetName(arrayname) outputArray.SetNumberOfComponents(3) outputArray.SetNumberOfTuples(numberOfTuples) velocityUnNormalizationFactor = self.ReD / (2.0 * self.Radius) * self.Viscosity / self.Density for i in range(numberOfTuples): line = lines[i+lineoffset] splitline = line.split(' ') value0 = float(splitline[0]) value1 = float(splitline[1]) value2 = float(splitline[2]) if self.UnNormalize ==1: value0 *= velocityUnNormalizationFactor value1 *= velocityUnNormalizationFactor value2 *= velocityUnNormalizationFactor outputArray.SetComponent(i,0,value0) outputArray.SetComponent(i,1,value1) outputArray.SetComponent(i,2,value2) self.Mesh.GetPointData().AddArray(outputArray)
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 compute(self): ds = self.getInputFromPort("VTK Data") ar = self.getInputFromPort("Scalars") v_name = self.forceGetInputFromPort("Array Name") if v_name == None: v_name = 'scalars' num_times = ds.vtkInstance.GetNumberOfTimeSteps() ar_ = ar.get_array() if ar_.shape[0] != num_times: raise ModuleError("Cannot process array with num timesteps = " + str(ar_.shape[0]) + " and vtkdata with " + str(num_times) + " timesteps") for i in range(num_times): self.update_progress(i, num_times) s_ar = ar_[i,::].squeeze().flatten() vtk_ar = vtk.vtkDoubleArray() vtk_ar.SetNumberOfValues(s_ar.size) vtk_ar.SetName(v_name) for j in range(s_ar.size): vtk_ar.InsertNextValue(s_ar[j]) ds.vtkInstance.GetTimeStep(i).GetPointData().AddArray(vtk_ar) ds.vtkInstance.GetTimeStep(i).GetPointData().SetScalars(vtk_ar) self.setResult("Output", ds)
def saveTrajectory(sols, outputFile): """ Save the trajectory to VTK file @param sols list of return values of odeint @param filename """ # number of contours nContours = len(sols) # number of points for each contour nptsContour = [sol.shape[0] for sol in sols] # total number of points npts = functools.reduce(lambda x, y: x + y, nptsContour) # total number of segments nSegs = functools.reduce(lambda x, y: x + y, [nps - 1 for nps in nptsContour]) # number of space dimensions ndims = 3 pvals = numpy.zeros((npts, 3), numpy.float64) tarr = vtk.vtkDoubleArray() tpts = vtk.vtkPoints() tgrid = vtk.vtkUnstructuredGrid() tarr.SetNumberOfComponents(ndims) tarr.SetNumberOfTuples(npts) tpts.SetNumberOfPoints(npts) ptIds = vtk.vtkIdList() ptIds.SetNumberOfIds(2) tgrid.Allocate(nSegs, 1) # create the points and the unstructured grid that goes with it offset1 = 0 offset2 = 0 for iContour in range(nContours): ns = nptsContour[iContour] # store points for i in range(ns): pvals[i + offset1, :] = sols[iContour][i] pvals[i + offset1, 0] = max(0., min(360., pvals[i + offset1, 0])) pvals[i + offset1, 1] = max(-90., min(90., pvals[i + offset1, 1])) offset1 += ns # create new cells/segments for i in range(ns - 1): ptIds.SetId(0, i + offset2) ptIds.SetId(1, i + 1 + offset2) tgrid.InsertNextCell(vtk.VTK_LINE, ptIds) offset2 += ns # connect tpts.SetData(tarr) tgrid.SetPoints(tpts) tarr.SetVoidArray(pvals, npts * 3, 1) # save writer = vtk.vtkUnstructuredGridWriter() writer.SetFileName(outputFile) writer.SetInputData(tgrid) writer.Update()
def setup(self): # Instantiate and connect widgets ... ScriptedLoadableModuleWidget.setup(self) # if self.developerMode: # # # # Reload and Test area # # # reloadCollapsibleButton = ctk.ctkCollapsibleButton() # reloadCollapsibleButton.text = "Reload && Test" # self.layout.addWidget(reloadCollapsibleButton) # reloadFormLayout = qt.QFormLayout(reloadCollapsibleButton) # # # reload button # # (use this during development, but remove it when delivering # # your module to users) # self.reloadButton = qt.QPushButton("Reload") # self.reloadButton.toolTip = "Reload this module." # self.reloadButton.name = "VolumeProbe Reload" # reloadFormLayout.addWidget(self.reloadButton) # self.reloadButton.connect('clicked()', self.onReload) # # # reload and test button # # (use this during development, but remove it when delivering # # your module to users) # self.reloadAndTestButton = qt.QPushButton("Reload and Test All") # self.reloadAndTestButton.toolTip = "Reload this module and then run the self tests." # reloadFormLayout.addWidget(self.reloadAndTestButton) # self.reloadAndTestButton.connect('clicked()', self.onReloadAndTest) # # # reload and run specific tests # scenarios = ("Three Volume", "View Watcher", "ROIManager",) # for scenario in scenarios: # button = qt.QPushButton("Reload and Test %s" % scenario) # self.reloadAndTestButton.toolTip = "Reload this module and then run the %s self test." % scenario # reloadFormLayout.addWidget(button) # button.connect('clicked()', lambda s=scenario: self.onReloadAndTest(scenario=s)) # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) """ # # target volume selector # self.inputSelector = slicer.qMRMLNodeComboBox() self.inputSelector.nodeTypes = ( ("vtkMRMLVolumeNode"), "" ) self.inputSelector.selectNodeUponCreation = True self.inputSelector.addEnabled = False self.inputSelector.removeEnabled = False self.inputSelector.noneEnabled = False self.inputSelector.showHidden = False self.inputSelector.showChildNodeTypes = True self.inputSelector.setMRMLScene( slicer.mrmlScene ) self.inputSelector.setToolTip( "Pick the input to the algorithm." ) parametersFormLayout.addRow("Target Volume: ", self.inputSelector) """ # # Add ROI # self.drawROICheck = qt.QCheckBox() parametersFormLayout.addRow("Draw ROI", self.drawROICheck) self.drawROICheck.connect("toggled(bool)", self.onDrawROIToggled) self.ROIRadiusSlider = ctk.ctkSliderWidget() # self.ROIRadiusSlider.setMinimum(1) # self.ROIRadiusSlider.setMaximum(100) self.ROIRadiusSlider.setValue(self.ROIRadius) parametersFormLayout.addRow("ROI Radius", self.ROIRadiusSlider) self.ROIRadiusSlider.connect("valueChanged(double)", self.onROIRadiusChanged) # # Add Histogram self.numBins = qt.QSpinBox() self.numBins.setRange(0, 200) self.numBins.setEnabled(1) self.numBins.setValue(20) parametersFormLayout.addRow("Number of Bins", self.numBins) self.histogramArray = vtk.vtkDoubleArray() self.histogramArray.SetNumberOfComponents(1) self.histogramArray.SetNumberOfTuples(0) self.histogram = ctk.ctkVTKHistogram() self.histogram.setDataArray(self.histogramArray) self.histogram.numberOfBins = self.numBins.value self.histogramView = ctk.ctkTransferFunctionView() self.histogramItem = ctk.ctkTransferFunctionBarsItem(self.histogram) self.histogramItem.barWidth = 0.7 self.histogramView.scene().addItem(self.histogramItem) parametersFormLayout.addRow("Histogram", self.histogramView) self.histogramView.show() self.minField = qt.QSpinBox() self.minField.setRange(-100000, 100000) self.minField.setEnabled(0) parametersFormLayout.addRow("Min Value", self.minField) self.maxField = qt.QSpinBox() self.maxField.setRange(-100000, 100000) self.maxField.setEnabled(0) parametersFormLayout.addRow("Max Value", self.maxField) self.meanField = qt.QSpinBox() self.meanField.setRange(-100000, 100000) self.meanField.setEnabled(0) parametersFormLayout.addRow("Mean Value", self.meanField) self.medianField = qt.QSpinBox() self.medianField.setRange(-100000, 100000) self.medianField.setEnabled(0) parametersFormLayout.addRow("Median Value", self.medianField) self.stdField = qt.QSpinBox() self.stdField.setRange(-100000, 100000) self.stdField.setEnabled(0) parametersFormLayout.addRow("STD Value", self.stdField) # Add vertical spacer self.layout.addStretch(1)
def display_tube(self, gfx, caller): if gfx.ps != None: gfx.renderer.RemoveActor(gfx.ps.acteur) if self.c != '' and self.T != '' and self.U != '' and self.henttype == 'cTU': #CTU CASE ptype = 'delta' self.enttype = 'cTU' deltaz = (self.c / self.U) deltaphi = (self.T * 360.0) / self.U self.dphi = deltaphi self.dz = deltaz elif self.dphi != '' and self.dz != '' and self.henttype == 'Elm-Hel': #DELTA CASE ptype = 'delta' self.enttype = 'Elm-Hel' deltaphi = self.dphi deltaz = self.dz else: MB.showwarning('Info', 'Configure symmetry setting') return try: zmax = gfx.map[0].box.GetBounds()[5] zmin = gfx.map[0].box.GetBounds()[4] z = zmax - zmin except: z = 4 * 360 * abs(self.dz / self.dphi) #ici exeption 'fit' calcule de dz avec ratio !!! if 'fit' in caller: self.c = self.c * gfx.map[0].ratio self.dz = self.dz * gfx.map[0].ratio deltaz = self.dz numPts = int(z / deltaz) self.numpts = numPts #definition du nombre de sm self.cptsymops_tube( ptype, numPts ) #ptype est tjs = a delta on calcule toujours de la même maniere dans symmetry #parameter definition : shifta = radians(deltaphi) phizero = radians(self.phizero) ###definition des boules selon les parametres pdo = vtk.vtkPolyData() newPts = vtk.vtkPoints() #This will store the points for the Helix vals = vtk.vtkDoubleArray() for i in range(0, numPts): try: x = self.radius * gfx.map[0].scale * cos(i * shifta + phizero) y = self.radius * gfx.map[0].scale * sin(i * shifta + phizero) z = zmin + i * deltaz except: x = self.radius * cos(i * shifta + phizero) y = self.radius * sin(i * shifta + phizero) z = i * deltaz newPts.InsertPoint(i, x, y, z) vals.InsertNextValue(i) pdo.SetPoints(newPts) pdo.GetPointData().SetScalars(vals) sphere = vtk.vtkSphereSource() sphere.SetCenter(0, 0, 0) try: sphere.SetRadius(self.radius * gfx.map[0].scale / 5.0) except: sphere.SetRadius(self.radius * (1 / 5.)) sphere.SetThetaResolution(8) sphere.SetStartTheta(0) sphere.SetEndTheta(360) sphere.SetPhiResolution(8) sphere.SetStartPhi(0) sphere.SetEndPhi(180) glyph = vtk.vtkGlyph3D() glyph.SetInput(pdo) glyph.SetColorMode(1) glyph.ScalingOn() glyph.SetScaleMode(2) glyph.SetScaleFactor(0.25) glyph.SetSource(sphere.GetOutput()) self.spheremapper = vtk.vtkPolyDataMapper() self.spheremapper.SetInputConnection(glyph.GetOutputPort()) self.spheremapper.UseLookupTableScalarRangeOff() self.spheremapper.SetScalarVisibility(0) self.sphact = vtk.vtkActor() self.sphact.PickableOff() self.sphact.DragableOff() self.sphact.SetMapper(self.spheremapper) self.sphact.GetProperty().SetRepresentationToSurface() self.sphact.GetProperty().SetInterpolationToGouraud() self.sphact.GetProperty().SetAmbient(0.15) self.sphact.GetProperty().SetDiffuse(0.85) self.sphact.GetProperty().SetSpecular(0.1) self.sphact.GetProperty().SetSpecularPower(100) self.sphact.GetProperty().SetSpecularColor(1, 1, 1) self.sphact.GetProperty().SetColor(1, 1, 1) ###definition de l helice continue enhance = 100 hlxpdo = vtk.vtkPolyData() hlxnewPts = vtk.vtkPoints() #This will store the points for the Helix hlxvals = vtk.vtkDoubleArray() hlxnumPts = int(numPts * enhance) for i in range(0, hlxnumPts): try: x = self.radius * gfx.map[0].scale * cos(i * shifta / enhance + phizero) y = self.radius * gfx.map[0].scale * sin(i * shifta / enhance + phizero) z = zmin + i * deltaz / enhance except: x = self.radius * cos(i * shifta / enhance + phizero) y = self.radius * sin(i * shifta / enhance + phizero) z = i * deltaz / enhance hlxnewPts.InsertPoint(i, x, y, z) hlxvals.InsertNextValue(i) hlxpdo.SetPoints(hlxnewPts) hlxpdo.GetPointData().SetScalars(hlxvals) aPolyLine = vtk.vtkPolyLine() aPolyLine.GetPointIds().SetNumberOfIds(hlxnumPts) for i in range(0, hlxnumPts): aPolyLine.GetPointIds().SetId(i, i) hlxpdo.Allocate(1, 1) hlxpdo.InsertNextCell(aPolyLine.GetCellType(), aPolyLine.GetPointIds()) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetScalarVisibility(0) self.mapper.SetInput(hlxpdo) self.helact = vtk.vtkActor() self.helact.PickableOff() self.helact.DragableOff() self.helact.GetProperty().SetColor(1, 1, 1) self.helact.GetProperty().SetRepresentationToWireframe() self.helact.GetProperty().SetLineWidth(5) self.helact.GetProperty().SetLineWidth(1) self.helact.GetProperty().SetSpecular(.4) self.helact.GetProperty().SetSpecularPower(10) self.helact.SetMapper(self.mapper) assembly = vtk.vtkAssembly() assembly.AddPart(self.sphact) assembly.AddPart(self.helact) helcol = [(1, 1, 1), (1, 0, 0.3), (0.3, 0, 1), (0, 1, 0.3)] for i in range(1, self.s + 1): if i == 1: continue else: tmp_sphact = vtk.vtkActor() tmp_helact = vtk.vtkActor() tmp_sphact.ShallowCopy(self.sphact) tmp_helact.ShallowCopy(self.helact) ps = vtk.vtkProperty() ph = vtk.vtkProperty() ps.SetColor(helcol[(i - 1) % 4]) ph.SetColor(helcol[(i - 1) % 4]) tmp_sphact.SetProperty(ps) tmp_helact.SetProperty(ph) tmp_sphact.RotateWXYZ((360 / self.s) * (i - 1), 0, 0, 1) tmp_helact.RotateWXYZ((360 / self.s) * (i - 1), 0, 0, 1) assembly.AddPart(tmp_sphact) assembly.AddPart(tmp_helact) self.acteur = assembly gfx.renderer.AddActor(self.acteur) gfx.renwin.Render() gfx.ps = self return ptype
def examineFilesIPPAcqTime(self, files): """ This strategy first orders files into lists, where each list is indexed by ImagePositionPatient (IPP). Next, files within each list are ordered by AcquisitionTime attribute. Finally, loadable frames are indexed by AcquisitionTime, and files within each frame are ordered by IPP. This strategy was required to handle DSC MRI data collected on Siemens, tested with a DSC sequence obtained using software version "syngo MR B15" """ loadables = [] subseriesLists = {} orderedFiles = [] desc = slicer.dicomDatabase.fileValue( files[0], self.tags['seriesDescription']) # SeriesDescription minTime = self.tm2ms( slicer.dicomDatabase.fileValue(files[0], self.tags['AcquisitionTime'])) for file in files: ipp = slicer.dicomDatabase.fileValue(file, self.tags['position']) time = self.tm2ms( slicer.dicomDatabase.fileValue(file, self.tags['AcquisitionTime'])) if time < minTime: minTime = time if not subseriesLists.has_key(ipp): subseriesLists[ipp] = {} subseriesLists[ipp][time] = file nSlicesEqual = True allIPPs = subseriesLists.keys() for ipp in subseriesLists.keys(): if len(subseriesLists[allIPPs[0]].keys()) != len( subseriesLists[ipp].keys()): nSlicesEqual = False break if len(subseriesLists[allIPPs[0]].keys()) < 2 or not nSlicesEqual: return [] if nSlicesEqual: nFrames = len(subseriesLists[allIPPs[0]].keys()) nSlices = len(allIPPs) orderedFiles = [0] * nFrames * nSlices frameLabelsStr = "" frameFileListStr = "" frameLabelsArray = vtk.vtkDoubleArray() ippPositionCnt = 0 for ipp in subseriesLists.keys(): timesSorted = subseriesLists[ipp].keys() timesSorted.sort() timeCnt = 0 for time in timesSorted: orderedFiles[timeCnt * nSlices + ippPositionCnt] = subseriesLists[ipp][time] timeCnt = timeCnt + 1 if ippPositionCnt == 0: frameLabelsStr = frameLabelsStr + str(time - minTime) + ',' frameLabelsArray.InsertNextValue(time - minTime) ippPositionCnt = ippPositionCnt + 1 scalarVolumePlugin = slicer.modules.dicomPlugins[ 'DICOMScalarVolumePlugin']() firstFrameTime = 0 for f in range(nFrames): frameFileList = orderedFiles[f * nSlices:(f + 1) * nSlices] svs = scalarVolumePlugin.examine([frameFileList]) if len(svs) == 0: print( 'Failed to parse one of the multivolume frames as scalar volume!' ) break time = self.tm2ms( slicer.dicomDatabase.fileValue( svs[0].files[0], self.tags['AcquisitionTime'])) if f == 0: frameLabelsStr = '0,' frameLabelsArray.InsertNextValue(0) firstFrameTime = time else: frameLabelsStr = frameLabelsStr + str(time - firstFrameTime) + ',' frameLabelsArray.InsertNextValue(time) for file in orderedFiles: frameFileListStr = frameFileListStr + str(file) + ',' frameLabelsStr = frameLabelsStr[:-1] frameFileListStr = frameFileListStr[:-1] mvNode = slicer.mrmlScene.CreateNodeByClass( 'vtkMRMLMultiVolumeNode') mvNode.SetReferenceCount(mvNode.GetReferenceCount() - 1) mvNode.SetScene(slicer.mrmlScene) mvNode.SetAttribute("MultiVolume.FrameLabels", frameLabelsStr) mvNode.SetAttribute("MultiVolume.FrameIdentifyingDICOMTagName", "AcquisitionTime") mvNode.SetAttribute("MultiVolume.ParseStrategy", "AcquisitionTime+ImagePositionPatient") mvNode.SetAttribute('MultiVolume.NumberOfFrames', str(nFrames)) mvNode.SetAttribute('MultiVolume.FrameIdentifyingDICOMTagUnits', "ms") # keep the files in the order by the detected tag # files are not ordered within the individual frames -- this will be # done by ScalarVolumePlugin later mvNode.SetAttribute('MultiVolume.FrameFileList', frameFileListStr) self.addAcquisitionAttributes(mvNode, frameFileList) mvNode.SetNumberOfFrames(nFrames) mvNode.SetLabelName("AcquisitionTime") mvNode.SetLabelArray(frameLabelsArray) loadable = DICOMLib.DICOMLoadable() loadable.files = orderedFiles loadable.name = desc + ' - as a ' + str( nFrames ) + ' frames MultiVolume by ImagePositionPatient+AcquisitionTime' mvNode.SetName(desc) loadable.tooltip = loadable.name loadable.selected = True loadable.multivolume = mvNode loadable.confidence = 1. loadables.append(loadable) return loadables
def getIntegratedQOI(model, sorted_region_nodes, quantities_to_integrate, output_filename, vprint): # Integrated quantities output_collection = [] # Point Averaged quantities output2_collection = [] for i_region in xrange(0, len(sorted_region_nodes)): for j_region in xrange(0, len(sorted_region_nodes[i_region])): print('Working on Region ' + str(i_region + 1) + '_' + str(j_region + 1) + '...') region = extractRegion(model, sorted_region_nodes[i_region][j_region], vprint) writeVTU(region, 'test.vtu', vprint) numPts = region.GetNumberOfPoints() numCells = region.GetNumberOfCells() # Read in your quantities of interest from the .vtp file QOI = [] for i in xrange(0, len(quantities_to_integrate)): QOI.append(vtk.vtkDoubleArray()) QOI[i] = model.GetPointData().GetArray( quantities_to_integrate[i]) # Initialize data structures to store area, point total, and point counts total_area = 0.0 integrated_variables = [] for i in xrange(0, len(quantities_to_integrate)): integrated_variables.append(0.0) point_totals = [] point_counts = [] point_averages = [] for iq in xrange(0, len(quantities_to_integrate)): point_totals.append(0.0) point_counts.append(0) point_averages.append(0.0) for pointID in xrange(0, numPts): # Get the region coordinate pointCoordinate = region.GetPoint(pointID) for iq in xrange(0, len(quantities_to_integrate)): # Find the region coordinate in the model vector = QOI[iq].GetTuple(model.FindPoint(pointCoordinate)) mag = 0 for i in xrange(0, len(vector)): mag = mag + float(vector[i])**2 mag = mag**(.5) # Ignore 0 value points if (mag > 0): point_totals[iq] = point_totals[iq] + mag point_counts[iq] = point_counts[iq] + 1 # Calculate point averaged QOIs for iq in xrange(0, len(quantities_to_integrate)): if (point_counts[iq] > 0): point_averages[iq] = point_totals[iq] / point_counts[iq] # Now loop over the cells and add in contribution to the integrated_variable # that is equal to the average of all the cell nodal values multiplied by # the area of the cell for icell in xrange(0, numCells): temp_cell = region.GetCell(icell) pts_cell = temp_cell.GetPointIds() # First, get the area of this cell vtkpt = temp_cell.GetPoints() p0 = vtkpt.GetPoint(0) p1 = vtkpt.GetPoint(1) p2 = vtkpt.GetPoint(2) temp_area = vtk.vtkTriangle().TriangleArea(p0, p1, p2) total_area = total_area + temp_area # Now, sum up the values of the quantities of interest at the cell # vertices averages = [] for iq in xrange(0, len(quantities_to_integrate)): averages.append(0.0) for ipt in xrange(0, pts_cell.GetNumberOfIds()): iid = pts_cell.GetId(ipt) pointCoordinate = region.GetPoint(iid) for iq in xrange(0, len(quantities_to_integrate)): vector = QOI[iq].GetTuple( model.FindPoint(pointCoordinate)) mag = 0 for i in xrange(0, len(vector)): mag = mag + float(vector[i])**2 mag = mag**(.5) averages[iq] = averages[iq] + mag # To complete the trapezoidal rule integration, multiply each summed quantity # by the area of the cell, then divide by the number of vertices for iq in xrange(0, len(quantities_to_integrate)): integrated_variables[iq] = integrated_variables[iq] + \ averages[iq] * temp_area / float(pts_cell.GetNumberOfIds()) # Now that we have integrated the variables of interest, it is time to save # the results to a list for outputting later temp_collection = [total_area] for iq in xrange(0, len(quantities_to_integrate)): temp_collection.append(integrated_variables[iq]) temp2_collection = [] for iq in xrange(0, len(quantities_to_integrate)): temp2_collection.append(point_averages[iq]) # Stores the integrated values output_collection.append(temp_collection) # Stores the point averaged values output2_collection.append(temp2_collection) # Now that we have looped over all our .vtp files of interest and integrated # the variables, it is time to save them to the output file. We also print # out the integrated quantities divided by the surface area for post-processing # convenience outfile = open(output_filename, 'w') # First print a header that tells what each integrated quantity of interest is out_string = 'Region, Surface area, ' for iq in xrange(0, len(quantities_to_integrate)): out_string = out_string + quantities_to_integrate[iq] + ', ' out_string = out_string + quantities_to_integrate[iq] + "/Area, " out_string = out_string + '\n' outfile.write(out_string) # Print data counter = 0 for i in xrange(0, len(sorted_region_nodes)): for j in xrange(0, len(sorted_region_nodes[i])): out_string = str(i) + '_' + str(j) + ',' + str( output_collection[counter][0]) for iq in xrange(1, len(quantities_to_integrate) + 1): out_string = out_string + ', ' + str( output_collection[counter][iq]) out_string = out_string + ', ' + str( output_collection[counter][iq] / output_collection[i][0]) counter += 1 out_string = out_string + '\n' outfile.write(out_string) outfile.write('\n') # Second print a header point averaged quantity of interests out_string = 'Region, ' for iq in xrange(0, len(quantities_to_integrate)): out_string = out_string + quantities_to_integrate[iq] + ', ' out_string = out_string + '\n' outfile.write(out_string) # Print data counter = 0 for i in xrange(0, len(sorted_region_nodes)): for j in xrange(0, len(sorted_region_nodes[i])): out_string = str(i) + '_' + str(j) + ',' + str( output_collection[counter][0]) for iq in xrange(0, len(quantities_to_integrate)): out_string = out_string + ', ' + str( output2_collection[counter][iq]) counter += 1 out_string = out_string + '\n' outfile.write(out_string) outfile.close()
def clipSurfaceAtEndPoints(self, networkPolyData, surfacePolyData): ''' Clips the surfacePolyData on the endpoints identified using the networkPolyData. Returns a tupel of the form [clippedPolyData, endpointsPoints] ''' # import the vmtk libraries try: import vtkvmtkComputationalGeometryPython as vtkvmtkComputationalGeometry import vtkvmtkMiscPython as vtkvmtkMisc except ImportError: logging.error("Unable to import the SlicerVmtk libraries") cleaner = vtk.vtkCleanPolyData() cleaner.SetInputData(networkPolyData) cleaner.Update() network = cleaner.GetOutput() network.BuildCells() network.BuildLinks(0) endpointIds = vtk.vtkIdList() radiusArray = network.GetPointData().GetArray('Radius') endpoints = vtk.vtkPolyData() endpointsPoints = vtk.vtkPoints() endpointsRadius = vtk.vtkDoubleArray() endpointsRadius.SetName('Radius') endpoints.SetPoints(endpointsPoints) endpoints.GetPointData().AddArray(endpointsRadius) radiusFactor = 1.2 minRadius = 0.01 for i in range(network.GetNumberOfCells()): numberOfCellPoints = network.GetCell(i).GetNumberOfPoints() pointId0 = network.GetCell(i).GetPointId(0) pointId1 = network.GetCell(i).GetPointId(numberOfCellPoints - 1) pointCells = vtk.vtkIdList() network.GetPointCells(pointId0, pointCells) numberOfEndpoints = endpointIds.GetNumberOfIds() if pointCells.GetNumberOfIds() == 1: pointId = endpointIds.InsertUniqueId(pointId0) if pointId == numberOfEndpoints: point = network.GetPoint(pointId0) radius = radiusArray.GetValue(pointId0) radius = max(radius, minRadius) endpointsPoints.InsertNextPoint(point) endpointsRadius.InsertNextValue(radiusFactor * radius) pointCells = vtk.vtkIdList() network.GetPointCells(pointId1, pointCells) numberOfEndpoints = endpointIds.GetNumberOfIds() if pointCells.GetNumberOfIds() == 1: pointId = endpointIds.InsertUniqueId(pointId1) if pointId == numberOfEndpoints: point = network.GetPoint(pointId1) radius = radiusArray.GetValue(pointId1) radius = max(radius, minRadius) endpointsPoints.InsertNextPoint(point) endpointsRadius.InsertNextValue(radiusFactor * radius) polyBall = vtkvmtkComputationalGeometry.vtkvmtkPolyBall() #polyBall.SetInputData(endpoints) polyBall.SetInput(endpoints) polyBall.SetPolyBallRadiusArrayName('Radius') clipper = vtk.vtkClipPolyData() clipper.SetInputData(surfacePolyData) clipper.SetClipFunction(polyBall) clipper.Update() connectivityFilter = vtk.vtkPolyDataConnectivityFilter() connectivityFilter.SetInputData(clipper.GetOutput()) connectivityFilter.ColorRegionsOff() connectivityFilter.SetExtractionModeToLargestRegion() connectivityFilter.Update() clippedSurface = connectivityFilter.GetOutput() outPolyData = vtk.vtkPolyData() outPolyData.DeepCopy(clippedSurface) return [outPolyData, endpointsPoints]
v1=vtk.vtkSelectEnclosedPoints() v1.SetInputConnection(reader.GetOutputPort()) v1.SetSurfaceConnection(rodReader.GetOutputPort()) v1.CheckSurfaceOn () v1.InsideOutOff () v1.SetTolerance (1.0e-6) v1.Update() v1insideArray = v1.GetOutput().GetPointData().GetArray("SelectedPoints"); particleId=[] for x in range(v1insideArray.GetNumberOfTuples()): particleId.append(v1insideArray.GetTuple1(x)) poly=vtk.vtkPolyData() points=vtk.vtkPoints() cells=vtk.vtkCellArray() particle_id=vtk.vtkDoubleArray() particle_id.SetName("ID") particle_id.SetNumberOfComponents(1) radius=vtk.vtkDoubleArray() radius.SetName("RADIUS") radius.SetNumberOfComponents(1) bonds=vtk.vtkIntArray() bonds.SetName("BONDS_ID") bonds.SetNumberOfComponents(1) data=reader.GetOutput() for x in range(data.GetNumberOfPoints()): points.InsertNextPoint(data.GetPoint(x)) radius.InsertNextTuple1(data.GetPointData().GetArray("radius").GetTuple1(x)) particle_id.InsertNextTuple1(particleId[x]) for x in range(data.GetNumberOfCells()): cell=data.GetCell(x)
#a handy point iterator, calls action() on each point def forEachPoint(xlim,ylim,zlim, action): for z in range(0,zlim+1): for y in range(0,ylim+1): for x in range(0,xlim+1): action((x,y,z)) #make geometry points = vtk.vtkPoints() def makeCoordinate(pt): points.InsertNextPoint(pt) forEachPoint(xlim,ylim,zlim, makeCoordinate) sg.SetPoints(points) #make a scalar array scalars = vtk.vtkDoubleArray() scalars.SetNumberOfComponents(1) scalars.SetName("Xcoord") def makeScalar(pt): scalars.InsertNextValue(pt[0]+pt[1]+pt[2]) forEachPoint(xlim,ylim,zlim, makeScalar) sg.GetPointData().SetScalars(scalars) #blank some arbitrarily chosen cells numcells = sg.GetNumberOfCells() if 11 < numcells: sg.BlankCell(11) if 64 < numcells: sg.BlankCell(64) if 164 < numcells: sg.BlankCell(164)
def Execute(self): if (self.InputDirectoryName == None): self.PrintError('Error: no directory.') if (self.Pattern == None): self.PrintError('Error: no pattern.') if (self.FirstTimeStep == None): self.PrintError('Error: no first timestep.') if (self.LastTimeStep == None): self.PrintError('Error: no last timestep.') if (self.VelocityComponentsArrayNames == None): self.PrintError('Error: no VelocityComponentsArrayNames.') for root, dirs, files in os.walk(self.InputDirectoryName): if root == self.InputDirectoryName: fileList = [x for x in files if not (x.startswith('.'))] timeIndexList = range(self.FirstTimeStep, self.LastTimeStep + 1, self.IntervalTimeStep) reader = vmtkmeshreader.vmtkMeshReader() #if self.VelocityVector or self.WsrVector: if self.WsrVector: vectorFromComponents = vmtkmeshvectorfromcomponents.vmtkMeshVectorFromComponents( ) u_name = self.VelocityComponentsArrayNames.split(' ')[0] v_name = self.VelocityComponentsArrayNames.split(' ')[1] w_name = self.VelocityComponentsArrayNames.split(' ')[2] if self.Wsr: taux_name = self.WsrComponentsArrayNames.split(' ')[0] tauy_name = self.WsrComponentsArrayNames.split(' ')[1] tauz_name = self.WsrComponentsArrayNames.split(' ')[2] field = vtk.vtkFieldData() field.AllocateArrays(1) timesteps = vtk.vtkIntArray() timesteps.SetNumberOfComponents(1) timesteps.SetName("timesteps") i = 0 for step in timeIndexList: if (self.Pattern % step).replace(' ', '0') in fileList: timesteps.InsertTuple1(i, step) i += 1 fileName = (self.Pattern % step).replace(' ', '0') timeIndex = step reader.InputFileName = os.path.abspath( os.path.join(self.InputDirectoryName, fileName)) reader.Execute() mesh = reader.Mesh if step == self.FirstTimeStep: mesh.CopyStructure(mesh) self.Mesh = mesh if self.Pressure: p = mesh.GetPointData().GetArray(self.PressureArrayName) p.SetName(self.PressureArrayName + str(step)) self.Mesh.GetPointData().AddArray(p) if self.Wsr: taux = mesh.GetPointData().GetArray(taux_name) taux.SetName(taux_name + str(step)) self.Mesh.GetPointData().AddArray(taux) tauy = mesh.GetPointData().GetArray(tauy_name) tauy.SetName(tauy_name + str(step)) self.Mesh.GetPointData().AddArray(tauy) tauz = mesh.GetPointData().GetArray(tauz_name) tauz.SetName(tauz_name + str(step)) self.Mesh.GetPointData().AddArray(tauz) if self.VelocityVector: j = 0 u_component = vtk.vtkDoubleArray() u_component.SetNumberOfComponents(1) v_component = vtk.vtkDoubleArray() v_component.SetNumberOfComponents(1) w_component = vtk.vtkDoubleArray() w_component.SetNumberOfComponents(1) while j < mesh.GetPointData().GetArray( self.VelocityVectorArrayName).GetNumberOfTuples(): u_val = mesh.GetPointData().GetArray( self.VelocityVectorArrayName).GetComponent(j, 0) v_val = mesh.GetPointData().GetArray( self.VelocityVectorArrayName).GetComponent(j, 1) w_val = mesh.GetPointData().GetArray( self.VelocityVectorArrayName).GetComponent(j, 2) u_component.InsertTuple1(j, u_val) v_component.InsertTuple1(j, v_val) w_component.InsertTuple1(j, w_val) j += 1 u_component.SetName(u_name + "_" + str(step)) self.Mesh.GetPointData().AddArray(u_component) v_component.SetName(v_name + "_" + str(step)) self.Mesh.GetPointData().AddArray(v_component) w_component.SetName(w_name + "_" + str(step)) self.Mesh.GetPointData().AddArray(w_component) else: u = mesh.GetPointData().GetArray(u_name) u.SetName(u_name + "_" + str(step)) self.Mesh.GetPointData().AddArray(u) v = mesh.GetPointData().GetArray(v_name) v.SetName(v_name + "_" + str(step)) self.Mesh.GetPointData().AddArray(v) w = mesh.GetPointData().GetArray(w_name) w.SetName(w_name + "_" + str(step)) self.Mesh.GetPointData().AddArray(w) if self.WsrVector: vectorFromComponents.Mesh = self.Mesh vectorFromComponents.VectorArrayName = "Wsr_" + str(step) vectorFromComponents.ComponentsArrayNames = [ taux.GetName(), tauy.GetName(), tauz.GetName() ] vectorFromComponents.RemoveComponentArrays = True vectorFromComponents.Execute() field.AddArray(timesteps) self.Mesh.SetFieldData(field)
def creaEstrucDatosDiagrama(self): # Crea las estructuras de datos necesarias para crear el diagrama. self.initializeMinMax() self.points = vtk.vtkPoints() self.escalares = vtk.vtkDoubleArray() self.cells = vtk.vtkCellArray()
def main(): points = vtk.vtkPoints() points.InsertNextPoint(0.0, 0.0, 0.0) points.InsertNextPoint(1.0, 0.0, 0.0) points.InsertNextPoint(2.0, 0.0, 0.0) points.InsertNextPoint(3.0, 0.0, 0.0) points.InsertNextPoint(4.0, 0.0, 0.0) lines = vtk.vtkCellArray() line = vtk.vtkLine() line.GetPointIds().SetId(0, 0) line.GetPointIds().SetId(1, 1) lines.InsertNextCell(line) line.GetPointIds().SetId(0, 1) line.GetPointIds().SetId(1, 2) lines.InsertNextCell(line) line.GetPointIds().SetId(0, 2) line.GetPointIds().SetId(1, 3) lines.InsertNextCell(line) line.GetPointIds().SetId(0, 3) line.GetPointIds().SetId(1, 4) lines.InsertNextCell(line) warpData = vtk.vtkDoubleArray() warpData.SetNumberOfComponents(3) warpData.SetName("warpData") warp = [0.0, 0.0, 0.0] warp[1] = 0.0 warpData.InsertNextTuple(warp) warp[1] = 0.1 warpData.InsertNextTuple(warp) warp[1] = 0.3 warpData.InsertNextTuple(warp) warp[1] = 0.0 warpData.InsertNextTuple(warp) warp[1] = 0.1 warpData.InsertNextTuple(warp) polydata = vtk.vtkPolyData() polydata.SetPoints(points) polydata.SetLines(lines) polydata.GetPointData().AddArray(warpData) polydata.GetPointData().SetActiveVectors(warpData.GetName()) # WarpVector will use the array marked as active vector in polydata # it has to be a 3 component array # with the same number of tuples as points in polydata warpVector = vtk.vtkWarpVector() if VTK_MAJOR_VERSION <= 5: warpVector.SetInput(polydata) else: warpVector.SetInputData(polydata) warpVector.Update() mapper = vtk.vtkPolyDataMapper() if VTK_MAJOR_VERSION <= 5: mapper.SetInput(warpVector.GetPolyDataOutput()) else: mapper.SetInputData(warpVector.GetPolyDataOutput()) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderer.AddActor(actor) renderer.SetBackground(.3, .6, .3) renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderWindow.Render() renderWindowInteractor.Start() return
pts.SetPoint(count,xy_new[i,j,k],yx_new[i,j,k],zx_new[i,j,k]) count = count +1 print("Endding of Point creation") #Create UNstructured grid and add the points ug = vtk.vtkUnstructuredGrid() ug.SetPoints(pts) #Probe filter to extract image pixel intensities in specific coordinates probe = vtk.vtkProbeFilter() probe.SetInputData(ug) probe.SetSourceData(t) probe.Update() samples = probe.GetOutput() samples = samples.GetPointData() samples = samples.GetScalars() #Create array with all pixel intensities extracted w = vtk.vtkDoubleArray() w.SetNumberOfTuples(samples.GetNumberOfTuples()) for i in range(samples.GetNumberOfTuples()): w.SetTuple1(i,samples.GetTuple1(i)) #Check paraview ug.GetPointData().AddArray(w) wr = vtk.vtkXMLUnstructuredGridWriter() wr.SetInputData(ug) wr.SetFileName("test.vtu") wr.EncodeAppendedDataOff() wr.Write() #Create Image output = vtk.vtkImageData() output.SetDimensions(xy_new.shape) output.AllocateScalars(vtk.VTK_DOUBLE,0) # output.SetDirectionMatrix(R[0,0],R[0,1],R[0,2],R[1,0],R[1,1],R[1,2],R[2,0],R[2,1],R[2,2])
file_handle = open(outPrefix + '/header.xml', 'w') file_handle.write(prettify(root)) file_handle.close() # medial points and polygons first medial_points = vtk.vtkPoints() medial_points.SetDataTypeToDouble( ) # important, this fix the bug that new srep has different precision with legacy one, you can find it by runningapplyTps2NewSrep program medial_polys = vtk.vtkCellArray() # This will be curves crest_points = vtk.vtkPoints() crest_polys = vtk.vtkCellArray() # up_spoke_directions = vtk.vtkDoubleArray() up_spoke_directions.SetNumberOfComponents(3) up_spoke_directions.SetName("spokeDirection") up_spoke_lengths = vtk.vtkDoubleArray() up_spoke_lengths.SetNumberOfComponents(1) up_spoke_lengths.SetName("spokeLength") down_spoke_directions = vtk.vtkDoubleArray() down_spoke_directions.SetNumberOfComponents(3) down_spoke_directions.SetName("spokeDirection") down_spoke_lengths = vtk.vtkDoubleArray() down_spoke_lengths.SetNumberOfComponents(1) down_spoke_lengths.SetName("spokeLength")
idList.InsertNextId(xyzToNode[i+1][j+1][k]) idList.InsertNextId(xyzToNode[i+1][j+1][k+1]) idList.InsertNextId(xyzToNode[i+1][j][k+1]) ugrid.InsertNextCell(VTK_HEXAHEDRON, idList) # Add the fields pointdata = ugrid.GetPointData() # NOTE: we cache the grid to speed up the conversion - not valid with variable meshes for f in files: f3d = Spherical_3D_multi(f) for index, vals in f3d.vals.items(): data = vtk.vtkDoubleArray() data.SetNumberOfValues(len(vals)) data.SetName('f'+index) for i, v in enumerate(vals): data.SetValue(i, v) pointdata.AddArray(data) pointdata.SetActiveScalars('f'+index) gridwriter = vtk.vtkXMLUnstructuredGridWriter() gridwriter.SetFileName(os.path.join("Spherical_3D", "full3d_"+f3d.basefilename+".vtu")) if vtk.vtkVersion.GetVTKMajorVersion() <= 5: gridwriter.SetInput(ugrid) else: gridwriter.SetInputData(ugrid) gridwriter.Write()
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.SetInputData(activeSegmentMapper.GetInput()) 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()
def export2vtk(self, filename): """This method call saves existing fields into a vtk file for visualization in e.g Paraview. This function has a dependency on VTK and the Python bindings vtk.""" logging.info('exporting network to VTK format...') try: import vtk from vtk.util import numpy_support except ImportError: logging.warning( 'Package VTK cannot be found, abort export to VTK format.') return self.clean_network() points = vtk.vtkPoints() # node-based quantities for n, node in enumerate(self.nodes): points.InsertPoint(n, node.x, node.y, node.z) if self.heads is not None: head = numpy_support.numpy_to_vtk(num_array=self.heads.ravel(), deep=True, array_type=vtk.VTK_FLOAT) head.SetName("h (m)") if self.node_throughflows is not None: throughflows = numpy_support.numpy_to_vtk( self.node_throughflows.ravel(), True, array_type=vtk.VTK_FLOAT) throughflows.SetName("Node throughflows (m**3/s)") if self.boundary_flows is not None: boundary_flows = numpy_support.numpy_to_vtk( self.boundary_flows.ravel(), True, array_type=vtk.VTK_FLOAT) boundary_flows.SetName("Local boundary flows (m**3/s)") if self.components is not None: components = numpy_support.numpy_to_vtk(self.components.ravel(), True, array_type=vtk.VTK_INT) components.SetName("Connected components (id)") lines = vtk.vtkCellArray() # channel-based quantities conductances, lengths, widths = vtk.vtkDoubleArray( ), vtk.vtkDoubleArray(), vtk.vtkDoubleArray() apertures, flows = vtk.vtkDoubleArray(), vtk.vtkDoubleArray() conductances.SetName("C (m**2/s)") lengths.SetName("L (m)") widths.SetName("W (m)") apertures.SetName("b (m)") flows.SetName("Q (m**3/s)") for k, v in self.channels.items(): lines.InsertNextCell(2) lines.InsertCellPoint(k[0]) lines.InsertCellPoint(k[1]) conductances.InsertNextValue(v.conductance) lengths.InsertNextValue(v.length) widths.InsertNextValue(v.width) apertures.InsertNextValue(v.aperture) flows.InsertNextValue(v.flow) profile = vtk.vtkPolyData() profile.SetPoints(points) # node-based data if self.heads is not None: profile.GetPointData().AddArray(head) if self.node_throughflows is not None: profile.GetPointData().AddArray(throughflows) if self.boundary_flows is not None: profile.GetPointData().AddArray(boundary_flows) if self.components is not None: profile.GetPointData().SetScalars(components) profile.SetLines(lines) # channel-based data profile.GetCellData().SetScalars(conductances) profile.GetCellData().AddArray(lengths) profile.GetCellData().AddArray(widths) profile.GetCellData().AddArray(apertures) profile.GetCellData().AddArray(flows) writer = vtk.vtkXMLPolyDataWriter() writer.SetFileName(filename + ".vtp") try: writer.SetInputData(profile) except AttributeError: writer.SetInput(profile) writer.Write() logging.info('...done')
def meshgrid_slice(meshgrid, x0, x1, y0, y1, main): #Data Parameter ndata = len(meshgrid[:, 0]) nx = len(np.unique(meshgrid[:, 0])) ny = len(np.unique(meshgrid[:, 1])) nz = int(ndata / nx / ny) minx = min(meshgrid[:, 0]) miny = min(meshgrid[:, 1]) delx = meshgrid[nz, 0] - meshgrid[nz - 1, 0] dely = meshgrid[nz * nx, 1] - meshgrid[nz * nx - 1, 1] #Mesh Creation d = (delx + dely) / 2 r = ((x1 - x0)**2 + (y1 - y0)**2)**0.5 dr = r / (int(r / d)) mesh = np.zeros((4, 4)) nsec = int(r / d) + 1 section = np.zeros((nsec * nz, 4)) for i in range(nsec): x = x0 + dr * i * (x1 - x0) / r y = y0 + dr * i * (y1 - y0) / r nmx = int((x0 + d * i * (x1 - x0) / r - minx) / delx) nmy = int((y0 + d * i * (y1 - y0) / r - miny) / dely) #--Interpolasi Liniar for h in range(nz): section[i * nz + h, 0] = x section[i * nz + h, 1] = y #Neighbors mesh[0, :] = meshgrid[(nx * (nmy + 0) + nmx + 0) * nz + h, :] mesh[1, :] = meshgrid[(nx * (nmy + 0) + nmx + 1) * nz + h, :] mesh[2, :] = meshgrid[(nx * (nmy + 1) + nmx + 0) * nz + h, :] mesh[3, :] = meshgrid[(nx * (nmy + 1) + nmx + 1) * nz + h, :] #Elevation Interpolation a0 = ((mesh[1, 2] - mesh[0, 2]) / (mesh[1, 0] - mesh[0, 0]) * (section[i * nz + h, 0] - mesh[0, 0])) + mesh[0, 2] b0 = ((mesh[3, 2] - mesh[2, 2]) / (mesh[3, 0] - mesh[2, 0]) * (section[i * nz + h, 0] - mesh[2, 0])) + mesh[2, 2] section[i * nz + h, 2] = ((b0 - a0) / (mesh[2, 1] - mesh[0, 1]) * (section[i * nz + h, 1] - mesh[0, 1])) + a0 a0 = ((mesh[1, 3] - mesh[0, 3]) / (mesh[1, 0] - mesh[0, 0]) * (section[i * nz + h, 0] - mesh[0, 0])) + mesh[0, 3] b0 = ((mesh[3, 3] - mesh[2, 3]) / (mesh[3, 0] - mesh[2, 0]) * (section[i * nz + h, 0] - mesh[2, 0])) + mesh[2, 3] section[i * nz + h, 3] = np.log10(((b0 - a0) / (mesh[2, 1] - mesh[0, 1]) * (section[i * nz + h, 1] - mesh[0, 1])) + a0) #--Creating Vtk Object #Create Polygon points = vtk.vtkPoints() mesh = vtk.vtkUnstructuredGrid() scalar = vtk.vtkDoubleArray() #Filling Points for i in range(nsec * nz): points.InsertNextPoint(section[i, 0], section[i, 1], section[i, 2]) #Insert Cells quad = vtk.vtkQuad() for i in range(nsec - 1): for h in range(nz - 1): quad.GetPointIds().SetId(0, nz * i + 0) quad.GetPointIds().SetId(1, nz * i + 1) quad.GetPointIds().SetId(2, nz * (i + 1) + 1) quad.GetPointIds().SetId(3, nz * (i + 1) + 0) mesh.InsertNextCell(quad.GetCellType(), quad.GetPointIds()) #Cell Scalar Value value = (section[nz * i + 0, 3] + section[nz * i + 1, 3] + section[nz * (i + 1) + 1, 3] + section[nz * (i + 1) + 0, 3]) / 4 scalar.InsertNextTuple([np.log10(value) * 0.5]) mesh.SetPoints(points) mesh.GetCellData().SetScalars(scalar) main.mesh_renderer(mesh) return section #point = np.array([[795727, 9197285, 0, 0], [795727, 9197285, 0, 0]]) #data = np.loadtxt("D:\WORK\MODEL_WNI\data\mesh_adj.txt") #a = xyzv_krigging(data, point)
def test_array2vtk(self): """Test Numeric array to VTK array conversion and vice-versa.""" # Put all the test arrays here. t_z = [] # Test the different types of arrays. t_z.append(numpy.array([-128, 0, 127], numpy.int8)) # FIXME: character arrays are a problem since there is no # unique mapping to a VTK data type and back. #t_z.append(numpy.array([-128, 0, 127], numpy.character)) t_z.append(numpy.array([-32768, 0, 32767], numpy.int16)) t_z.append(numpy.array([-2147483648, 0, 2147483647], numpy.int32)) t_z.append(numpy.array([0, 255], numpy.uint8)) t_z.append(numpy.array([0, 65535], numpy.uint16)) t_z.append(numpy.array([0, 4294967295L], numpy.uint32)) t_z.append(numpy.array([-1.0e38, 0, 1.0e38], 'f')) t_z.append(numpy.array([-1.0e299, 0, 1.0e299], 'd')) # Check multi-component arrays. t_z.append(numpy.array([[1], [2], [300]], 'd')) t_z.append(numpy.array([[1, 20], [300, 4000]], 'd')) t_z.append(numpy.array([[1, 2, 3], [4, 5, 6]], 'f')) t_z.append(numpy.array([[1, 2, 3], [4, 5, 6]], 'd')) t_z.append(numpy.array([[1, 2, 3, 400], [4, 5, 6, 700]], 'd')) t_z.append(numpy.array([range(9), range(10, 19)], 'f')) # Test if a Python list also works. t_z.append(numpy.array([[1., 2., 3., 400.], [4, 5, 6, 700]], 'd')) # Test if arrays with number of components not in [1,2,3,4,9] work. t_z.append( numpy.array([[1, 2, 3, 400, 5000], [4, 5, 6, 700, 8000]], 'd')) t_z.append(numpy.array([range(10), range(10, 20)], 'd')) for z in t_z: vtk_arr = array_handler.array2vtk(z) # Test for memory leaks. self.assertEqual(vtk_arr.GetReferenceCount(), array_handler.BASE_REFERENCE_COUNT) self._check_arrays(z, vtk_arr) z1 = array_handler.vtk2array(vtk_arr) if len(z.shape) == 1: self.assertEqual(len(z1.shape), 1) if z.dtype.char != 'c': #print z1 self.assertEqual(sum(numpy.ravel(z) - numpy.ravel(z1)), 0) else: #print z1.astype('c') self.assertEqual(z, z1.astype('c')) # Check if type conversion works correctly. z = numpy.array([-128, 0, 127], numpy.int8) vtk_arr = vtk.vtkDoubleArray() ident = id(vtk_arr) vtk_arr = array_handler.array2vtk(z, vtk_arr) # Make sure this is the same array! self.assertEqual(ident, id(vtk_arr)) self._check_arrays(z, vtk_arr) # Check the vtkBitArray. vtk_arr = vtk.vtkBitArray() vtk_arr.InsertNextValue(0) vtk_arr.InsertNextValue(1) vtk_arr.InsertNextValue(0) vtk_arr.InsertNextValue(1) arr = array_handler.vtk2array(vtk_arr) self.assertEqual(numpy.sum(arr - [0, 1, 0, 1]), 0) vtk_arr = array_handler.array2vtk(arr, vtk_arr) self.assertEqual(vtk_arr.GetValue(0), 0) self.assertEqual(vtk_arr.GetValue(1), 1) self.assertEqual(vtk_arr.GetValue(2), 0) self.assertEqual(vtk_arr.GetValue(3), 1) # ---------------------------------------- # Test if the array is copied or not. a = numpy.array([[1, 2, 3], [4, 5, 6]], 'd') vtk_arr = array_handler.array2vtk(a) # Change the numpy array and see if the changes are # reflected in the VTK array. a[0] = [10.0, 20.0, 30.0] self.assertEqual(vtk_arr.GetTuple3(0), (10., 20., 30.)) # Make sure the cache is doing its job. key = vtk_arr.__this__ z = array_handler._array_cache.get(vtk_arr) self.assertEqual(numpy.sum(z - numpy.ravel(a)), 0.0) l1 = len(array_handler._array_cache) # del the Numeric array and see if this still works. del a self.assertEqual(vtk_arr.GetTuple3(0), (10., 20., 30.)) # Check the cache -- just making sure. self.assertEqual(len(array_handler._array_cache), l1) # Delete the VTK array and see if the cache is cleared. del vtk_arr self.assertEqual(len(array_handler._array_cache), l1 - 1) self.assertEqual(array_handler._array_cache._cache.has_key(key), False) # Make sure bit arrays are copied. vtk_arr = vtk.vtkBitArray() a = numpy.array([0, 1, 0, 1], numpy.int32) vtk_arr = array_handler.array2vtk(a, vtk_arr) del a self.assertEqual(vtk_arr.GetValue(0), 0) self.assertEqual(vtk_arr.GetValue(1), 1) self.assertEqual(vtk_arr.GetValue(2), 0) self.assertEqual(vtk_arr.GetValue(3), 1) # Make sure the code at least runs for all the non-complex # numerical dtypes in numpy. for dtype in (numpy.sctypes['int'] + numpy.sctypes['uint'] + numpy.sctypes['float']): array_handler.array2vtk(numpy.zeros((1, ), dtype=dtype))
def exportToTable(self, table, nonEmptyKeysOnly=True): """ Export statistics to table node """ tableWasModified = table.StartModify() table.RemoveAllColumns() keys = self.getNonEmptyKeys() if nonEmptyKeysOnly else self.keys columnHeaderNames, uniqueColumnHeaderNames = self.getHeaderNames( nonEmptyKeysOnly) # Define table columns statistics = self.getStatistics() for key in keys: # create table column appropriate for data type; currently supported: float, int, long, string measurements = [ statistics[segmentID, key] for segmentID in statistics["SegmentIDs"] if statistics.has_key((segmentID, key)) ] if len( measurements ) == 0: # there were not measurements and therefore use the default "string" representation col = table.AddColumn() elif type(measurements[0]) in [int, long]: col = table.AddColumn(vtk.vtkLongArray()) elif type(measurements[0]) is float: col = table.AddColumn(vtk.vtkDoubleArray()) else: # default col = table.AddColumn() plugin = self.getPluginByKey(key) columnName = uniqueColumnHeaderNames[key] longColumnName = columnHeaderNames[key] col.SetName(columnName) if plugin: table.SetColumnProperty(columnName, "Plugin", plugin.name) longColumnName += '<br>Computed by ' + plugin.name + ' Statistics plugin' table.SetColumnLongName(columnName, longColumnName) measurementInfo = statistics["MeasurementInfo"][ key] if key in statistics["MeasurementInfo"] else {} if measurementInfo: for mik, miv in measurementInfo.iteritems(): if mik == 'description': table.SetColumnDescription(columnName, str(miv)) elif mik == 'units': table.SetColumnUnitLabel(columnName, str(miv)) else: table.SetColumnProperty(columnName, str(mik), str(miv)) # Fill columns for segmentID in statistics["SegmentIDs"]: rowIndex = table.AddEmptyRow() columnIndex = 0 for key in keys: value = statistics[segmentID, key] if statistics.has_key( (segmentID, key)) else None if value is None and key != 'Segment': value = float('nan') table.GetTable().GetColumn(columnIndex).SetValue( rowIndex, value) columnIndex += 1 table.Modified() table.EndModify(tableWasModified)
def __get_contour_data_vtk(self, x_grid, y_grid, z_grid, isovalue=[0]): """ wrapper for vtk marching squares function. Extracting contour information into bokeh compatible data type. Less comfortable (no text labels, no coloring) but faster then __get_contour_data_mpl :param x_grid: :param y_grid: :param z_grid: :param isovalue: :return: """ nx, ny = x_grid.shape xmin = self._plot.x_range.start xmax = self._plot.x_range.end ymin = self._plot.y_range.start ymax = self._plot.y_range.end hx = (xmax - xmin) / (nx - 1) hy = (ymax - ymin) / (ny - 1) image = vtk.vtkImageData() image.SetDimensions(nx, ny, 1) image.SetOrigin(xmin, ymin, 0) image.SetSpacing(hx, hy, 0) data = vtk.vtkDoubleArray() data.SetNumberOfComponents(1) data.SetNumberOfTuples(image.GetNumberOfPoints()) data.SetName("Values") # we load the z_data into vtk datatypes vtk_data_array = numpy_support.numpy_to_vtk(z_grid.ravel(), deep=True, array_type=vtk.VTK_DOUBLE) image.AllocateScalars(vtk.VTK_DOUBLE, 1) image.GetPointData().SetScalars(vtk_data_array) # apply marchign squares ms = vtk.vtkMarchingSquares() ms.SetInputData(image) for i in range(isovalue.__len__()): # set isovalues ms.SetValue(i, isovalue[i]) ms.SetImageRange(0, image.GetDimensions()[0], 0, image.GetDimensions()[1], 0, 0) ms.Update() # read output poly = ms.GetOutput() points = poly.GetPoints() lines = poly.GetLines() pts = numpy_support.vtk_to_numpy(points.GetData()) # get points line_idx = numpy_support.vtk_to_numpy(lines.GetData()) # get lines # lines are encoded as [nVerticesLine1, firstId, secondId, ... , nVerticesLine2...] # We always have 2 vertices per line. This justifies the stride 3 pattern below even_idx = line_idx[1::3] odd_idx = line_idx[2::3] x0 = pts[odd_idx, 0] y0 = pts[odd_idx, 1] x1 = pts[even_idx, 0] y1 = pts[even_idx, 1] data_contour = {'x0': x0, 'x1': x1, 'y0': y0, 'y1': y1} data_contour_label = {} return data_contour, data_contour_label
x0, y0, z0 = points.GetPoint(ptId0) x1, y1, z1 = points.GetPoint(ptId1) # retreat by a tiny bit in order to capture multivalued jumps #x1 = x0 + (x1 - x0)*(1. - EPS) #y1 = y0 + (y1 - y0)*(1. - EPS) #z1 = z0 + (z1 - z0)*(1. - EPS) lam0, the0 = getLambdaTheta(x0, y0, z0) lam1, the1 = getLambdaTheta(x1, y1, z1) divVal += getCosThetaDLambda(lam0, the0, lam1, the1) divVal -= 0.5 * alpha * getSinTwoThetaDLambda(lam0, the0, lam1, the1) divData[cellId] = divVal # attach cell centred values to the grid dataArray = vtk.vtkDoubleArray() dataArray.SetNumberOfComponents(1) dataArray.SetNumberOfTuples(numCells) save = 1 dataArray.SetVoidArray(divData, numCells, save) grid.GetCellData().SetScalars(dataArray) # save/show cs.save('divLatLon1.vtk') cs.show()
def initMultiVolumes(self, files, prescribedTags=None): tag2ValueFileList = {} multivolumes = [] if prescribedTags == None: consideredTags = self.multiVolumeTags.keys() else: consideredTags = prescribedTags # iterate over all files for file in files: # iterate over the tags that can be used to separate individual frames for frameTag in consideredTags: try: tagValue2FileList = tag2ValueFileList[frameTag] except: tagValue2FileList = {} tag2ValueFileList[frameTag] = tagValue2FileList tagValueStr = slicer.dicomDatabase.fileValue( file, self.tags[frameTag]) if tagValueStr == '': # not found? continue if frameTag == 'AcquisitionTime' or frameTag == 'SeriesTime' or frameTag == 'ContentTime': # extra parsing is needed to convert from DICOM TM VR into ms tagValue = self.tm2ms(tagValueStr) # convert to ms elif frameTag == "GE.B-value": try: # Parse this: # (0043,1039) IS [1000001250\8\0\0] # 16, 4 Unknown Tag & Data # GE Discovery w750 tagValue = float( int(tagValueStr.split('\\')[0]) % 100000) except: continue elif frameTag == "CardiacCycle": try: # Parse this: # TP0PC0965, PULSTART_P0020PC, PULSEND_P0080PC... # TP10PC0965, PULSTART_P0020PC, PULSEND_P0080PC... # TP30PC0965, PULSTART_P0020PC, PULSEND_P0080PC... cardiacPhaseInfo = tagValueStr.split('\\')[ 0] # TP0PC0965 matched = re.search("TP(\d+)PC(\d+)", cardiacPhaseInfo) tagValue = float(matched.groups()[0]) except: continue else: try: tagValue = float(tagValueStr) except: continue try: tagValue2FileList[tagValue].append(file) except: tagValue2FileList[tagValue] = [file] # iterate over the parsed items and decide which ones can qualify as mv for frameTag in self.multiVolumeTags.keys(): try: tagValue2FileList = tag2ValueFileList[frameTag] except: # didn't find the tag continue if len(tagValue2FileList) < 2: # not enough frames for this tag to be a multivolume continue tagValues = tagValue2FileList.keys() # sort the frames tagValues.sort() firstFrameSize = len(tagValue2FileList[tagValues[0]]) frameInvalid = False for tagValue in tagValues: if len(tagValue2FileList[tagValue]) != firstFrameSize: # number of frames does not match frameInvalid = True if frameInvalid == True: continue # TODO: add a check to confirm individual frames have the same geometry # (check pixel dimensions, orientation, position) # now this looks like a serious mv! # initialize the needed attributes for a new mvNode frameFileListStr = "" frameLabelsStr = "" frameLabelsArray = vtk.vtkDoubleArray() tagValue0 = tagValues[0] for tagValue in tagValues: frameFileList = tagValue2FileList[tagValue] for file in frameFileList: frameFileListStr = frameFileListStr + file + ',' # if mv was parsed by series time, probably makes sense to start from 0 if frameTag == 'SeriesTime' or frameTag == 'AcquisitionTime' or frameTag == 'ContentTime': frameLabelsArray.InsertNextValue(tagValue - tagValue0) frameLabelsStr = frameLabelsStr + str(tagValue - tagValue0) + ',' else: frameLabelsArray.InsertNextValue(tagValue) frameLabelsStr = frameLabelsStr + str(tagValue) + ',' frameFileListStr = frameFileListStr[:-1] frameLabelsStr = frameLabelsStr[:-1] mvNode = slicer.mrmlScene.CreateNodeByClass( 'vtkMRMLMultiVolumeNode') mvNode.UnRegister(None) mvNode.SetAttribute("MultiVolume.FrameLabels", frameLabelsStr) mvNode.SetAttribute("MultiVolume.FrameIdentifyingDICOMTagName", frameTag) mvNode.SetAttribute('MultiVolume.NumberOfFrames', str(len(tagValue2FileList))) mvNode.SetAttribute('MultiVolume.FrameIdentifyingDICOMTagUnits', self.multiVolumeTagsUnits[frameTag]) # keep the files in the order by the detected tag # files are not ordered within the individual frames -- this will be # done by ScalarVolumePlugin later mvNode.SetAttribute('MultiVolume.FrameFileList', frameFileListStr) mvNode.SetNumberOfFrames(len(tagValue2FileList)) mvNode.SetLabelName(self.multiVolumeTagsUnits[frameTag]) mvNode.SetLabelArray(frameLabelsArray) self.addAcquisitionAttributes(mvNode, frameFileList) # add the node multivolumes.append(mvNode) return multivolumes
if len(z) == 0: z = [0] if len(t) == 0: t = [0] # need to check for repeated values as i haven't # considered them below if len(x) != len(set(x)) or len(y) != len(set(y)) or len(z) != len(set(z)): sys.stderr.write( "griddeddata_to_vtk cannot handle repeated X, Y or Z values\n") sys.exit(4) if opts.verbose: sys.stdout.write("Creating the VTR base grid\n") # create the vtr grid xArray = vtk.vtkDoubleArray() for val in sorted(x): xArray.InsertNextValue(val) yArray = vtk.vtkDoubleArray() for val in sorted(y): yArray.InsertNextValue(val) zArray = vtk.vtkDoubleArray() for val in sorted(z): zArray.InsertNextValue(val) # create the vtkRectilinearGrid grid = vtk.vtkRectilinearGrid() grid.SetDimensions(xArray.GetNumberOfTuples(), yArray.GetNumberOfTuples(), zArray.GetNumberOfTuples())
lateralunit = pieces[3] if pieces[1] == 'Height:': height = float(pieces[2]) lateralunit = pieces[3] if pieces[1] == 'Value' and pieces[2] == 'units:': elevationunit = pieces[3] if options.scaling == 0.0: options.scaling = scalingFactor[lateralunit][elevationunit] elevation = np.loadtxt(file) * options.scaling grid = vtk.vtkRectilinearGrid() grid.SetDimensions(elevation.shape[1], elevation.shape[0], 1) xCoords = vtk.vtkDoubleArray() for x in np.arange(0.0, width, width / elevation.shape[1], 'd'): xCoords.InsertNextValue(x) yCoords = vtk.vtkDoubleArray() for y in np.arange(0.0, height, height / elevation.shape[0], 'd'): yCoords.InsertNextValue(y) zCoords = vtk.vtkDoubleArray() zCoords.InsertNextValue(0.0) grid.SetXCoordinates(xCoords) grid.SetYCoordinates(yCoords) grid.SetZCoordinates(zCoords) vector = vtk.vtkFloatArray() vector.SetName("elevation") vector.SetNumberOfComponents(3)
def GenerateParticles(): (mesh, minPoint, maxPoint) = STLMESH("particles.stl") mntable = MNTable3D(minPoint, maxPoint, 2.0 * RMAX, 1) taskai = [] for x in range(len(taskai)): S = Sphere( Vector3(float(taskai[x][0]), float(taskai[x][1]), float(taskai[x][2])), float(taskai[x][3])) mntable.insert(S, 0) yra = 1 packer = InsertGenerator3D(R, R, 100, 1000, 1.0e-9, True) packer.generatePacking(mesh, mntable, 0, 1) mntable.write("tempas.vtu", 2) reader = vtk.vtkXMLUnstructuredGridReader() reader.SetFileName("tempas.vtu") reader.Update() poly = vtk.vtkPolyData() poly.SetPoints(reader.GetOutput().GetPoints()) KIEKIS = poly.GetNumberOfPoints() rad_seg = vtk.vtkDoubleArray() rad_seg.SetName("UNIQUE_RADIUS") rad_seg.SetNumberOfComponents(1) rad_seg.SetNumberOfTuples(2) rad_seg.SetTuple1(0, R) rad_seg.SetTuple1(1, R_KLIUTIS) rad = vtk.vtkDoubleArray() rad.SetName("RADIUS") rad.SetNumberOfComponents(1) rad.SetNumberOfTuples(KIEKIS) vel = vtk.vtkDoubleArray() vel.SetName("VELOCITY") vel.SetNumberOfComponents(3) vel.SetNumberOfTuples(KIEKIS) part_type = vtk.vtkIntArray() part_type.SetName("PARTICLE_TYPE") part_type.SetNumberOfComponents(1) part_type.SetNumberOfTuples(KIEKIS) part_material = vtk.vtkIntArray() part_material.SetName("PARTICLE_MATERIAL") part_material.SetNumberOfComponents(1) part_material.SetNumberOfTuples(KIEKIS) part_fix = vtk.vtkIntArray() part_fix.SetName("PARTICLE_FIX") part_fix.SetNumberOfComponents(1) part_fix.SetNumberOfTuples(KIEKIS) reader.GetOutput().GetPointData().GetArray("radius").SetName("RADIUS") poly.GetPointData().SetScalars( reader.GetOutput().GetPointData().GetArray("RADIUS")) verts = vtk.vtkCellArray() for x in range(poly.GetNumberOfPoints()): vel.SetTuple3(x, 0, 0, 0) part_material.SetTuple1(x, 0) tag = reader.GetOutput().GetPointData().GetArray( "particleTag").GetTuple1(x) if (tag == 0): part_type.SetTuple1(x, 1) part_fix.SetTuple1(x, 1) print(tag) else: part_type.SetTuple1(x, 0) part_fix.SetTuple1(x, 0) verts.InsertNextCell(1) verts.InsertCellPoint(x) poly.SetVerts(verts) poly.GetPointData().AddArray(part_fix) poly.GetPointData().AddArray(part_material) poly.GetPointData().AddArray(vel) poly.GetPointData().AddArray(part_type) poly.GetFieldData().AddArray(rad_seg) www = vtk.vtkXMLPolyDataWriter() www.SetInputData(poly) www.SetFileName("input.vtp") www.Write()
#!/usr/bin/env python import vtk htg = vtk.vtkUniformHyperTreeGrid() htg.Initialize() scalarArray = vtk.vtkDoubleArray() scalarArray.SetName('scalar') scalarArray.SetNumberOfValues(0) htg.GetPointData().AddArray(scalarArray) htg.GetPointData().SetActiveScalars('scalar') htg.SetDimensions([4, 3, 1]) htg.SetBranchFactor(2) htg.SetOrigin([-1, -1, 0]) htg.SetGridScale([1, 1, 1]) # Let's split the various trees cursor = vtk.vtkHyperTreeGridNonOrientedCursor() offsetIndex = 0 # ROOT CELL 0 htg.InitializeNonOrientedCursor(cursor, 0, True) cursor.SetGlobalIndexStart(offsetIndex) idx = cursor.GetGlobalNodeIndex() scalarArray.InsertTuple1(idx, 10) cursor.SubdivideLeaf() # ROOT CELL 0/[0-3]
import sys import vtk import math # Default branch angle if the angle per branch is not specified. branchAngle = math.pi / 4.0 scaling = 1.0 step = 0.1 radiusBase = 1.0 # If sphereRadius is set to None, the centreline is generated in the XY plane. # Otherwise the centreline is wrapped on a sphere of the specified radius. sphereRadius = None points = vtk.vtkPoints() lines = vtk.vtkCellArray() radii = vtk.vtkDoubleArray() radii.SetName("radiiScalars") centreline = vtk.vtkPolyData() def BuildCentreline(segmentList, firstId=0, firstPt=(0.0, 0.0, 0.0), direction=0.0): print("Processing centreline:", segmentList) domain = None try: domain = segmentList[0] except IndexError:
def display_Xn(self, gfx): if gfx.ps != None: gfx.renderer.RemoveActor(gfx.ps.acteur) try: zmax = gfx.map[0].box.GetBounds()[5] zmin = gfx.map[0].box.GetBounds()[4] ymax = gfx.map[0].box.GetBounds()[3] ymin = gfx.map[0].box.GetBounds()[2] c = (zmax - zmin) / 2. b = (ymax - ymin) / 2. except: b = c = self.radius dist = self.radius phizero = radians(self.phizero) if self.solidtype == 'Cn': numPts = self.cnn shifta = radians(360. / numPts) pdo = vtk.vtkPolyData() cirpdo = vtk.vtkPolyData() newPts = vtk.vtkPoints() vals = vtk.vtkDoubleArray() for i in range(0, numPts): try: if self.axe == 'Z': x = dist * gfx.map[0].scale * cos(i * shifta + phizero) y = dist * gfx.map[0].scale * sin(i * shifta + phizero) z = 0 elif self.axe == 'Y': x = dist * gfx.map[0].scale * cos(i * shifta + phizero) y = 0 z = dist * gfx.map[0].scale * sin(i * shifta + phizero) elif self.axe == 'X': x = 0 y = dist * gfx.map[0].scale * cos(i * shifta + phizero) z = dist * gfx.map[0].scale * sin(i * shifta + phizero) except: if self.axe == 'Z': x = dist * cos(i * shifta + phizero) y = dist * sin(i * shifta + phizero) z = 0 elif self.axe == 'Y': x = dist * cos(i * shifta + phizero) y = 0 z = dist * sin(i * shifta + phizero) elif self.axe == 'X': x = 0 y = dist * cos(i * shifta + phizero) z = dist * sin(i * shifta + phizero) newPts.InsertPoint(i, x, y, z) vals.InsertNextValue(i) pdo.SetPoints(newPts) pdo.GetPointData().SetScalars(vals) cirpdo.SetPoints(newPts) cirpdo.GetPointData().SetScalars(vals) aPolyLine = vtk.vtkPolyLine() aPolyLine.GetPointIds().SetNumberOfIds(numPts + 1) for i in range(0, numPts): aPolyLine.GetPointIds().SetId(i, i) aPolyLine.GetPointIds().SetId(numPts, 0) cirpdo.Allocate(1, 1) cirpdo.InsertNextCell(aPolyLine.GetCellType(), aPolyLine.GetPointIds()) sphere = vtk.vtkSphereSource() sphere.SetCenter(0, 0, 0) try: sphere.SetRadius(self.radius * gfx.map[0].scale / 5.0) except: sphere.SetRadius(self.radius / 5.0) sphere.SetThetaResolution(8) sphere.SetStartTheta(0) sphere.SetEndTheta(360) sphere.SetPhiResolution(8) sphere.SetStartPhi(0) sphere.SetEndPhi(180) glyph = vtk.vtkGlyph3D() glyph.SetInput(pdo) glyph.SetColorMode(1) glyph.ScalingOn() glyph.SetScaleMode(2) glyph.SetScaleFactor(0.25) glyph.SetSource(sphere.GetOutput()) self.spheremapper = vtk.vtkPolyDataMapper() self.spheremapper.SetInputConnection(glyph.GetOutputPort()) self.spheremapper.UseLookupTableScalarRangeOff() self.spheremapper.SetScalarVisibility(0) self.sphact = vtk.vtkActor() self.sphact.PickableOff() self.sphact.DragableOff() self.sphact.SetMapper(self.spheremapper) self.sphact.GetProperty().SetRepresentationToSurface() self.sphact.GetProperty().SetInterpolationToGouraud() self.sphact.GetProperty().SetAmbient(0.15) self.sphact.GetProperty().SetDiffuse(0.85) self.sphact.GetProperty().SetSpecular(0.1) self.sphact.GetProperty().SetSpecularPower(100) self.sphact.GetProperty().SetSpecularColor(1, 1, 1) self.sphact.GetProperty().SetColor(1, 1, 1) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetScalarVisibility(0) self.mapper.SetInput(cirpdo) self.helact = vtk.vtkActor() self.helact.PickableOff() self.helact.DragableOff() self.helact.GetProperty().SetColor(1, 1, 1) self.helact.GetProperty().SetRepresentationToWireframe() self.helact.GetProperty().SetLineWidth(5) self.helact.GetProperty().SetLineWidth(1) self.helact.GetProperty().SetSpecular(.4) self.helact.GetProperty().SetSpecularPower(10) self.helact.SetMapper(self.mapper) assembly = vtk.vtkAssembly() assembly.AddPart(self.sphact) assembly.AddPart(self.helact) self.acteur = assembly gfx.renderer.AddActor(self.acteur) gfx.renwin.Render() gfx.ps = self elif self.solidtype == 'Dn': numPts = self.dnn shifta = radians(360. / numPts) cirpdo = vtk.vtkPolyData() pdo = vtk.vtkPolyData() newPts = vtk.vtkPoints() vals = vtk.vtkDoubleArray() for i in range(0, numPts): try: x = dist * gfx.map[0].scale * cos(i * shifta) y = dist * gfx.map[0].scale * sin(i * shifta) z = 0 except: x = dist * cos(i * shifta) y = dist * sin(i * shifta) z = 0 newPts.InsertPoint(i, x, y, z) vals.InsertNextValue(i) pdo.SetPoints(newPts) pdo.GetPointData().SetScalars(vals) cirpdo.SetPoints(newPts) cirpdo.GetPointData().SetScalars(vals) aPolyLine = vtk.vtkPolyLine() aPolyLine.GetPointIds().SetNumberOfIds(numPts + 1) for i in range(0, numPts): aPolyLine.GetPointIds().SetId(i, i) aPolyLine.GetPointIds().SetId(numPts, 0) cirpdo.Allocate(1, 1) cirpdo.InsertNextCell(aPolyLine.GetCellType(), aPolyLine.GetPointIds()) sphere = vtk.vtkSphereSource() sphere.SetCenter(0, 0, 0) try: sphere.SetRadius(self.radius * gfx.map[0].scale / 5.0) except: sphere.SetRadius(self.radius / 5.0) sphere.SetThetaResolution(8) sphere.SetStartTheta(0) sphere.SetEndTheta(360) sphere.SetPhiResolution(8) sphere.SetStartPhi(0) sphere.SetEndPhi(180) glyph = vtk.vtkGlyph3D() glyph.SetInput(pdo) glyph.SetColorMode(1) glyph.ScalingOn() glyph.SetScaleMode(2) glyph.SetScaleFactor(0.25) glyph.SetSource(sphere.GetOutput()) self.spheremapper = vtk.vtkPolyDataMapper() self.spheremapper.SetInputConnection(glyph.GetOutputPort()) self.spheremapper.UseLookupTableScalarRangeOff() self.spheremapper.SetScalarVisibility(0) self.sphact = vtk.vtkActor() self.sphact.PickableOff() self.sphact.DragableOff() self.sphact.SetMapper(self.spheremapper) self.sphact.GetProperty().SetRepresentationToSurface() self.sphact.GetProperty().SetInterpolationToGouraud() self.sphact.GetProperty().SetAmbient(0.15) self.sphact.GetProperty().SetDiffuse(0.85) self.sphact.GetProperty().SetSpecular(0.1) self.sphact.GetProperty().SetSpecularPower(100) self.sphact.GetProperty().SetSpecularColor(1, 1, 1) self.sphact.GetProperty().SetColor(1, 1, 1) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetScalarVisibility(0) self.mapper.SetInput(cirpdo) self.helact = vtk.vtkActor() self.helact.PickableOff() self.helact.DragableOff() self.helact.GetProperty().SetColor(1, 1, 1) self.helact.GetProperty().SetRepresentationToWireframe() self.helact.GetProperty().SetLineWidth(5) self.helact.GetProperty().SetLineWidth(1) self.helact.GetProperty().SetSpecular(.4) self.helact.GetProperty().SetSpecularPower(10) self.helact.SetMapper(self.mapper) sphact2 = vtk.vtkActor() helact2 = vtk.vtkActor() sphact2.ShallowCopy(self.sphact) helact2.ShallowCopy(self.helact) self.sphact.AddPosition(0, 0, dist * c / b) self.helact.AddPosition(0, 0, dist * c / b) sphact2.AddPosition(0, 0, -dist * c / b) helact2.AddPosition(0, 0, -dist * c / b) assembly = vtk.vtkAssembly() assembly.AddPart(self.sphact) assembly.AddPart(self.helact) assembly.AddPart(sphact2) assembly.AddPart(helact2) self.acteur = assembly gfx.renderer.AddActor(self.acteur) gfx.renwin.Render() gfx.ps = self
def main(): angle_num = 1 for angle in range(60, 120, 10): print 'Processing angle', angle, '...' # Read the EC mesh. ecFileName = os.path.join(str(angle), 'quadMeshFullECc4080.vtp') ecMeshReader = vtk.vtkXMLPolyDataReader() ecMeshReader.SetFileName(ecFileName) ecMeshReader.Update() # Remember the EC mesh. ecMesh = ecMeshReader.GetOutput() # Get EC centres. cellCentresFilter = vtk.vtkCellCenters() cellCentresFilter.VertexCellsOn() cellCentresFilter.SetInput(ecMesh) cellCentresFilter.Update() ecMeshCentres = cellCentresFilter.GetOutput() pointsPerBranch = ecMeshCentres.GetNumberOfPoints() / 3 # Find three saddle points. # The first point is 3/4th of the EC row away from the end of the parent branch. # The second point is 1/4th of the EC row away from the end of the parent branch. # The third point is 3/4th of the way from the start of the first sibling branch. saddle_ids = [ pointsPerBranch - (numQuadsPerRing / 4) * (numECsAx * numECsCirc), pointsPerBranch - ((numQuadsPerRing / 4) * 3) * (numECsAx * numECsCirc), pointsPerBranch + ((numQuadsPerRing / 4) * 3) * (numECsAx * numECsCirc) ] saddle_points = [ecMeshCentres.GetPoint(sId) for sId in saddle_ids] atpArray = vtk.vtkDoubleArray() atpArray.SetName("initialATP") # Loop through each centre point. for cId in range(pointsPerBranch * 3): # If it falls within one of the three spheres, map it to ATP. point = ecMeshCentres.GetPoints().GetPoint(cId) # Find closest saddle point to work with. # List of distances to all three saddle points. dist2_list = [ vtk.vtkMath.Distance2BetweenPoints(point, saddle_point) for saddle_point in saddle_points ] # Position of the closest saddle point. saddle_id = dist2_list.index(min(dist2_list)) sphere_rad = sphere_rads[saddle_id] max_atp = atp_max[saddle_id] # Decrement radius if on the first one; this is the changing angle for bifurcation outer curve. if saddle_id == 0: sphere_rad -= (angle_num * rad_dec) * sphere_rad # Increment radius if on the third one; this is the neck of the bifurcation. if saddle_id == 2: sphere_rad += (angle_num * rad_inc) * sphere_rad # Increase intensity if on the third one. if saddle_id == 2: max_atp += ((angle_num - 1) * atp_inc) # Does dist2 fall into sphere_rad2? if dist2_list[saddle_id] <= sphere_rad**2: # Map to parametric distance in the range [0, 1]. par_dist = math.sqrt(dist2_list[saddle_id]) / sphere_rad # Map to ATP range, depending on the saddle id. if par_dist <= inner_rad: # The centre is atp_max. atp_val = max_atp else: # Discard the inner radius from our parametric distance. x0 = par_dist - inner_rad # Map distance to sigmoind domain min to max range. x1 = x0 * scaling_to_sigmoid_domain x2 = x1 + sigmoind_domain_min # Calculate sigmoid value and subtract the min sigmoid value for this domain. s = sigmoid(x2) s1 = s # Scale to atp range. atp_range = max_atp - atp_base atp_val = atp_base + s1 * atp_range # Outside the sphere_rad2. else: atp_val = atp_base # Remember the ATP value. atpArray.InsertNextValue(atp_val) ecMeshCentres.GetCellData().SetScalars(atpArray) angle_num += 1 ecMesh.GetCellData().SetScalars(atpArray) atpFileName = os.path.join(str(angle), 'quadMeshFullATPc4080.vtp') # atpFileName = 'quadMeshFullATPc4080_' + str(angle) + '.vtp' print 'Writing', atpFileName, '...' writer = vtk.vtkXMLPolyDataWriter() writer.SetFileName(atpFileName) writer.SetInput(ecMeshCentres) # writer.SetInput(ecMesh) writer.Update()
def write_vtp(vtp_filename, points, fieldData_list, flagVerboseLevel=0, flagFieldDataMode=None): ambient_num_dim = 3 # assumed data is embedded in R^3 if flagFieldDataMode == None: if isinstance(fieldData_list, list) == True: flagFieldDataMode = 'list' elif isinstance(fieldData_list, dict) == True: flagFieldDataMode = 'dict' # Check parameter types are correct given the flags flagFieldTypeErr = False if (flagFieldDataMode == 'list') and (isinstance(fieldData_list, list) == False): flagFieldTypeErr = True type_str = str(list) elif (flagFieldDataMode == 'dict') and (isinstance(fieldData_list, dict) == False): flagFieldTypeErr = True type_str = str(dict) if flagFieldTypeErr == True: err_s = "" err_s += "Expected that the fieldData_list is of type '%s'. \n" % type_str err_s += "May need to adjust and set the flagFieldDataMode. \n" err_s += "flagFieldDataMode = %s\n" % str(flagFieldDataMode) err_s += "type(fieldData_list) = %s\n" % str(type(fieldData_list)) raise Exception(err_s) # Output a VTP file with the fields # # record the data for output #N_list = np.shape(ptsX)[0]; vtpData = vtk.vtkPolyData() # check format of the points array #n1 = np.size(points_data,0); #if (n1 == 0): # we assume array already flat # # nothing to do #else: # points = points_data.T.flatten(); # setup the points data Points = vtk.vtkPoints() #numPoints = int(len(points)/ambient_num_dim); numPoints = np.size(points, 1) for I in range(numPoints): Points.InsertNextPoint(points[0, I], points[1, I], points[2, I]) vtpData.SetPoints(Points) # Get data from the vtu object #print("Getting data from the vtu object."); #nodes_vtk_array = vtuData.GetPoints().GetData(); #ptsX = vtk_to_numpy(nodes_vtk_array); # -- setup data arrays if fieldData_list != None: # if we have field data numFields = len(fieldData_list) if flagVerboseLevel == 1: print("numFields = " + str(numFields)) if flagFieldDataMode == 'list': f_list = fieldData_list elif flagFieldDataMode == 'dict': # convert dictionary to a list f_list = [] for k, v in fieldData_list.items(): f_list.append(v) for fieldData in f_list: #print("fieldData = " + str(fieldData)); fieldName = fieldData['fieldName'] if flagVerboseLevel == 1: print("fieldName = " + str(fieldName)) fieldValues = fieldData['fieldValues'] NumberOfComponents = fieldData['NumberOfComponents'] if (NumberOfComponents == 1): N_list = len(fieldValues) if flagVerboseLevel == 1: print("N_list = " + str(N_list)) atzDataPhi = vtk.vtkDoubleArray() atzDataPhi.SetNumberOfComponents(1) atzDataPhi.SetName(fieldName) #print("fieldName = "+str(fieldName)) atzDataPhi.SetNumberOfTuples(N_list) for I in np.arange(0, N_list): #print("I = "+str(I)+", fieldValues[I] = "+str(fieldValues[I])) atzDataPhi.SetValue(I, fieldValues[I]) #vtpData.GetPointData().SetScalars(atzDataPhi); vtpData.GetPointData().AddArray(atzDataPhi) elif (NumberOfComponents == 3): #print(fieldValues); #print(fieldValues.shape); N_list = fieldValues.shape[1] if flagVerboseLevel == 1: print("N_list = " + str(N_list)) atzDataV = vtk.vtkDoubleArray() atzDataV.SetNumberOfComponents(3) atzDataV.SetName(fieldName) atzDataV.SetNumberOfTuples(N_list) for I in np.arange(0, N_list): atzDataV.SetValue(I * ambient_num_dim + 0, fieldValues[0, I]) atzDataV.SetValue(I * ambient_num_dim + 1, fieldValues[1, I]) atzDataV.SetValue(I * ambient_num_dim + 2, fieldValues[2, I]) #vtpData.GetPointData().SetVectors(atzDataV); vtpData.GetPointData().AddArray(atzDataV) else: #print("ERROR: " + error_code_file + ":" + error_func); s = "" s += "NumberOfComponents invalid. \n" s += "NumberOfComponents = " + str(NumberOfComponents) raise Exception(s) #exit(1); #vtuData.GetPointData().SetVectors(atzDataVec); #vtuData.GetPointData().AddArray(atzDataScalar1); #vtuData.GetPointData().AddArray(atzDataScalar2); #vtuData.GetPointData().AddArray(atzDataVec1); #vtuData.GetPointData().AddArray(atzDataVec2); # write the XML file writerVTP = vtk.vtkXMLPolyDataWriter() writerVTP.SetFileName(vtp_filename) writerVTP.SetInputData(vtpData) writerVTP.SetCompressorTypeToNone() # help ensure ascii output (as opposed to binary) writerVTP.SetDataModeToAscii() # help ensure ascii output (as opposed to binary) writerVTP.Write()