def __init__(self, polydata):
self.polydata = polydata
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.ImmediateModeRenderingOff()
self.mapper.ScalarVisibilityOff()
self.mapper.SetInputDataObject(polydata)
self.actor = vtk.vtkActor()
self.actor.GetProperty().SetPointSize(7.0)
self.actor.GetProperty().SetColor(0.,0.,0.)
self.actor.SetMapper(self.mapper)
self.labelmapper = vtk.vtkLabeledDataMapper()
self.labelmapper.SetLabelFormat(" %g")
self.labelmapper.SetLabelModeToLabelScalars()
self.labelmapper.SetInputDataObject(polydata)
prp = self.labelmapper.GetLabelTextProperty()
prp.SetFontSize(16)
prp.SetItalic(False)
prp.SetBold(True)
prp.SetColor(1.0,0.0,0.0)
prp.SetLineOffset(-2)
self.pointLabels = vtk.vtkActor2D()
self.pointLabels.SetMapper(self.labelmapper)
def setup(self):
self.CLselS = vtk.vtkSelectionSource()
self.CLselS.SetContentType(
4
) # vtkSelection:: #1 GLOBALIDS(nada) #3 VALUES(nada) #4 INDICES(varios)
self.CLselS.SetFieldType(1) # vtkSelection:: #0 CELL #1 POINT
self.CLselS.SetContainingCells(
0) # para non extraer tamén as celdas que conteñen o punto dado
self.CLselF = vtk.vtkExtractSelectedIds()
self.CLselF.SetInputConnection(self.src.GetOutputPort())
self.CLselF.SetSelectionConnection(self.CLselS.GetOutputPort())
self.CLlabelsbM = vtk.vtkLabeledDataMapper()
self.CLlabelsbM.SetInputConnection(self.CLselF.GetOutputPort())
# self.CLlabelsbM.SetLabelFormat("%g")
self.CLlabelsbM.SetLabelModeToLabelScalars()
self.CLlabelsbM.GetLabelTextProperty().SetColor(Plot.label_color)
self.CLlabelsbA = vtk.vtkActor2D()
self.CLlabelsbA.SetMapper(self.CLlabelsbM)
# self.CLlabelsbA.SetVisibility(0)
self.renderer.AddActor(self.CLlabelsbA)
self.iren.AddObserver("LeftButtonPressEvent", self.ButtonPress)
self.iren.AddObserver("LeftButtonReleaseEvent", self.ButtonRelease)
self.picker = vtk.vtkPointPicker()
# picker.SetTolerance(0.005)
self.picker.AddObserver("EndPickEvent", self.EndPick)
self.iren.SetPicker(self.picker)
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 VtkDibujaIdsKPts(uGrid, setToDraw, renderer):
'''Draw the point labels.'''
numKPtsDI= setToDraw.getPoints.size
if(numKPtsDI>0):
ids= vtk.vtkIdFilter()
ids.SetInput(uGrid)
ids.CellIdsOff()
ids.PointIdsOff()
VtkCargaIdsKPts(uGrid,setToDraw)
visPts= vtk.vtkSelectVisiblePoints()
visPts.SetInputConnection(ids.GetOutputPort())
visPts.SetRenderer(renderer)
visPts.SelectionWindowOff()
#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.SetInputConnection(visPts.GetOutputPort())
ldm.GetLabelTextProperty().SetColor(0.1,0.1,0.1)
pointLabels= vtk.vtkActor2D()
pointLabels.SetMapper(ldm)
renderer.AddActor2D(pointLabels)
else:
print "El conjunto: '",setToDraw,"' no tiene KPts."
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 VtkDibujaIdsKPts(uGrid, setToDraw, renderer):
numKPtsDI = setToDraw.getPoints.size
if (numKPtsDI > 0):
ids = vtk.vtkIdFilter()
ids.SetInput(uGrid)
ids.CellIdsOff()
ids.PointIdsOff()
VtkCargaIdsKPts(uGrid, setToDraw)
visPts = vtk.vtkSelectVisiblePoints()
visPts.SetInputConnection(ids.GetOutputPort())
visPts.SetRenderer(renderer)
visPts.SelectionWindowOff()
#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.SetInputConnection(visPts.GetOutputPort())
ldm.GetLabelTextProperty().SetColor(0.1, 0.1, 0.1)
pointLabels = vtk.vtkActor2D()
pointLabels.SetMapper(ldm)
renderer.AddActor2D(pointLabels)
else:
print "El conjunto: '", setToDraw, "' no tiene KPts."
def create_node_labels(point_id_filter: vtk.vtkIdFilter,
grid: vtk.vtkUnstructuredGrid,
rend: vtk.vtkRenderer,
label_size: float = 10.0):
"""creates the node labels"""
# filter inner points, so only surface points will be available
geo = vtk.vtkUnstructuredGridGeometryFilter()
geo.SetInputData(grid)
# points
vertex_filter = vtk.vtkVertexGlyphFilter()
vertex_filter.SetInputConnection(geo.GetOutputPort())
vertex_filter.Update()
points_mapper = vtk.vtkPolyDataMapper()
points_mapper.SetInputConnection(vertex_filter.GetOutputPort())
points_mapper.ScalarVisibilityOn()
points_actor = vtk.vtkActor()
points_actor.SetMapper(points_mapper)
points_actor.GetProperty().SetPointSize(label_size)
# point labels
label_mapper = vtk.vtkLabeledDataMapper()
label_mapper.SetInputConnection(point_id_filter.GetOutputPort())
label_mapper.SetLabelModeToLabelFieldData()
label_actor = vtk.vtkActor2D()
label_actor.SetMapper(label_mapper)
return label_actor
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 add_actors(self, list_of_actors, label=False):
for actor in list_of_actors:
self.ren.AddActor(actor)
if label:
labelMapper = vtk.vtkLabeledDataMapper()
labelMapper.SetInput(actor.polydata)
labelActor = vtk.vtkActor2D()
labelActor.SetMapper(labelMapper)
self.ren.AddActor(labelActor)
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 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 polyShowScalarValues(ren,obj):
#@c Show the scalar values for object in 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.polyUnshowScalarValues(ren,obj)
except:
pass
lmap = [None]*2
lmap[0] = "p_lmap_"+tag
labels = [None]*2
labels[0] = "p_labels_"+tag
lmap[1] = vtk.vtkLabeledDataMapper()
lmap[1].SetLabelModeToLabelScalars()
if isinstance(obj,list):
lmap[1].SetInputDataObject(obj[1])
else:
vtkPoly = Repository.ExportToVtk(obj)
lmap[1].SetInputDataObject(vtkPoly)
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 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()
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
band_cell_edges_mapper.SetInputConnection(band_cell_edges.GetOutputPort())
band_cell_edges_actor = vtk.vtkActor()
band_cell_edges_actor.SetMapper(band_cell_edges_mapper)
band_cell_edges_actor.GetProperty().SetColor(.4,.4,.4)
# Displays the contour edges generated by the BPDCF,
# somewhat thicker than the cell edges
band_edges_mapper = vtk.vtkPolyDataMapper()
band_edges_mapper.SetInputConnection(bands.GetOutputPort(1))
band_edges_actor = vtk.vtkActor()
band_edges_actor.SetMapper(band_edges_mapper)
band_edges_actor.GetProperty().SetColor(1,1,1)
band_edges_actor.GetProperty().SetLineWidth(1.3)
# Displays the scalars of the input points of the BPDCF
scalar_value_mapper = vtk.vtkLabeledDataMapper()
scalar_value_mapper.SetInputConnection(src.GetOutputPort())
scalar_value_mapper.SetLabelModeToLabelScalars()
scalar_value_mapper.SetLabelFormat("%1.3f")
scalar_value_actor = vtk.vtkActor2D()
scalar_value_actor.SetMapper(scalar_value_mapper)
# Set up renderer and camera
r = vtk.vtkRenderer()
r.AddViewProp(bands_actor)
r.AddViewProp(band_cell_edges_actor)
r.AddViewProp(band_edges_actor)
r.AddViewProp(scalar_value_actor)
r.SetBackground(.5,.5,.5)
cam=r.GetActiveCamera()
cam.SetPosition(1.25,.5,1)
def AddPointLabels(self, points, labels, bold=True, fontsize=16,
textcolor='k', font_family='courier', shadow=False,
showpoints=True, pointcolor='k', pointsize=5):
"""
Creates a point actor with one label from list labels assigned to
each point.
Parameters
----------
points : np.ndarray
3 x n numpy array of points.
labels : list
List of labels. Must be the same length as points.
italic : bool, optional
Italicises title and bar labels. Default False.
bold : bool, optional
Bolds title and bar labels. Default True
fontsize : float, optional
Sets the size of the title font. Defaults to 16.
textcolor : string or 3 item list, optional, defaults to black
Color of text.
Either a string, rgb list, or hex color string. For example:
textcolor='white'
textcolor='w'
textcolor=[1, 1, 1]
textcolor='#FFFFFF'
font_family : string, optional
Font family. Must be either courier, times, or arial.
shadow : bool, optional
Adds a black shadow to the text. Defaults to False
showpoints : bool, optional
Controls if points are visible. Default True
pointcolor : string or 3 item list, optional, defaults to black
Color of points (if visible).
Either a string, rgb list, or hex color string. For example:
textcolor='white'
textcolor='w'
textcolor=[1, 1, 1]
textcolor='#FFFFFF'
pointsize : float, optional
Size of points (if visible)
Returns
-------
labelMapper : vtk.vtkvtkLabeledDataMapper
VTK label mapper. Can be used to change properties of the labels.
"""
if len(points) != len(labels):
raise Exception('There must be one label for each point')
vtkpoints = vtkInterface.MakePointMesh(points)
vtklabels = vtk.vtkStringArray()
vtklabels.SetName('labels')
for item in labels:
vtklabels.InsertNextValue(str(item))
vtkpoints.GetPointData().AddArray(vtklabels)
# create label mapper
labelMapper = vtk.vtkLabeledDataMapper()
labelMapper.SetInputData(vtkpoints)
textprop = labelMapper.GetLabelTextProperty()
textprop.SetBold(bold)
textprop.SetFontSize(fontsize)
textprop.SetFontFamily(ParseFontFamily(font_family))
textprop.SetColor(ParseColor(textcolor))
textprop.SetShadow(shadow)
labelMapper.SetLabelModeToLabelFieldData()
labelMapper.SetFieldDataName('labels')
labelActor = vtk.vtkActor2D()
labelActor.SetMapper(labelMapper)
# add points
if showpoints:
self.AddMesh(vtkpoints, style='points', color=pointcolor,
psize=pointsize)
else:
self.AddMesh(vtkpoints)
self.AddActor(labelActor)
return labelMapper
def draw_vtk(nodes,
elements,
values=None,
colors_count=256,
contours_count=10,
use_gray=False,
title=None,
background=(0.95, 0.95, 0.95),
show_mesh=False,
mesh_color=(0.25, 0.25, 0.25),
use_cell_data=False,
show_labels=False,
show_axes=False):
"""
Function draws planar unstructured mesh using vtk
:param show_axes: if it equals true than axes is drawn
:param use_cell_data: if it equals true than cell data is used to colorize zones
:param show_labels: if it equals true than labels are shown
:param show_mesh: if it equals true than mesh lines are shown
:param mesh_color: color of mesh lines (polygons edges)
:param contours_count: Contour lines count
:param title: Title of the scalar bar
:param background: Background RGB-color value
:param use_gray: if it equals true than gray-scale colormap is used
:param colors_count: Colors count for values visualization
:param nodes: nodes array [nodes_count; 2]
:param elements: elements array [elements_count; element_nodes]
:param values: values array (coloring rule)
:return: nothing
"""
import vtk
points = vtk.vtkPoints()
for n in nodes:
if len(n) == 2:
points.InsertNextPoint([n[0], n[1], 0.0])
elif len(n) == 3:
points.InsertNextPoint([n[0], n[1], n[2]])
cells_array = vtk.vtkCellArray()
for el in elements:
polygon = vtk.vtkPolygon()
polygon.GetPointIds().SetNumberOfIds(len(el))
for i in range(len(el)):
polygon.GetPointIds().SetId(i, el[i])
cells_array.InsertNextCell(polygon)
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(colors_count)
lut.SetHueRange(0.66667, 0.0)
if use_gray:
lut.SetValueRange(1.0, 0.0)
lut.SetSaturationRange(0.0, 0.0) # no color saturation
lut.SetRampToLinear()
lut.Build()
renderer = vtk.vtkRenderer()
renderer.SetBackground(background)
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
bcf_actor = vtk.vtkActor()
bcf_mapper = vtk.vtkPolyDataMapper()
poly_data = vtk.vtkPolyData()
poly_data.SetPoints(points)
poly_data.SetPolys(cells_array)
if values is not None:
scalars = vtk.vtkFloatArray()
for v in values:
scalars.InsertNextValue(v)
poly_data.GetPointData().SetScalars(scalars)
bcf = vtk.vtkBandedPolyDataContourFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
bcf.SetInput(poly_data)
else:
bcf.SetInputData(poly_data)
if contours_count > 0:
bcf.SetNumberOfContours(contours_count)
bcf.GenerateValues(contours_count, [values.min(), values.max()])
bcf.SetNumberOfContours(contours_count + 1)
bcf.GenerateContourEdgesOn()
bcf.Update()
bcf_mapper.ImmediateModeRenderingOn()
if vtk.VTK_MAJOR_VERSION <= 5:
bcf_mapper.SetInput(bcf.GetOutput())
else:
bcf_mapper.SetInputData(bcf.GetOutput())
bcf_mapper.SetScalarRange(values.min(), values.max())
bcf_mapper.SetLookupTable(lut)
bcf_mapper.ScalarVisibilityOn()
if use_cell_data:
bcf_mapper.SetScalarModeToUseCellData()
bcf_actor.SetMapper(bcf_mapper)
renderer.AddActor(bcf_actor)
edge_mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
edge_mapper.SetInput(bcf.GetContourEdgesOutput())
else:
edge_mapper.SetInputData(bcf.GetContourEdgesOutput())
edge_mapper.SetResolveCoincidentTopologyToPolygonOffset()
edge_actor = vtk.vtkActor()
edge_actor.SetMapper(edge_mapper)
if use_gray:
edge_actor.GetProperty().SetColor(0.0, 1.0, 0.0)
else:
edge_actor.GetProperty().SetColor(0.0, 0.0, 0.0)
renderer.AddActor(edge_actor)
if show_labels:
mask = vtk.vtkMaskPoints()
if vtk.VTK_MAJOR_VERSION <= 5:
mask.SetInput(bcf.GetOutput())
else:
mask.SetInputData(bcf.GetOutput())
mask.SetOnRatio(bcf.GetOutput().GetNumberOfPoints() / 20)
mask.SetMaximumNumberOfPoints(20)
# Create labels for points - only show visible points
visible_points = vtk.vtkSelectVisiblePoints()
visible_points.SetInputConnection(mask.GetOutputPort())
visible_points.SetRenderer(renderer)
ldm = vtk.vtkLabeledDataMapper()
ldm.SetInputConnection(mask.GetOutputPort())
ldm.SetLabelFormat("%.2E")
ldm.SetLabelModeToLabelScalars()
text_property = ldm.GetLabelTextProperty()
text_property.SetFontFamilyToArial()
text_property.SetFontSize(10)
if use_gray:
text_property.SetColor(0.0, 1.0, 0.0)
else:
text_property.SetColor(0.0, 0.0, 0.0)
text_property.ShadowOff()
text_property.BoldOff()
contour_labels = vtk.vtkActor2D()
contour_labels.SetMapper(ldm)
renderer.AddActor(contour_labels)
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(lut)
if title is not None:
scalar_bar.SetTitle(title)
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(render_window_interactor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
else:
if vtk.VTK_MAJOR_VERSION <= 5:
bcf_mapper.SetInput(poly_data)
else:
bcf_mapper.SetInputData(poly_data)
bcf_actor.GetProperty().SetColor(0.0, 1.0, 0.0)
if show_mesh:
bcf_actor.GetProperty().EdgeVisibilityOn()
bcf_actor.GetProperty().SetEdgeColor(mesh_color)
bcf_actor.SetMapper(bcf_mapper)
renderer.AddActor(bcf_actor)
if show_axes:
axes = vtk.vtkAxesActor()
renderer.AddActor(axes)
render_window.Render()
render_window_interactor.Start()
def main():
pointThreshold = 10
polyData = vtk.vtkPolyData()
contour_filter = vtk.vtkContourFilter()
# If a file is present, read it, otherwise generate some random
# scalars on a plane
nargs = len(sys.argv)
argv = sys.argv
if nargs == 1:
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(argv[1])
reader.Update()
#scalar_range[2]
scalar_range = reader.GetOutput().GetScalarRange()
polyData = reader.GetOutput()
print("scalar_range: ", scalar_range[0], ", ", scalar_range[1])
contour_filter.SetValue(0, (scalar_range[1] + scalar_range[0]) / 2.0)
contour_filter.SetInputConnection(reader.GetOutputPort())
if nargs == 3:
contour_filter.SetValue(0, float(argv[2]))
elif nargs == 4:
contour_filter.SetValue(0, float(argv[2]))
contour_filter.SetValue(1, float(argv[3]))
elif nargs == 5:
contour_filter.GenerateValues(int(argv[2]), float(argv[3]),
float(argv[4]))
else:
plane = vtk.vtkPlaneSource()
plane.SetXResolution(10)
plane.SetYResolution(10)
plane.Update()
randomScalars = vtk.vtkDoubleArray() # was vtkArray
randomScalars.SetNumberOfComponents(1)
randomScalars.SetName("Isovalues")
for i in range(plane.GetOutput().GetNumberOfPoints()):
randomScalars.InsertNextTuple1(vtk.vtkMath.Random(-100.0, 100.0))
plane.GetOutput().GetPointData().SetScalars(randomScalars)
polyData = plane.GetOutput()
contour_filter.SetInputConnection(plane.GetOutputPort())
contour_filter.GenerateValues(5, -100, 100)
pointThreshold = 0
# Connect the segments of the conours into polylines
contour_stripper = vtk.vtkStripper()
contour_stripper.SetInputConnection(contour_filter.GetOutputPort())
contour_stripper.Update()
numberOfContourLines = contour_stripper.GetOutput().GetNumberOfLines()
print("There are ", numberOfContourLines, " contours lines.")
points = contour_stripper.GetOutput().GetPoints()
cells = contour_stripper.GetOutput().GetLines()
scalars = contour_stripper.GetOutput().GetPointData().GetScalars()
npoints = points.GetNumberOfPoints()
# Create a polydata that contains point locations for the contour
# line labels
label_poly_data = vtk.vtkPolyData()
label_points = vtk.vtkPoints()
label_scalars = vtk.vtkDoubleArray() # was vtkArray
label_scalars.SetNumberOfComponents(1)
label_scalars.SetName("Isovalues")
#vtkIdType *indices
#vtkIdType npoints
lineCount = 0
#for(cells.InitTraversal()
# cells.GetNextCell(npoints, indices)
# npoints++)
#numberOfPoints = vtk.vtkIdType()
#nstart = cells.InitTraversal()
print('npoints = ', npoints)
#print('nstart=%s' % nstart)
include_labels = False
if include_labels:
indices = [i for i in range(cells.GetNumberOfCells() * 10 + 1)]
print(indices)
#nend = cells.GetNextCell(npoints, indices)
#print('nstart=%s nend=%s' % (nstart, nend))
ncells = cells.GetNumberOfCells()
#for i in range(nstart, c):
for i in range(ncells):
#cell = cells.GetNumber
if npoints < pointThreshold:
continue
print("Line ", lineCount, ": ")
# Compute the point id to hold the label
# Mid point or a random point
mid_point_id = indices[npoints / 2]
val = int(vtk.vtkMath.Random(0, npoints))
mid_point_id = indices[val]
# mid_point[3]
mid_point = points.GetPoint(mid_point_id)
print("\tmidPoint is ", mid_point_id, " with coordinate ", "(",
mid_point[0], ", ", mid_point[1], ", ", mid_point[2], ")",
" and value ", scalars.GetTuple1(mid_point_id))
label_points.InsertNextPoint(mid_point)
label_scalars.InsertNextTuple1(scalars.GetTuple1(mid_point_id))
lineCount += 1
label_poly_data.SetPoints(label_points)
label_poly_data.GetPointData().SetScalars(label_scalars)
contour_mapper = vtk.vtkPolyDataMapper()
contour_mapper.SetInputConnection(contour_stripper.GetOutputPort())
contour_mapper.ScalarVisibilityOff()
isolines = vtk.vtkActor()
isolines.SetMapper(contour_mapper)
surfaceLUT = vtk.vtkLookupTable()
surfaceLUT.SetRange(polyData.GetPointData().GetScalars().GetRange())
surfaceLUT.Build()
surface_mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
surface_mapper.SetInput(polyData)
else:
surface_mapper.SetInputData(polyData)
surface_mapper.ScalarVisibilityOn()
surface_mapper.SetScalarRange(
polyData.GetPointData().GetScalars().GetRange())
surface_mapper.SetLookupTable(surfaceLUT)
surface = vtk.vtkActor()
surface.SetMapper(surface_mapper)
# The labeled data mapper will place labels at the points
if include_labels:
label_mapper = vtk.vtkLabeledDataMapper()
label_mapper.SetFieldDataName("Isovalues")
if vtk.VTK_MAJOR_VERSION <= 5:
label_mapper.SetInput(label_poly_data)
else:
label_mapper.SetInputData(label_poly_data)
label_mapper.SetLabelModeToLabelScalars()
label_mapper.SetLabelFormat("%6.2f")
isolabels = vtk.vtkActor2D()
isolabels.SetMapper(label_mapper)
# Create a renderer and render window
renderer = vtk.vtkRenderer()
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
# Create an interactor
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
# Add the actors to the scene
renderer.AddActor(isolines)
if include_labels:
renderer.AddActor(isolabels)
#renderer.AddActor(surface)
# Render the scene(lights and cameras are created automatically)
render_window.Render()
render_window_interactor.Start()
def __init__ (self, mod_m, module=None, n_points=25, vis_points=0):
"""Input arguments:
mod_m -- Module manager that manages this module.
module -- Module to label. Can be given a module name (the
same name as listed in the Modules GUI) or an index of the
module (starting from 0) in the current module manager. If
the value is -1, then the filtered data from the module
manager is used. The value defaults to None where the user is
asked to specify the module to label.
n_points -- Number of points to label. Defaults to 25.
vis_points -- If 1 turns on the vtkSelectVisiblePoints filter.
Defaults to 0.
"""
debug ("In Labels::__init__ ()")
Base.Objects.Module.__init__ (self, mod_m)
self.act = None
self.input = None
self.mod_num = -1
if module is not None:
self._set_input(module)
if not self.input:
res = self._get_input_gui()
self._set_input(res)
if not self.input:
msg = "Sorry, you need to choose a valid module in order to "\
"use this module."
raise Base.Objects.ModuleException, msg
input = self.input
Common.state.busy ()
self.n_points = n_points
self.vis_points = vis_points
self.mask = vtk.vtkMaskPoints ()
n = input.GetNumberOfPoints ()
self.mask.SetInput (input)
self.mask.SetOnRatio (max(n/n_points, 1))
self.mask.GenerateVerticesOn()
self.mask.RandomModeOn ()
self.vis_pnts = vtk.vtkSelectVisiblePoints ()
self.vis_pnts.SetRenderer(self.renwin.get_renderer())
self.mapper = self.map = vtk.vtkLabeledDataMapper ()
self.mapper.SetLabelModeToLabelScalars()
self.tprop = None
if hasattr(self.mapper, "GetLabelTextProperty"):
self.tprop = self.mapper.GetLabelTextProperty()
self.tprop.SetColor (*Common.config.fg_color)
self.tprop.SetOpacity(1.0)
if vis_points:
self.vis_pnts.SetInput (self.mask.GetOutput ())
self.mapper.SetInput (self.vis_pnts.GetOutput ())
else:
self.mapper.SetInput (self.mask.GetOutput ())
self.actor = self.act = vtk.vtkActor2D ()
self.actor.SetMapper (self.mapper)
self.vis_pnt_gui = None
self.act.GetProperty ().SetColor (*Common.config.fg_color)
self.renwin.add_actors (self.act)
# used for the pipeline browser
self.pipe_objs = self.act
self.renwin.Render ()
Common.state.idle ()
def plot(self, struct):
# creates self. data1, legend, filename, fieldname, dim, has_field, tracker, revision
if not self.call_config(struct):
return
# creates self.src
if not self.call_src():
return
# wireframe
# test proba
#self.ref0 = vtk.vtkThreshold() # necesario en selrF_
#self.ref0.SetInputConnection(self.src.GetOutputPort())
#self.ref0.ThresholdByLower(0.999) # valor inclusive
self.wireM = vtk.vtkDataSetMapper()
# test proba
#self.wireM.SetInputConnection(self.ref0.GetOutputPort())
self.wireM.SetInputConnection(self.src.GetOutputPort())
self.wireM.ScalarVisibilityOff()
self.wireA = vtk.vtkActor()
self.wireA.SetMapper(self.wireM)
self.wireA.GetProperty().SetRepresentationToWireframe()
self.wireA.GetProperty().SetColor(Plot.mesh3_color)
self.wireA.SetVisibility(0)
self.add_outline_2(self.src)
if self.has_field:
# reference labels
if self.data1.get('fielddomain') == 'point':
self.refsT = vtk.vtkThresholdPoints()
self.refsT.SetInputConnection(self.src.GetOutputPort())
self.refsT.ThresholdByUpper(1.0 - epsilon)
else:
self.refsT = vtk.vtkThreshold() # necesario en selrF_
self.refsT.SetInputConnection(self.src.GetOutputPort())
self.refsT.ThresholdByUpper(1.0 - epsilon)
# self.refsT.SetInputArrayToProcess(1, 0, 0, 0, self.fieldname)
# self.refsT.SetAttributeModeToUseCellData()
if self.data1.get('fielddomain') == 'point':
label_con = self.refsT.GetOutputPort()
else:
self.ccrF = vtk.vtkCellCenters()
self.ccrF.SetInputConnection(self.refsT.GetOutputPort())
label_con = self.ccrF.GetOutputPort()
self.lrM = vtk.vtkLabeledDataMapper()
self.lrM.SetInputConnection(label_con)
self.lrM.SetLabelModeToLabelScalars()
self.lrM.GetLabelTextProperty().SetColor(Plot.label_color)
self.lrA = vtk.vtkActor2D()
self.lrA.SetMapper(self.lrM)
self.lrA.SetVisibility(0)
# CELL POINT FIELD VERTEX EDGE
if self.data1.get('fielddomain') == 'point':
ftype = 1 # vtkSelection::POINT
else:
ftype = 0 # vtkSelection::CELL
# selected edges
self.selr = vtk.vtkSelectionSource()
self.selr.SetContentType(7) # vtkSelection::THRESHOLDS
self.selr.SetFieldType(ftype)
if self.data1.get(
'fielddomain'
) == 'point': # necesario para los puntos, sino colapsa
self.selr.SetContainingCells(0)
# unselected edges
self.selr_ = vtk.vtkSelectionSource()
self.selr_.SetContentType(7) # vtkSelection::THRESHOLDS
self.selr_.SetFieldType(ftype)
if self.data1.get(
'fielddomain'
) == 'point': # necesario para los puntos, sino colapsa
self.selr_.SetContainingCells(0)
self.selr_.SetInverse(1)
self.selrF = vtk.vtkExtractSelectedThresholds()
#self.selrF.SetInputConnection(self.src.GetOutputPort()) # por que era asi? # x1sbc
self.selrF.SetInputConnection(self.refsT.GetOutputPort())
self.selrF.SetSelectionConnection(self.selr.GetOutputPort())
self.selrF_ = vtk.vtkExtractSelectedThresholds()
self.selrF_.SetInputConnection(self.refsT.GetOutputPort()) #
self.selrF_.SetSelectionConnection(self.selr_.GetOutputPort())
self.selrM = vtk.vtkDataSetMapper()
self.selrM.SetInputConnection(self.selrF.GetOutputPort())
if not several_colors:
self.selrM.ScalarVisibilityOff()
self.selrM_ = vtk.vtkDataSetMapper()
self.selrM_.SetInputConnection(self.selrF_.GetOutputPort())
self.selrM_.ScalarVisibilityOff()
self.selrM.SetScalarRange(self.change_range(self.src))
self.selrA = vtk.vtkActor()
self.selrA.SetMapper(self.selrM)
if not several_colors:
self.selrA.GetProperty().SetColor(Plot.mesh2_color)
if self.data1.get('fielddomain') == 'point':
self.selrA.GetProperty().SetRepresentationToPoints()
else:
self.selrA.GetProperty().SetRepresentationToSurface()
self.selrA_ = vtk.vtkActor()
self.selrA_.SetMapper(self.selrM_)
if several_colors:
self.selrA_.GetProperty().SetColor(Plot.unselected_color)
else:
self.selrA_.GetProperty().SetColor(Plot.mesh_color)
if self.data1.get('fielddomain') == 'point':
self.selrA_.GetProperty().SetRepresentationToPoints()
else:
self.selrA_.GetProperty().SetRepresentationToWireframe()
if self.data1.get('fielddomain') == 'point':
self.selrA.GetProperty().SetPointSize(3.0)
self.selrA_.GetProperty().SetPointSize(2.0)
# lóxica dudosa: depende do nome do campo
if self.data1.get('fieldname') == 'edge_ref':
self.selrA.GetProperty().SetLineWidth(5.0)
self.selrA_.GetProperty().SetLineWidth(5.0)
self.update_thresholds(struct, True)
# Add the actors to the render
self.rens[0].AddActor(self.selrA_) # unselected
self.rens[0].AddActor(self.selrA) # selected
self.rens[0].AddActor(self.lrA) # labels
self.rens[0].AddActor(self.wireA) # mesh
self.set_iren()
self.iren.AddObserver("LeftButtonPressEvent", self.ButtonEvent)
if self.data1.get('fielddomain') == 'cell':
self.picker = vtk.vtkCellPicker()
else:
self.picker = vtk.vtkPointPicker()
self.picker.AddObserver("EndPickEvent", self.EndPick)
self.iren.SetPicker(self.picker)
self.done = True
def Execute(self):
if not self.Mesh:
self.PrintError('Error: No input mesh.')
return
if not self.CellEntityIdsArrayName:
self.PrintError('Error: No input CellEntityIdsArrayName.')
return
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self)
threshold = vtk.vtkThreshold()
threshold.SetInput(self.Mesh)
threshold.ThresholdByUpper(self.VolumeCellEntityId+0.5)
threshold.SetInputArrayToProcess(0,0,0,1,self.CellEntityIdsArrayName)
threshold.Update()
boundaryMesh = threshold.GetOutput()
boundaryMesh.GetCellData().SetActiveScalars(self.CellEntityIdsArrayName)
boundaryMapper = vtk.vtkDataSetMapper()
boundaryMapper.SetInput(boundaryMesh)
boundaryMapper.ScalarVisibilityOn()
boundaryMapper.SetScalarModeToUseCellData()
boundaryMapper.SetScalarRange(boundaryMesh.GetCellData().GetScalars().GetRange())
boundaryActor = vtk.vtkActor()
boundaryActor.SetMapper(boundaryMapper)
self.vmtkRenderer.Renderer.AddActor(boundaryActor)
wallThreshold = vtk.vtkThreshold()
wallThreshold.SetInput(boundaryMesh)
wallThreshold.ThresholdByLower(self.WallCellEntityId+0.5)
wallThreshold.SetInputArrayToProcess(0,0,0,1,self.CellEntityIdsArrayName)
wallThreshold.Update()
wallMeshToSurface = vtk.vtkGeometryFilter()
wallMeshToSurface.SetInput(wallThreshold.GetOutput())
wallMeshToSurface.Update()
boundaryReferenceSystems = vtkvmtk.vtkvmtkBoundaryReferenceSystems()
boundaryReferenceSystems.SetInput(wallMeshToSurface.GetOutput())
boundaryReferenceSystems.SetBoundaryRadiusArrayName("BoundaryRadius")
boundaryReferenceSystems.SetBoundaryNormalsArrayName("BoundaryNormals")
boundaryReferenceSystems.SetPoint1ArrayName("Point1Array")
boundaryReferenceSystems.SetPoint2ArrayName("Point2Array")
boundaryReferenceSystems.Update()
self.ReferenceSystems = boundaryReferenceSystems.GetOutput()
cellEntityIdsArray = vtk.vtkIntArray()
cellEntityIdsArray.SetName(self.CellEntityIdsArrayName)
cellEntityIdsArray.SetNumberOfTuples(self.ReferenceSystems.GetNumberOfPoints())
self.ReferenceSystems.GetPointData().AddArray(cellEntityIdsArray)
wallMeshToSurface = vtk.vtkGeometryFilter()
wallMeshToSurface.SetInput(boundaryMesh)
wallMeshToSurface.Update()
boundarySurface = wallMeshToSurface.GetOutput()
pointCells = vtk.vtkIdList()
surfaceCellEntityIdsArray = vtk.vtkIntArray()
surfaceCellEntityIdsArray.DeepCopy(boundarySurface.GetCellData().GetArray(self.CellEntityIdsArrayName))
self.PrintLog('')
for i in range(self.ReferenceSystems.GetNumberOfPoints()):
pointId = boundarySurface.FindPoint(self.ReferenceSystems.GetPoint(i))
boundarySurface.GetPointCells(pointId,pointCells)
cellId = pointCells.GetId(0)
cellEntityId = surfaceCellEntityIdsArray.GetValue(cellId)
cellEntityIdsArray.SetValue(i,cellEntityId)
origin = self.ReferenceSystems.GetPoint(i)
normal = self.ReferenceSystems.GetPointData().GetArray("BoundaryNormals").GetTuple3(i)
radius = self.ReferenceSystems.GetPointData().GetArray("BoundaryRadius").GetTuple1(i)
logLine = 'CellEntityId: %d\n' % cellEntityId
logLine += ' Origin: %f, %f, %f\n' % (origin[0],origin[1],origin[2])
logLine += ' Normal: %f, %f, %f\n' % (normal[0],normal[1],normal[2])
logLine += ' Radius: %f\n' % radius
self.PrintLog(logLine)
self.ReferenceSystems.GetPointData().SetActiveScalars(self.CellEntityIdsArrayName)
labelsMapper = vtk.vtkLabeledDataMapper();
labelsMapper.SetInput(self.ReferenceSystems)
labelsMapper.SetLabelModeToLabelScalars()
labelsActor = vtk.vtkActor2D()
labelsActor.SetMapper(labelsMapper)
self.vmtkRenderer.Renderer.AddActor(labelsActor)
self.vmtkRenderer.Render()
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
def setup(self):
self.CLselS = vtk.vtkSelectionSource()
self.CLselS.SetContentType(
4
) # vtkSelection:: #1 GLOBALIDS(nada) #3 VALUES(nada) #4 INDICES(varios)
self.CLselS.SetFieldType(1) # vtkSelection:: #0 CELL #1 POINT
self.CLselS.SetContainingCells(
0) # para non extraer tamén as celdas que conteñen o punto dado
self.CLselF = vtk.vtkExtractSelectedIds()
self.CLselF.SetInputConnection(self.src.GetOutputPort())
self.CLselF.SetSelectionConnection(self.CLselS.GetOutputPort())
# marcar puntos
if True:
# puntos. tamanho en pantalla constante
# self.CLPointsV = vtk.vtkVertexGlyphFilter()
# self.CLPointsV.SetInputConnection(self.CLselF.GetOutputPort())
# self.CLPointsM = vtk.vtkPolyDataMapper()
# self.CLPointsM.SetInputConnection(self.CLPointsV.GetOutputPort())
# self.CLPointsM.ScalarVisibilityOff()
self.CLPointsM = vtk.vtkDataSetMapper()
self.CLPointsM.SetInputConnection(self.CLselF.GetOutputPort())
self.CLPointsM.ScalarVisibilityOff()
self.CLPointsA = vtk.vtkActor()
self.CLPointsA.SetMapper(self.CLPointsM)
self.CLPointsA.GetProperty().SetRepresentationToPoints()
self.CLPointsA.GetProperty().SetPointSize(3.0)
self.CLPointsA.GetProperty().SetColor(Plot.points_color)
self.renderer.AddActor(self.CLPointsA)
else:
# esferas. tamanho en pantalla variable
self.CLglyph = vtk.vtkSphereSource()
self.CLPointsG = vtk.vtkGlyph3D()
self.CLPointsG.SetInputConnection(self.CLselF.GetOutputPort())
self.CLPointsG.SetSourceConnection(self.CLglyph.GetOutputPort())
self.CLPointsG.ScalingOff()
#self.CLPointsG.SetScaleModeToDataScalingOff()
self.CLPointsM = vtk.vtkPolyDataMapper()
self.CLPointsM.SetInputConnection(self.CLPointsG.GetOutputPort())
self.CLPointsM.ScalarVisibilityOff()
self.CLPointsA = vtk.vtkActor()
self.CLPointsA.SetMapper(self.CLPointsM)
self.CLPointsA.GetProperty().SetColor(Plot.points_color)
self.renderer.AddActor(self.CLPointsA)
# labels
self.CLlabelsbM = vtk.vtkLabeledDataMapper()
self.CLlabelsbM.SetInputConnection(self.CLselF.GetOutputPort())
# self.CLlabelsbM.SetLabelFormat("%g")
if self.mode == 0:
self.CLlabelsbM.SetLabelModeToLabelScalars()
elif self.mode == 1:
self.CLlabelsbM.SetLabelModeToLabelVectors()
self.CLlabelsbM.GetLabelTextProperty().SetColor(Plot.label_color)
self.CLlabelsbA = vtk.vtkActor2D()
self.CLlabelsbA.SetMapper(self.CLlabelsbM)
# self.CLlabelsbA.SetVisibility(0)
self.renderer.AddActor(self.CLlabelsbA)
# point locator
self.point_locator = vtk.vtkPointLocator()
self.point_locator_pending = True
self.iren.AddObserver("LeftButtonPressEvent", self.ButtonPress)
self.iren.AddObserver("LeftButtonReleaseEvent", self.ButtonRelease)
self.picker = vtk.vtkPropPicker()
# picker.SetTolerance(0.005)
self.picker.AddObserver("EndPickEvent", self.EndPick)
self.iren.SetPicker(self.picker)
# generate some points
psource = vtk.vtkPointSource()
psource.SetNumberOfPoints(10)
psource.Update()
pmapper = vtk.vtkPolyDataMapper()
pmapper.SetInputConnection(psource.GetOutputPort())
pactor = vtk.vtkActor()
pactor.SetMapper(pmapper)
pactor.GetProperty().SetPointSize(8)
pactor.GetProperty().SetColor(1, 1, .4)
# labels #1
lmapper1 = vtk.vtkLabeledDataMapper()
lmapper1.SetInputConnection(psource.GetOutputPort())
# <= move the labels one space char to the right (not mandatory)
lmapper1.SetLabelFormat(" %d")
lactor1 = vtk.vtkActor2D()
lactor1.SetMapper(lmapper1)
# labels #2
lmapper2 = vtk.vtkLabeledDataMapper()
lmapper2.SetInputConnection(psource.GetOutputPort())
lactor2 = vtk.vtkActor2D()
lactor2.SetMapper(lmapper2)
p = lmapper2.GetLabelTextProperty()
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()
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)
if label_face_ids:
cell_centers = vtk.vtkCellCenters()
if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
cell_centers.SetInputData(source)
else:
cell_centers.SetInput(source)
labels = vtk.vtkLabeledDataMapper()
labels.SetInputConnection(cell_centers.GetOutputPort())
def main():
inputFilename = 'element_labels_input.vtk'
# read file
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(inputFilename)
reader.ReadAllScalarsOn()
reader.SetScalarsName(reader.GetScalarsNameInFile(0))
reader.Update()
ncells = reader.GetOutput().GetNumberOfCells()
npoints = reader.GetOutput().GetNumberOfPoints()
# get attributes
ugrid = reader.GetOutput()
cell_data = ugrid.GetCellData()
point_data = ugrid.GetPointData()
cell_scalars = cell_data.GetScalars(reader.GetScalarsNameInFile(0))
# validate that attributes are read correctly
print('name0:')
for i in range(ncells):
print(i, ": ", cell_scalars.GetComponent(i, 0))
cell_scalars = cell_data.GetScalars(reader.GetScalarsNameInFile(1))
print('\nname1:')
for i in range(ncells):
print(i, ": ", cell_scalars.GetComponent(i, 0))
point_scalars = point_data.GetScalars(reader.GetScalarsNameInFile(0))
print(point_scalars)
print('\nname2:')
for i in range(npoints):
print(i, ": ", point_scalars.GetComponent(i, 0))
#point_scalars = cell_data.GetScalars(reader.GetScalarsNameInFile(2))
#print(point_scalars)
# geometry filter
geometry_filter = vtk.vtkUnstructuredGridGeometryFilter()
geometry_filter.SetInputConnection(reader.GetOutputPort())
geometry_filter.Update()
# Generate data arrays containing point and cell ids
ids = vtk.vtkIdFilter()
ids.SetInputConnection(geometry_filter.GetOutputPort())
ids.PointIdsOff()
ids.CellIdsOff()
ids.FieldDataOn()
# Create labels for cells
cell_centers = vtk.vtkCellCenters()
cell_centers.SetInputConnection(ids.GetOutputPort())
node_points = vtk.vtkVertexGlyphFilter()
node_points.SetInputConnection(ids.GetOutputPort())
node_points.Update()
#node_points = vtk.vtkPointCentered()
#node_points.SetInputConnection(ids.GetOutputPort())
# lut
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(ncells)
lut.Build()
lut.SetTableValue(0, 1, 0, 0, 1) # red.
lut.SetTableValue(1, 0, 1, 0, 1) # green.
lut.SetTableValue(2, 0, 0, 1, 1) # blue.
# mapper
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(geometry_filter.GetOutputPort())
mapper.SetScalarVisibility(1)
if apply_colors:
mapper.SetLookupTable(lut)
mapper.SetScalarModeToUseCellData()
mapper.SetScalarRange(11, 13)
mapper.GetInput().GetCellData().SetActiveScalars("cell_tag")
# label mapper
cell_label_mapper = vtk.vtkLabeledDataMapper()
cell_label_mapper.SetInputConnection(cell_centers.GetOutputPort())
cell_label_mapper.SetLabelModeToLabelScalars()
#point_label_mapper = vtk.vtkLabeledDataMapper()
#point_label_mapper.SetInputConnection(node_points.GetOutputPort())
#point_label_mapper.SetLabelModeToLabelScalars()
# actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetRepresentationToWireframe()
# label actor
cell_label_actor = vtk.vtkActor2D()
cell_label_actor.SetMapper(cell_label_mapper)
#point_label_actor = vtk.vtkActor2D()
#point_label_actor.SetMapper(point_label_mapper)
# renderer
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(actor)
renderer.AddActor(cell_label_actor)
#renderer.AddActor(point_label_actor)
renderWindow.Render()
renderWindowInteractor.Start()
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
if self.ExtensionMode == "centerlinedirection" and self.Centerlines == None:
self.PrintError('Error: No input centerlines.')
boundaryIds = vtk.vtkIdList()
if self.Interactive:
if not self.vmtkRenderer:
import vmtkrenderer
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
boundaryExtractor = vtkvmtk.vtkvmtkPolyDataBoundaryExtractor()
boundaryExtractor.SetInput(self.Surface)
boundaryExtractor.Update()
boundaries = boundaryExtractor.GetOutput()
numberOfBoundaries = boundaries.GetNumberOfCells()
seedPoints = vtk.vtkPoints()
for i in range(numberOfBoundaries):
barycenter = [0.0, 0.0, 0.0]
vtkvmtk.vtkvmtkBoundaryReferenceSystems.ComputeBoundaryBarycenter(boundaries.GetCell(i).GetPoints(),barycenter)
seedPoints.InsertNextPoint(barycenter)
seedPolyData = vtk.vtkPolyData()
seedPolyData.SetPoints(seedPoints)
seedPolyData.Update()
labelsMapper = vtk.vtkLabeledDataMapper();
labelsMapper.SetInput(seedPolyData)
labelsMapper.SetLabelModeToLabelIds()
labelsActor = vtk.vtkActor2D()
labelsActor.SetMapper(labelsMapper)
self.vmtkRenderer.Renderer.AddActor(labelsActor)
surfaceMapper = vtk.vtkPolyDataMapper()
surfaceMapper.SetInput(self.Surface)
surfaceMapper.ScalarVisibilityOff()
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(surfaceMapper)
surfaceActor.GetProperty().SetOpacity(0.25)
self.vmtkRenderer.Renderer.AddActor(surfaceActor)
self.vmtkRenderer.Render()
self.vmtkRenderer.Renderer.RemoveActor(labelsActor)
self.vmtkRenderer.Renderer.RemoveActor(surfaceActor)
ok = False
while not ok:
labelString = self.InputText("Please input boundary ids: ",self.LabelValidator)
labels = [int(label) for label in labelString.split()]
ok = True
for label in labels:
if label not in range(numberOfBoundaries):
ok = False
for label in labels:
boundaryIds.InsertNextId(label)
flowExtensionsFilter = vtkvmtk.vtkvmtkPolyDataFlowExtensionsFilter()
flowExtensionsFilter.SetInput(self.Surface)
flowExtensionsFilter.SetCenterlines(self.Centerlines)
flowExtensionsFilter.SetSigma(self.Sigma)
flowExtensionsFilter.SetAdaptiveExtensionLength(self.AdaptiveExtensionLength)
flowExtensionsFilter.SetAdaptiveExtensionRadius(self.AdaptiveExtensionRadius)
flowExtensionsFilter.SetAdaptiveNumberOfBoundaryPoints(self.AdaptiveNumberOfBoundaryPoints)
flowExtensionsFilter.SetExtensionLength(self.ExtensionLength)
flowExtensionsFilter.SetExtensionRatio(self.ExtensionRatio)
flowExtensionsFilter.SetExtensionRadius(self.ExtensionRadius)
flowExtensionsFilter.SetTransitionRatio(self.TransitionRatio)
flowExtensionsFilter.SetCenterlineNormalEstimationDistanceRatio(self.CenterlineNormalEstimationDistanceRatio)
flowExtensionsFilter.SetNumberOfBoundaryPoints(self.TargetNumberOfBoundaryPoints)
if self.ExtensionMode == "centerlinedirection":
flowExtensionsFilter.SetExtensionModeToUseCenterlineDirection()
elif self.ExtensionMode == "boundarynormal":
flowExtensionsFilter.SetExtensionModeToUseNormalToBoundary()
if self.InterpolationMode == "linear":
flowExtensionsFilter.SetInterpolationModeToLinear()
elif self.InterpolationMode == "thinplatespline":
flowExtensionsFilter.SetInterpolationModeToThinPlateSpline()
if self.Interactive:
flowExtensionsFilter.SetBoundaryIds(boundaryIds)
flowExtensionsFilter.Update()
self.Surface = flowExtensionsFilter.GetOutput()
if self.Surface.GetSource():
self.Surface.GetSource().UnRegisterAllOutputs()
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
# cleaner = vtk.vtkCleanPolyData()
# cleaner.SetInput(self.Surface)
# cleaner.Update()
#
# triangleFilter = vtk.vtkTriangleFilter()
# triangleFilter.SetInput(cleaner.GetOutput())
# triangleFilter.Update()
#
# self.Surface = triangleFilter.GetOutput()
boundaryIds = vtk.vtkIdList()
if self.Interactive:
if not self.vmtkRenderer:
import vmtkrenderer
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self)
boundaryExtractor = vtkvmtk.vtkvmtkPolyDataBoundaryExtractor()
boundaryExtractor.SetInputData(self.Surface)
boundaryExtractor.Update()
boundaries = boundaryExtractor.GetOutput()
numberOfBoundaries = boundaries.GetNumberOfCells()
seedPoints = vtk.vtkPoints()
for i in range(numberOfBoundaries):
barycenter = [0.0, 0.0, 0.0]
vtkvmtk.vtkvmtkBoundaryReferenceSystems.ComputeBoundaryBarycenter(boundaries.GetCell(i).GetPoints(),barycenter)
seedPoints.InsertNextPoint(barycenter)
seedPolyData = vtk.vtkPolyData()
seedPolyData.SetPoints(seedPoints)
labelsMapper = vtk.vtkLabeledDataMapper();
labelsMapper.SetInputData(seedPolyData)
labelsMapper.SetLabelModeToLabelIds()
labelsActor = vtk.vtkActor2D()
labelsActor.SetMapper(labelsMapper)
self.vmtkRenderer.Renderer.AddActor(labelsActor)
surfaceMapper = vtk.vtkPolyDataMapper()
surfaceMapper.SetInputData(self.Surface)
surfaceMapper.ScalarVisibilityOff()
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(surfaceMapper)
surfaceActor.GetProperty().SetOpacity(0.25)
self.vmtkRenderer.Renderer.AddActor(surfaceActor)
#self.vmtkRenderer.Render()
#self.vmtkRenderer.Renderer.RemoveActor(labelsActor)
#self.vmtkRenderer.Renderer.RemoveActor(surfaceActor)
ok = False
while not ok:
labelString = self.InputText("Please input boundary ids: ",self.LabelValidator)
labels = [int(label) for label in labelString.split()]
ok = True
for label in labels:
if label not in range(numberOfBoundaries):
ok = False
for label in labels:
boundaryIds.InsertNextId(label)
if self.Method == 'simple':
capper = vtkvmtk.vtkvmtkSimpleCapPolyData()
capper.SetInputData(self.Surface)
elif self.Method == 'centerpoint':
capper = vtkvmtk.vtkvmtkCapPolyData()
capper.SetInputData(self.Surface)
capper.SetDisplacement(0.0)
capper.SetInPlaneDisplacement(0.0)
elif self.Method == 'smooth':
triangle = vtk.vtkTriangleFilter()
triangle.SetInputData(self.Surface)
triangle.PassLinesOff()
triangle.PassVertsOff()
triangle.Update()
capper = vtkvmtk.vtkvmtkSmoothCapPolyData()
capper.SetInputConnection(triangle.GetOutputPort())
capper.SetConstraintFactor(self.ConstraintFactor)
capper.SetNumberOfRings(self.NumberOfRings)
elif self.Method == 'annular':
capper = vtkvmtk.vtkvmtkAnnularCapPolyData()
capper.SetInputData(self.Surface)
elif self.Method == 'concaveannular':
import vtkvmtkcontrib
capper = vtkvmtkcontrib.vtkvmtkConcaveAnnularCapPolyData()
capper.SetInputData(self.Surface)
if self.Interactive:
capper.SetBoundaryIds(boundaryIds)
capper.SetCellEntityIdsArrayName(self.CellEntityIdsArrayName)
capper.SetCellEntityIdOffset(self.CellEntityIdOffset)
capper.Update()
self.Surface = capper.GetOutput()
if self.TriangleOutput == 1:
triangle = vtk.vtkTriangleFilter()
triangle.SetInputData(self.Surface)
triangle.PassLinesOff()
triangle.PassVertsOff()
triangle.Update()
self.Surface = triangle.GetOutput()
normals = vtk.vtkPolyDataNormals()
normals.SetInputData(self.Surface)
normals.AutoOrientNormalsOn()
normals.SplittingOff()
normals.ConsistencyOn()
normals.Update()
self.Surface = normals.GetOutput()
def main():
inputFilename = '3_cells.vtk'
assert os.path.exists(inputFilename)
# read file.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(inputFilename)
reader.ReadAllScalarsOn()
reader.SetScalarsName(reader.GetScalarsNameInFile(0))
reader.Update()
ncell = reader.GetOutput().GetNumberOfCells()
assert ncell > 0
# get attributes.
ugrid = reader.GetOutput()
cellData = ugrid.GetCellData()
data = cellData.GetScalars(reader.GetScalarsNameInFile(0))
# validate that attributes are read correctly.
#for (int i=0 i<ncell i++)
#{
#std::cout<< i << ": " << data.GetComponent(i,0)<< std::endl
#}
data = cellData.GetScalars(reader.GetScalarsNameInFile(1))
#for (int i=0 i<ncell i++)
#{
#std::cout<< i << ": " << data.GetComponent(i,0)<< std::endl
#}
data = cellData.GetScalars(reader.GetScalarsNameInFile(0))
# geometry filter.
geometryFilter = vtk.vtkUnstructuredGridGeometryFilter()
geometryFilter.SetInputConnection(reader.GetOutputPort())
geometryFilter.Update()
# Generate data arrays containing point and cell ids
ids = vtk.vtkIdFilter()
ids.SetInputConnection(geometryFilter.GetOutputPort())
ids.PointIdsOff()
ids.CellIdsOff()
ids.FieldDataOn()
# Create labels for cells
cc = vtk.vtkCellCenters()
cc.SetInputConnection(ids.GetOutputPort())
# lut
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(ncell)
lut.Build()
lut.SetTableValue(0, 1, 0, 0, 1) # red.
lut.SetTableValue(1, 0, 1, 0, 1) # green.
lut.SetTableValue(2, 0, 0, 1, 1) # blue.
# mapper.
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(geometryFilter.GetOutputPort())
mapper.SetLookupTable(lut)
mapper.SetScalarVisibility(1)
mapper.SetScalarModeToUseCellData()
mapper.SetScalarRange(11, 13)
mapper.GetInput().GetCellData().SetActiveScalars("cell_tag")
# label mapper.
label_mapper = vtk.vtkLabeledDataMapper()
label_mapper.SetInputConnection(cc.GetOutputPort())
label_mapper.SetLabelModeToLabelScalars()
# actor.
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetRepresentationToWireframe()
# label actor.
label_actor = vtk.vtkActor2D()
label_actor.SetMapper(label_mapper)
# renderer.
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(actor)
renderer.AddActor(label_actor)
renderWindow.Render()
renderWindowInteractor.Start()
ids.CellIdsOn()
ids.FieldDataOn()
# Create the renderer here because vtkSelectVisiblePoints needs it.
ren = vtk.vtkRenderer()
# Create labels for points
visPts = vtk.vtkSelectVisiblePoints()
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)
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
# cleaner = vtk.vtkCleanPolyData()
# cleaner.SetInput(self.Surface)
# cleaner.Update()
#
# triangleFilter = vtk.vtkTriangleFilter()
# triangleFilter.SetInput(cleaner.GetOutput())
# triangleFilter.Update()
#
# self.Surface = triangleFilter.GetOutput()
boundaryIds = vtk.vtkIdList()
if self.Interactive:
if not self.vmtkRenderer:
from vmtk import vmtkrenderer
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self)
boundaryExtractor = vtkvmtk.vtkvmtkPolyDataBoundaryExtractor()
boundaryExtractor.SetInputData(self.Surface)
boundaryExtractor.Update()
boundaries = boundaryExtractor.GetOutput()
numberOfBoundaries = boundaries.GetNumberOfCells()
seedPoints = vtk.vtkPoints()
for i in range(numberOfBoundaries):
barycenter = [0.0, 0.0, 0.0]
vtkvmtk.vtkvmtkBoundaryReferenceSystems.ComputeBoundaryBarycenter(boundaries.GetCell(i).GetPoints(),barycenter)
seedPoints.InsertNextPoint(barycenter)
seedPolyData = vtk.vtkPolyData()
seedPolyData.SetPoints(seedPoints)
labelsMapper = vtk.vtkLabeledDataMapper();
labelsMapper.SetInputData(seedPolyData)
labelsMapper.SetLabelModeToLabelIds()
labelsActor = vtk.vtkActor2D()
labelsActor.SetMapper(labelsMapper)
self.vmtkRenderer.Renderer.AddActor(labelsActor)
surfaceMapper = vtk.vtkPolyDataMapper()
surfaceMapper.SetInputData(self.Surface)
surfaceMapper.ScalarVisibilityOff()
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(surfaceMapper)
surfaceActor.GetProperty().SetOpacity(0.25)
self.vmtkRenderer.Renderer.AddActor(surfaceActor)
#self.vmtkRenderer.Render()
#self.vmtkRenderer.Renderer.RemoveActor(labelsActor)
#self.vmtkRenderer.Renderer.RemoveActor(surfaceActor)
ok = False
while not ok:
labelString = self.InputText("Please input boundary ids: ",self.LabelValidator)
labels = [int(label) for label in labelString.split()]
ok = True
for label in labels:
if label not in list(range(numberOfBoundaries)):
ok = False
for label in labels:
boundaryIds.InsertNextId(label)
if self.Method == 'simple':
capper = vtkvmtk.vtkvmtkSimpleCapPolyData()
capper.SetInputData(self.Surface)
elif self.Method == 'centerpoint':
capper = vtkvmtk.vtkvmtkCapPolyData()
capper.SetInputData(self.Surface)
capper.SetDisplacement(0.0)
capper.SetInPlaneDisplacement(0.0)
elif self.Method == 'smooth':
triangle = vtk.vtkTriangleFilter()
triangle.SetInputData(self.Surface)
triangle.PassLinesOff()
triangle.PassVertsOff()
triangle.Update()
capper = vtkvmtk.vtkvmtkSmoothCapPolyData()
capper.SetInputConnection(triangle.GetOutputPort())
capper.SetConstraintFactor(self.ConstraintFactor)
capper.SetNumberOfRings(self.NumberOfRings)
elif self.Method == 'annular':
capper = vtkvmtk.vtkvmtkAnnularCapPolyData()
capper.SetInputData(self.Surface)
elif self.Method == 'concaveannular':
from vmtk import vtkvmtkcontrib
capper = vtkvmtkcontrib.vtkvmtkConcaveAnnularCapPolyData()
capper.SetInputData(self.Surface)
if self.Interactive:
capper.SetBoundaryIds(boundaryIds)
capper.SetCellEntityIdsArrayName(self.CellEntityIdsArrayName)
capper.SetCellEntityIdOffset(self.CellEntityIdOffset)
capper.Update()
self.Surface = capper.GetOutput()
if self.TriangleOutput == 1:
triangle = vtk.vtkTriangleFilter()
triangle.SetInputData(self.Surface)
triangle.PassLinesOff()
triangle.PassVertsOff()
triangle.Update()
self.Surface = triangle.GetOutput()
normals = vtk.vtkPolyDataNormals()
normals.SetInputData(self.Surface)
normals.AutoOrientNormalsOn()
normals.SplittingOff()
normals.ConsistencyOn()
normals.Update()
self.Surface = normals.GetOutput()
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 display_annot(self, images, image_pos_pat, image_ori_pat, annots_dict_list, interact):
'''Display list of annotations, put markers according to notes and color code according to sequence order'''
# define image based on subtraction of postS -preS
image = images[4]
# Proceed to build reference frame for display objects based on DICOM coords
[self.transformed_image, transform_cube] = self.dicomTransform(image, image_pos_pat, image_ori_pat)
# supports 56 annotations
color_list = [ [0,0,0], [1,0,0], [0,0,1], [0,1,1], [1,1,0], [1,0,1], [1,1,1], [0.5,0.5,0.5], [0.5,0.5,0], [1,0.2,0], [1,1,0], [0,1,1],[0,1,0.6], [0,1,1], [1,0.4,0], [0.6,0,0.2], [1,1,0], [0,1,1],[0,1,0], [0,1,1], [1,0,0.1], [1,0.4,0],[0,1,1],[0,1,0], [0,1,1], [1,0,0.1], [1,0.4,0],
[0,0,0], [1,0,0], [0,0,1], [0,1,1], [1,1,0], [1,0,1], [1,1,1], [0.5,0.5,0.5], [0.5,0.5,0], [1,0.2,0], [1,1,0], [0,1,1],[0,1,0.6], [0,1,1], [1,0.4,0], [0.6,0,0.2], [1,1,0], [0,1,1],[0,1,0], [0,1,1], [1,0,0.1], [1,0.4,0],[0,1,1],[0,1,0], [0,1,1], [1,0,0.1], [1,0.4,0] ]
a_count = 1
annot_pts_lbl = vtk.vtkPoints()
for annots_dict in annots_dict_list:
try:
float(annots_dict['SliceLocation'])
print '\n=========#'+str(a_count)
print annots_dict
######################
## Display in graphics
######################
im_pt = [0,0,0]
ijk = [0,0,0]
pco = [0,0,0]
pi_2display=[0,0,0]
pf_2display=[0,0,0]
# extract Slice locaton
pixId_sliceloc = self.transformed_image.FindPoint(self.origin[0], self.origin[1], float(annots_dict['SliceLocation']))
self.transformed_image.GetPoint(pixId_sliceloc, im_pt)
io = self.transformed_image.ComputeStructuredCoordinates( im_pt, ijk, pco)
# mark initial
print "Point init"
ijk[0] = int(annots_dict['xi'])
ijk[1] = int(annots_dict['yi'])
print ijk
annots_dict['pi_ijk']=ijk
pixId = self.transformed_image.ComputePointId(ijk)
pi_2display = self.transformed_image.GetPoint(pixId)
annots_dict['pi_2display']=pi_2display
print pi_2display
# mark final
print "Point final"
ijk[0] = int(annots_dict['xf'])
ijk[1] = int(annots_dict['yf'])
print ijk
annots_dict['pf_ijk']=ijk
pixId = self.transformed_image.ComputePointId(ijk)
pf_2display = self.transformed_image.GetPoint(pixId)
annots_dict['pf_2display']=pf_2display
print pf_2display
# Create a graphial line between the two points
annot_pts = vtk.vtkPoints()
annot_pts.InsertNextPoint(pi_2display)
annot_pts.InsertNextPoint(pf_2display)
annot_ln = vtk.vtkLine()
annot_ln.GetPointIds().SetId(0,0)
annot_ln.GetPointIds().SetId(1,1)
note_lines = vtk.vtkCellArray()
note_lines.InsertNextCell(annot_ln)
annot_poly = vtk.vtkPolyData()
annot_poly.SetPoints(annot_pts)
annot_poly.SetLines(note_lines)
annot_poly.Update()
# Create mappers and actors
annot_mapper_mesh = vtk.vtkPolyDataMapper()
annot_mapper_mesh.SetInput( annot_poly )
self.annot_actor = vtk.vtkActor()
self.annot_actor.SetMapper(annot_mapper_mesh)
self.annot_actor.GetProperty().SetColor(color_list[a_count])
self.annot_actor.GetProperty().SetLineWidth(3)
self.annot_actor.GetProperty().SetOpacity(0.6)
self.annot_actor.GetProperty().SetPointSize(7.0)
self.annot_actor.GetProperty().SetRepresentationToWireframe()
############
# Generate data arrays containing label ids
annot_pts_lbl.InsertPoint(a_count, pi_2display)
# add annotation to scene
print annots_dict
self.renderer1.AddActor(self.annot_actor)
# Initizalize
self.renWin1.Render()
self.renderer1.Render()
a_count +=1
except ValueError:
a_count +=1
pass
############
print annot_pts_lbl.GetNumberOfPoints()
annot_lbl_poly = vtk.vtkPolyData()
annot_lbl_poly.SetPoints(annot_pts_lbl)
annot_lbl_poly.Update()
# Generate data arrays containing label ids
ids = vtk.vtkIdFilter()
ids.SetInput(annot_lbl_poly)
ids.PointIdsOn()
ids.CellIdsOff()
# Create labels for points
visPts = vtk.vtkSelectVisiblePoints()
visPts.SetInput(ids.GetOutput())
visPts.SetRenderer(self.renderer1)
visPts.SelectionWindowOff()
# 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.SetInput(visPts.GetOutput())
ldm.SetLabelModeToLabelFieldData()
pointLabels = vtk.vtkActor2D()
pointLabels.SetMapper(ldm)
# initialize
self.renderer1.AddActor2D(pointLabels)
print "\n====== Color codes:\n "
print '\033[1;31m 1) Red '
print '\033[1;34m 2) Blue '
print '\033[1;36m 3) Cyan '
print '\033[1;33m 4) Yellow '
print '\033[1;35m 5) Fushia '
print '\033[1;37m 6) White '
print '\033[1;30m 7) Gray '
print '\033[1;0m'
############
if(interact==True):
interactor = self.renWin1.GetInteractor()
interactor.Start()
return
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 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):
if (self._Surface == None):
self.PrintError(
'vmtkOpenProfilesSeedSelector Error: Surface not set.')
return
if (self._SeedIds == None):
self.PrintError(
'vmtkOpenProfilesSeedSelector Error: SeedIds not set.')
return
self._SourceSeedIds.Initialize()
self._TargetSeedIds.Initialize()
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self.Script)
seedPoints = vtk.vtkPoints()
for i in range(self._SeedIds.GetNumberOfIds()):
seedPoints.InsertNextPoint(
self._Surface.GetPoint(self._SeedIds.GetId(i)))
seedPolyData = vtk.vtkPolyData()
seedPolyData.SetPoints(seedPoints)
labelsMapper = vtk.vtkLabeledDataMapper()
labelsMapper.SetInputData(seedPolyData)
labelsMapper.SetLabelModeToLabelIds()
labelsActor = vtk.vtkActor2D()
labelsActor.SetMapper(labelsMapper)
self.vmtkRenderer.Renderer.AddActor(labelsActor)
surfaceMapper = vtk.vtkPolyDataMapper()
surfaceMapper.SetInputData(self._Surface)
surfaceMapper.ScalarVisibilityOff()
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(surfaceMapper)
surfaceActor.GetProperty().SetOpacity(0.25)
self.vmtkRenderer.Renderer.AddActor(surfaceActor)
self.vmtkRenderer.Render()
seedIdString = self.InputText(
"Please input list of inlet profile ids: ")
separator = ' '
if seedIdString.find(',') != -1:
separator = ','
seedIdList = seedIdString.split(separator)
for seedIdString in seedIdList:
self._SourceSeedIds.InsertNextId(int(seedIdString.strip()))
seedIdString = self.InputText(
"Please input list of outlet profile ids (leave empty for all available profiles): "
)
if seedIdString.strip() == '':
self.InputInfo("Selected outlets: ")
for i in range(seedPoints.GetNumberOfPoints()):
if self._SourceSeedIds.IsId(i) == -1:
self._TargetSeedIds.InsertNextId(i)
self.InputInfo("%d " % i)
self.InputInfo("\n")
else:
seedIdList = seedIdString.split(separator)
for seedIdString in seedIdList:
self._TargetSeedIds.InsertNextId(int(seedIdString.strip()))
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
def Execute(self):
if not self.Mesh:
self.PrintError('Error: No input mesh.')
return
if not self.CellEntityIdsArrayName:
self.PrintError('Error: No input CellEntityIdsArrayName.')
return
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
threshold = vtk.vtkThreshold()
threshold.SetInput(self.Mesh)
threshold.ThresholdByUpper(self.VolumeCellEntityId + 0.5)
threshold.SetInputArrayToProcess(0, 0, 0, 1,
self.CellEntityIdsArrayName)
threshold.Update()
boundaryMesh = threshold.GetOutput()
boundaryMesh.GetCellData().SetActiveScalars(
self.CellEntityIdsArrayName)
boundaryMapper = vtk.vtkDataSetMapper()
boundaryMapper.SetInput(boundaryMesh)
boundaryMapper.ScalarVisibilityOn()
boundaryMapper.SetScalarModeToUseCellData()
boundaryMapper.SetScalarRange(
boundaryMesh.GetCellData().GetScalars().GetRange())
boundaryActor = vtk.vtkActor()
boundaryActor.SetMapper(boundaryMapper)
self.vmtkRenderer.Renderer.AddActor(boundaryActor)
wallThreshold = vtk.vtkThreshold()
wallThreshold.SetInput(boundaryMesh)
wallThreshold.ThresholdByLower(self.WallCellEntityId + 0.5)
wallThreshold.SetInputArrayToProcess(0, 0, 0, 1,
self.CellEntityIdsArrayName)
wallThreshold.Update()
wallMeshToSurface = vtk.vtkGeometryFilter()
wallMeshToSurface.SetInput(wallThreshold.GetOutput())
wallMeshToSurface.Update()
boundaryReferenceSystems = vtkvmtk.vtkvmtkBoundaryReferenceSystems()
boundaryReferenceSystems.SetInput(wallMeshToSurface.GetOutput())
boundaryReferenceSystems.SetBoundaryRadiusArrayName("BoundaryRadius")
boundaryReferenceSystems.SetBoundaryNormalsArrayName("BoundaryNormals")
boundaryReferenceSystems.SetPoint1ArrayName("Point1Array")
boundaryReferenceSystems.SetPoint2ArrayName("Point2Array")
boundaryReferenceSystems.Update()
self.ReferenceSystems = boundaryReferenceSystems.GetOutput()
cellEntityIdsArray = vtk.vtkIntArray()
cellEntityIdsArray.SetName(self.CellEntityIdsArrayName)
cellEntityIdsArray.SetNumberOfTuples(
self.ReferenceSystems.GetNumberOfPoints())
self.ReferenceSystems.GetPointData().AddArray(cellEntityIdsArray)
wallMeshToSurface = vtk.vtkGeometryFilter()
wallMeshToSurface.SetInput(boundaryMesh)
wallMeshToSurface.Update()
boundarySurface = wallMeshToSurface.GetOutput()
pointCells = vtk.vtkIdList()
surfaceCellEntityIdsArray = vtk.vtkIntArray()
surfaceCellEntityIdsArray.DeepCopy(
boundarySurface.GetCellData().GetArray(
self.CellEntityIdsArrayName))
self.PrintLog('')
for i in range(self.ReferenceSystems.GetNumberOfPoints()):
pointId = boundarySurface.FindPoint(
self.ReferenceSystems.GetPoint(i))
boundarySurface.GetPointCells(pointId, pointCells)
cellId = pointCells.GetId(0)
cellEntityId = surfaceCellEntityIdsArray.GetValue(cellId)
cellEntityIdsArray.SetValue(i, cellEntityId)
origin = self.ReferenceSystems.GetPoint(i)
normal = self.ReferenceSystems.GetPointData().GetArray(
"BoundaryNormals").GetTuple3(i)
radius = self.ReferenceSystems.GetPointData().GetArray(
"BoundaryRadius").GetTuple1(i)
logLine = 'CellEntityId: %d\n' % cellEntityId
logLine += ' Origin: %f, %f, %f\n' % (origin[0], origin[1],
origin[2])
logLine += ' Normal: %f, %f, %f\n' % (normal[0], normal[1],
normal[2])
logLine += ' Radius: %f\n' % radius
self.PrintLog(logLine)
self.ReferenceSystems.GetPointData().SetActiveScalars(
self.CellEntityIdsArrayName)
labelsMapper = vtk.vtkLabeledDataMapper()
labelsMapper.SetInput(self.ReferenceSystems)
labelsMapper.SetLabelModeToLabelScalars()
labelsActor = vtk.vtkActor2D()
labelsActor.SetMapper(labelsMapper)
self.vmtkRenderer.Renderer.AddActor(labelsActor)
self.vmtkRenderer.Render()
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
def draw_vtk(nodes,
elements,
values=None,
colors_count=256,
contours_count=10,
use_gray=False,
title=None,
background=(0.95, 0.95, 0.95),
show_mesh=False,
mesh_color=(0.25, 0.25, 0.25),
use_cell_data=False,
show_labels=False,
show_axes=False):
"""
Function draws planar unstructured mesh using vtk
:param show_axes: if it equals true than axes is drawn
:param use_cell_data: if it equals true than cell data is used to colorize zones
:param show_labels: if it equals true than labels are shown
:param show_mesh: if it equals true than mesh lines are shown
:param mesh_color: color of mesh lines (polygons edges)
:param contours_count: Contour lines count
:param title: Title of the scalar bar
:param background: Background RGB-color value
:param use_gray: if it equals true than gray-scale colormap is used
:param colors_count: Colors count for values visualization
:param nodes: nodes array [nodes_count; 2]
:param elements: elements array [elements_count; element_nodes]
:param values: values array (coloring rule)
:return: nothing
"""
import vtk
points = vtk.vtkPoints()
for n in nodes:
points.InsertNextPoint([n[0], n[1], 0.0])
cells_array = vtk.vtkCellArray()
for el in elements:
polygon = vtk.vtkPolygon()
polygon.GetPointIds().SetNumberOfIds(len(el))
for i in range(len(el)):
polygon.GetPointIds().SetId(i, el[i])
cells_array.InsertNextCell(polygon)
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(colors_count)
lut.SetHueRange(0.66667, 0.0)
if use_gray:
lut.SetValueRange(1.0, 0.0)
lut.SetSaturationRange(0.0, 0.0) # no color saturation
lut.SetRampToLinear()
lut.Build()
renderer = vtk.vtkRenderer()
renderer.SetBackground(background)
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
bcf_actor = vtk.vtkActor()
bcf_mapper = vtk.vtkPolyDataMapper()
poly_data = vtk.vtkPolyData()
poly_data.SetPoints(points)
poly_data.SetPolys(cells_array)
if values is not None:
scalars = vtk.vtkFloatArray()
for v in values:
scalars.InsertNextValue(v)
poly_data.GetPointData().SetScalars(scalars)
bcf = vtk.vtkBandedPolyDataContourFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
bcf.SetInput(poly_data)
else:
bcf.SetInputData(poly_data)
bcf.SetNumberOfContours(contours_count)
bcf.GenerateValues(contours_count, [values.min(), values.max()])
bcf.SetNumberOfContours(contours_count + 1)
bcf.SetScalarModeToValue()
bcf.GenerateContourEdgesOn()
bcf.Update()
bcf_mapper.ImmediateModeRenderingOn()
if vtk.VTK_MAJOR_VERSION <= 5:
bcf_mapper.SetInput(bcf.GetOutput())
else:
bcf_mapper.SetInputData(bcf.GetOutput())
bcf_mapper.SetScalarRange(values.min(), values.max())
bcf_mapper.SetLookupTable(lut)
bcf_mapper.ScalarVisibilityOn()
if use_cell_data:
bcf_mapper.SetScalarModeToUseCellData()
bcf_actor.SetMapper(bcf_mapper)
renderer.AddActor(bcf_actor)
edge_mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
edge_mapper.SetInput(bcf.GetContourEdgesOutput())
else:
edge_mapper.SetInputData(bcf.GetContourEdgesOutput())
edge_mapper.SetResolveCoincidentTopologyToPolygonOffset()
edge_actor = vtk.vtkActor()
edge_actor.SetMapper(edge_mapper)
if use_gray:
edge_actor.GetProperty().SetColor(0.0, 1.0, 0.0)
else:
edge_actor.GetProperty().SetColor(0.0, 0.0, 0.0)
renderer.AddActor(edge_actor)
if show_labels:
mask = vtk.vtkMaskPoints()
if vtk.VTK_MAJOR_VERSION <= 5:
mask.SetInput(bcf.GetOutput())
else:
mask.SetInputData(bcf.GetOutput())
mask.SetOnRatio(bcf.GetOutput().GetNumberOfPoints() / 20)
mask.SetMaximumNumberOfPoints(20)
# Create labels for points - only show visible points
visible_points = vtk.vtkSelectVisiblePoints()
visible_points.SetInputConnection(mask.GetOutputPort())
visible_points.SetRenderer(renderer)
ldm = vtk.vtkLabeledDataMapper()
ldm.SetInputConnection(mask.GetOutputPort())
ldm.SetLabelFormat("%.2E")
ldm.SetLabelModeToLabelScalars()
text_property = ldm.GetLabelTextProperty()
text_property.SetFontFamilyToArial()
text_property.SetFontSize(10)
if use_gray:
text_property.SetColor(0.0, 1.0, 0.0)
else:
text_property.SetColor(0.0, 0.0, 0.0)
text_property.ShadowOff()
text_property.BoldOff()
contour_labels = vtk.vtkActor2D()
contour_labels.SetMapper(ldm)
renderer.AddActor(contour_labels)
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(lut)
if title is not None:
scalar_bar.SetTitle(title)
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(render_window_interactor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
else:
if vtk.VTK_MAJOR_VERSION <= 5:
bcf_mapper.SetInput(poly_data)
else:
bcf_mapper.SetInputData(poly_data)
bcf_actor.GetProperty().SetColor(0.0, 1.0, 0.0)
if show_mesh:
bcf_actor.GetProperty().EdgeVisibilityOn()
bcf_actor.GetProperty().SetEdgeColor(mesh_color)
bcf_actor.SetMapper(bcf_mapper)
renderer.AddActor(bcf_actor)
if show_axes:
axes = vtk.vtkAxesActor()
renderer.AddActor(axes)
render_window.Render()
render_window_interactor.Start()
# Generate ids for labeling
ids = vtk.vtkIdFilter()
ids.SetInputConnection(sphere.GetOutputPort())
ids.PointIdsOn()
ids.CellIdsOn()
ids.FieldDataOn()
# Create labels for points
visPts = vtk.vtkSelectVisiblePoints()
visPts.SetInputConnection(ids.GetOutputPort())
visPts.SetRenderer(ren1)
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()
def main():
titles = list()
textMappers = list()
textActors = list()
uGrids = list()
mappers = list()
actors = list()
renderers = list()
uGrids.append(MakeVertex())
titles.append('VTK_VERTEX (=1)')
uGrids.append(MakePolyVertex())
titles.append('VTK_POLY_VERTEX (=2)')
uGrids.append(MakeLine())
titles.append('VTK_LINE (=3)')
uGrids.append(MakePolyLine())
titles.append('VTK_POLY_LINE (=4)')
uGrids.append(MakeTriangle())
titles.append('VTK_TRIANGLE (=5)')
uGrids.append(MakeTriangleStrip())
titles.append('VTK_TRIANGLE_STRIP (=6)')
uGrids.append(MakePolygon())
titles.append('VTK_POLYGON (=7)')
uGrids.append(MakePixel())
titles.append('VTK_PIXEL (=8)')
uGrids.append(MakeQuad())
titles.append('VTK_QUAD (=9)')
uGrids.append(MakeTetra())
titles.append('VTK_TETRA (=10)')
uGrids.append(MakeVoxel())
titles.append('VTK_VOXEL (=11)')
uGrids.append(MakeHexahedron())
titles.append('VTK_HEXAHEDRON (=12)')
uGrids.append(MakeWedge())
titles.append('VTK_WEDGE (=13)')
uGrids.append(MakePyramid())
titles.append('VTK_PYRAMID (=14)')
uGrids.append(MakePentagonalPrism())
titles.append('VTK_PENTAGONAL_PRISM (=15)')
uGrids.append(MakeHexagonalPrism())
titles.append('VTK_HEXAGONAL_PRISM (=16)')
colors = vtk.vtkNamedColors()
renWin = vtk.vtkRenderWindow()
renWin.SetSize(600, 600)
renWin.SetWindowName('LinearCellDemo')
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
# Create one sphere for all
sphere = vtk.vtkSphereSource()
sphere.SetPhiResolution(21)
sphere.SetThetaResolution(21)
sphere.SetRadius(.08)
# Create one text property for all
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(10)
textProperty.SetJustificationToCentered()
# Create and link the mappers actors and renderers together.
for i in range(0, len(uGrids)):
print('Creating:', titles[i])
textMappers.append(vtk.vtkTextMapper())
textActors.append(vtk.vtkActor2D())
mappers.append(vtk.vtkDataSetMapper())
actors.append(vtk.vtkActor())
renderers.append(vtk.vtkRenderer())
mappers[i].SetInputData(uGrids[i])
actors[i].SetMapper(mappers[i])
actors[i].GetProperty().SetColor(colors.GetColor3d('Tomato'))
actors[i].GetProperty().EdgeVisibilityOn()
actors[i].GetProperty().SetLineWidth(3)
actors[i].GetProperty().SetOpacity(.5)
renderers[i].AddViewProp(actors[i])
textMappers[i].SetInput(titles[i])
textActors[i].SetMapper(textMappers[i])
textActors[i].SetPosition(50, 10)
renderers[i].AddViewProp(textActors[i])
# Label the points
labelMapper = vtk.vtkLabeledDataMapper()
labelMapper.SetInputData(uGrids[i])
labelActor = vtk.vtkActor2D()
labelActor.SetMapper(labelMapper)
renderers[i].AddViewProp(labelActor)
# Glyph the points
pointMapper = vtk.vtkGlyph3DMapper()
pointMapper.SetInputData(uGrids[i])
pointMapper.SetSourceConnection(sphere.GetOutputPort())
pointMapper.ScalingOff()
pointMapper.ScalarVisibilityOff()
pointActor = vtk.vtkActor()
pointActor.SetMapper(pointMapper)
pointActor.GetProperty().SetDiffuseColor(colors.GetColor3d('Banana'))
pointActor.GetProperty().SetSpecular(.6)
pointActor.GetProperty().SetSpecularColor(1.0, 1.0, 1.0)
pointActor.GetProperty().SetSpecularPower(100)
renderers[i].AddViewProp(pointActor)
renWin.AddRenderer(renderers[i])
# Setup the viewports
xGridDimensions = 4
yGridDimensions = 4
rendererSize = 240
renWin.SetSize(rendererSize * xGridDimensions, rendererSize * yGridDimensions)
for row in range(0, yGridDimensions):
for col in range(0, xGridDimensions):
index = row * xGridDimensions + col
# (xmin, ymin, xmax, ymax)
viewport = [float(col) / xGridDimensions,
float(yGridDimensions - (row + 1)) / yGridDimensions,
float(col + 1) / xGridDimensions,
float(yGridDimensions - row) / yGridDimensions]
if index > (len(actors) - 1):
# Add a renderer even if there is no actor.
# This makes the render window background all the same color.
ren = vtk.vtkRenderer()
ren.SetBackground(colors.GetColor3d('SlateGray'))
ren.SetViewport(viewport)
renWin.AddRenderer(ren)
continue
renderers[index].SetViewport(viewport)
renderers[index].SetBackground(colors.GetColor3d('SlateGray'))
renderers[index].ResetCamera()
renderers[index].GetActiveCamera().Azimuth(30)
renderers[index].GetActiveCamera().Elevation(-30)
if index == 0:
renderers[index].GetActiveCamera().Dolly(0.1)
renderers[index].ResetCameraClippingRange()
if index == 4:
renderers[index].GetActiveCamera().Dolly(0.8)
renderers[index].ResetCameraClippingRange()
renderers[index].ResetCameraClippingRange()
renWin.Render()
iRen.Initialize()
iRen.Start()
band_cell_edges_mapper.SetInputConnection(band_cell_edges.GetOutputPort())
band_cell_edges_actor = vtk.vtkActor()
band_cell_edges_actor.SetMapper(band_cell_edges_mapper)
band_cell_edges_actor.GetProperty().SetColor(.4,.4,.4)
# Displays the contour edges generated by the BPDCF,
# somewhat thicker than the cell edges
band_edges_mapper = vtk.vtkPolyDataMapper()
band_edges_mapper.SetInputConnection(bands.GetOutputPort(1))
band_edges_actor = vtk.vtkActor()
band_edges_actor.SetMapper(band_edges_mapper)
band_edges_actor.GetProperty().SetColor(1,1,1)
band_edges_actor.GetProperty().SetLineWidth(1.3)
# Displays the scalars of the input points of the BPDCF
scalar_value_mapper = vtk.vtkLabeledDataMapper()
scalar_value_mapper.SetInputConnection(src.GetOutputPort())
scalar_value_mapper.SetLabelModeToLabelScalars()
scalar_value_mapper.SetLabelFormat("%1.3f")
scalar_value_actor = vtk.vtkActor2D()
scalar_value_actor.SetMapper(scalar_value_mapper)
# Set up renderer and camera
r = vtk.vtkRenderer()
r.AddViewProp(bands_actor)
r.AddViewProp(band_cell_edges_actor)
r.AddViewProp(band_edges_actor)
r.AddViewProp(scalar_value_actor)
r.SetBackground(.5,.5,.5)
cam=r.GetActiveCamera()
cam.SetPosition (1.5,1.5,1)
def Execute(self):
if (self._Surface == None):
self.PrintError('vmtkOpenProfilesSeedSelector Error: Surface not set.')
return
if (self._SeedIds == None):
self.PrintError('vmtkOpenProfilesSeedSelector Error: SeedIds not set.')
return
self._SourceSeedIds.Initialize()
self._TargetSeedIds.Initialize()
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
seedPoints = vtk.vtkPoints()
for i in range(self._SeedIds.GetNumberOfIds()):
seedPoints.InsertNextPoint(self._Surface.GetPoint(self._SeedIds.GetId(i)))
seedPolyData = vtk.vtkPolyData()
seedPolyData.SetPoints(seedPoints)
seedPolyData.Update()
labelsMapper = vtk.vtkLabeledDataMapper();
labelsMapper.SetInput(seedPolyData)
labelsMapper.SetLabelModeToLabelIds()
labelsActor = vtk.vtkActor2D()
labelsActor.SetMapper(labelsMapper)
self.vmtkRenderer.Renderer.AddActor(labelsActor)
surfaceMapper = vtk.vtkPolyDataMapper()
surfaceMapper.SetInput(self._Surface)
surfaceMapper.ScalarVisibilityOff()
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(surfaceMapper)
surfaceActor.GetProperty().SetOpacity(0.25)
self.vmtkRenderer.Renderer.AddActor(surfaceActor)
self.vmtkRenderer.Render()
self.vmtkRenderer.Renderer.RemoveActor(labelsActor)
self.vmtkRenderer.Renderer.RemoveActor(surfaceActor)
seedIdString = self.InputText("Please input list of inlet profile ids: ")
separator = ' '
if seedIdString.find(',') != -1:
separator = ','
seedIdList = seedIdString.split(separator)
for seedIdString in seedIdList:
self._SourceSeedIds.InsertNextId(int(seedIdString.strip()))
seedIdString = self.InputText("Please input list of outlet profile ids (leave empty for all available profiles): ")
if seedIdString.strip() == '':
self.OutputText("Selected outlets: ")
for i in range(seedPoints.GetNumberOfPoints()):
if self._SourceSeedIds.IsId(i) == -1:
self._TargetSeedIds.InsertNextId(i)
self.OutputText("%d " % i)
self.OutputText("\n")
else:
seedIdList = seedIdString.split(separator)
for seedIdString in seedIdList:
self._TargetSeedIds.InsertNextId(int(seedIdString.strip()))
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
isoMapper.SetInputConnection(iso.GetOutputPort()) isoMapper.ScalarVisibilityOn() isoMapper.SetScalarRange(iso.GetOutput().GetScalarRange()) isoActor = vtk.vtkActor() isoActor.SetMapper(isoMapper) # Subsample the points and label them mask = vtk.vtkMaskPoints() mask.SetInputConnection(iso.GetOutputPort()) mask.SetOnRatio(expr.expr(globals(), locals(),["numPts","/","50"])) mask.SetMaximumNumberOfPoints(50) mask.RandomModeOn() # Create labels for points - only show visible points visPts = vtk.vtkSelectVisiblePoints() visPts.SetInputConnection(mask.GetOutputPort()) visPts.SetRenderer(ren1) ldm = vtk.vtkLabeledDataMapper() ldm.SetInputConnection(mask.GetOutputPort()) # ldm SetLabelFormat "%g" ldm.SetLabelModeToLabelScalars() tprop = ldm.GetLabelTextProperty() tprop.SetFontFamilyToArial() tprop.SetFontSize(10) tprop.SetColor(1,0,0) contourLabels = vtk.vtkActor2D() contourLabels.SetMapper(ldm) # Add the actors to the renderer, set the background and size # ren1.AddActor2D(isoActor) ren1.AddActor2D(contourLabels) ren1.SetBackground(1,1,1) renWin.SetSize(500,500)
def display_annot(self, images, image_pos_pat, image_ori_pat, annots_dict_list, interact):
'''Display list of annotations, put markers according to notes and color code according to sequence order'''
# define image based on subtraction of postS -preS
image = images[4]
# Proceed to build reference frame for display objects based on DICOM coords
[self.transformed_image, transform_cube] = self.dicomTransform(image, image_pos_pat, image_ori_pat)
# supports 56 annotations
color_list = [ [0,0,0], [1,0,0], [0,0,1], [0,1,1], [1,1,0], [1,0,1], [1,1,1], [0.5,0.5,0.5], [0.5,0.5,0], [1,0.2,0], [1,1,0], [0,1,1],[0,1,0.6], [0,1,1], [1,0.4,0], [0.6,0,0.2], [1,1,0], [0,1,1],[0,1,0], [0,1,1], [1,0,0.1], [1,0.4,0],[0,1,1],[0,1,0], [0,1,1], [1,0,0.1], [1,0.4,0],
[0,0,0], [1,0,0], [0,0,1], [0,1,1], [1,1,0], [1,0,1], [1,1,1], [0.5,0.5,0.5], [0.5,0.5,0], [1,0.2,0], [1,1,0], [0,1,1],[0,1,0.6], [0,1,1], [1,0.4,0], [0.6,0,0.2], [1,1,0], [0,1,1],[0,1,0], [0,1,1], [1,0,0.1], [1,0.4,0],[0,1,1],[0,1,0], [0,1,1], [1,0,0.1], [1,0.4,0] ]
a_count = 1
annot_pts_lbl = vtk.vtkPoints()
for annots_dict in annots_dict_list:
try:
float(annots_dict['SliceLocation'])
print '\n=========#'+str(a_count)
print annots_dict
######################
## Display in graphics
######################
im_pt = [0,0,0]
ijk = [0,0,0]
pco = [0,0,0]
pi_2display=[0,0,0]
pf_2display=[0,0,0]
# extract Slice locaton
pixId_sliceloc = self.transformed_image.FindPoint(self.origin[0], self.origin[1], float(annots_dict['SliceLocation']))
self.transformed_image.GetPoint(pixId_sliceloc, im_pt)
io = self.transformed_image.ComputeStructuredCoordinates( im_pt, ijk, pco)
# mark initial
print "Point init"
ijk[0] = int(annots_dict['xi'])
ijk[1] = int(annots_dict['yi'])
print ijk
annots_dict['pi_ijk']=ijk
pixId = self.transformed_image.ComputePointId(ijk)
pi_2display = self.transformed_image.GetPoint(pixId)
annots_dict['pi_2display']=pi_2display
print pi_2display
# mark final
print "Point final"
ijk[0] = int(annots_dict['xf'])
ijk[1] = int(annots_dict['yf'])
print ijk
annots_dict['pf_ijk']=ijk
pixId = self.transformed_image.ComputePointId(ijk)
pf_2display = self.transformed_image.GetPoint(pixId)
annots_dict['pf_2display']=pf_2display
print pf_2display
# Create a graphial line between the two points
annot_pts = vtk.vtkPoints()
annot_pts.InsertNextPoint(pi_2display)
annot_pts.InsertNextPoint(pf_2display)
annot_ln = vtk.vtkLine()
annot_ln.GetPointIds().SetId(0,0)
annot_ln.GetPointIds().SetId(1,1)
note_lines = vtk.vtkCellArray()
note_lines.InsertNextCell(annot_ln)
annot_poly = vtk.vtkPolyData()
annot_poly.SetPoints(annot_pts)
annot_poly.SetLines(note_lines)
annot_poly.Update()
# Create mappers and actors
annot_mapper_mesh = vtk.vtkPolyDataMapper()
annot_mapper_mesh.SetInputData( annot_poly )
self.annot_actor = vtk.vtkActor()
self.annot_actor.SetMapper(annot_mapper_mesh)
self.annot_actor.GetProperty().SetColor(color_list[a_count])
self.annot_actor.GetProperty().SetLineWidth(3)
self.annot_actor.GetProperty().SetOpacity(0.6)
self.annot_actor.GetProperty().SetPointSize(7.0)
self.annot_actor.GetProperty().SetRepresentationToWireframe()
############
# Generate data arrays containing label ids
annot_pts_lbl.InsertPoint(a_count, pi_2display)
# add annotation to scene
print annots_dict
self.renderer1.AddActor(self.annot_actor)
# Initizalize
self.renWin1.Render()
self.renderer1.Render()
a_count +=1
except ValueError:
a_count +=1
pass
############
print annot_pts_lbl.GetNumberOfPoints()
annot_lbl_poly = vtk.vtkPolyData()
annot_lbl_poly.SetPoints(annot_pts_lbl)
annot_lbl_poly.Update()
# Generate data arrays containing label ids
ids = vtk.vtkIdFilter()
ids.SetInput(annot_lbl_poly)
ids.PointIdsOn()
ids.CellIdsOff()
# Create labels for points
visPts = vtk.vtkSelectVisiblePoints()
visPts.SetInput(ids.GetOutput())
visPts.SetRenderer(self.renderer1)
visPts.SelectionWindowOff()
# 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.SetInput(visPts.GetOutput())
ldm.SetLabelModeToLabelFieldData()
pointLabels = vtk.vtkActor2D()
pointLabels.SetMapper(ldm)
# initialize
self.renderer1.AddActor2D(pointLabels)
print "\n====== Color codes:\n "
print '\033[1;31m 1) Red '
print '\033[1;34m 2) Blue '
print '\033[1;36m 3) Cyan '
print '\033[1;33m 4) Yellow '
print '\033[1;35m 5) Fushia '
print '\033[1;37m 6) White '
print '\033[1;30m 7) Gray '
print '\033[1;0m'
############
if(interact==True):
interactor = self.renWin1.GetInteractor()
interactor.Start()
return
def displayPolyAndDataLabels(poly, title = 'Polydata'):
"""
display a poly and 3 planes
"""
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(poly)
actor1 = vtk.vtkActor()
actor1.SetMapper(mapper)
actor1.GetProperty().SetColor(1,0,0) #RED
actor1.GetProperty().SetOpacity(1.0)
mapper2 = vtk.vtkPolyDataMapper()
mapper2.SetResolveCoincidentTopologyToPolygonOffset()
mapper2.ScalarVisibilityOff()
mapper2.SetInput(poly)
actor2 = vtk.vtkActor()
actor2.SetMapper(mapper2)
actor2.GetProperty().SetRepresentationToWireframe()
actor2.GetProperty().SetColor(1,1,1)
actor2.GetProperty().SetAmbient(1.0)
actor2.GetProperty().SetDiffuse(0.0)
actor2.GetProperty().SetSpecular(0.0)
ids = vtk.vtkIdFilter()
ids.SetInput(poly)
ids.PointIdsOn()
ids.CellIdsOn()
ids.FieldDataOn()
ren= vtk.vtkRenderer()
ren.AddActor(actor1)
ren.AddActor(actor2)
ren.SetBackground(1,1,1)
# Create labels for points
visPts = vtk.vtkSelectVisiblePoints()
visPts.SetInputConnection(ids.GetOutputPort())
visPts.SetRenderer(ren)
# 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.GetLabelTextProperty().ShadowOff()
ldm.GetLabelTextProperty().SetColor(0,0,0)
# ldm.SetLabelFormat("%g")
ldm.SetInputConnection(visPts.GetOutputPort())
ldm.SetLabelModeToLabelFieldData()
pointLabels = vtk.vtkActor2D()
pointLabels.SetMapper(ldm)
ren.AddActor2D(pointLabels)
renwin = vtk.vtkRenderWindow()
renwin.AddRenderer(ren)
renwin.SetSize( 700, 700 )
renwin.SetWindowName(title)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renwin)
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
ren.ResetCamera()
cam1 = ren.GetActiveCamera()
cam1.Elevation(-90)
cam1.SetViewUp(0, 0, 1)
cam1.Azimuth(45)
ren.ResetCameraClippingRange()
iren.Initialize()
renwin.Render()
iren.Start()
