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