def onChar(self, obj, event):
key = self.GetInteractor().GetKeySym()
if key == "q":
self.txt_startp = vtk.vtkTextActor()
self.txt_startp.SetInput("Click on starting cell")
txtprop = self.txt_startp.GetTextProperty()
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(18)
txtprop.SetColor(1, 1, 1)
self.txt_startp.SetDisplayPosition(0, 0)
self.ren.AddActor(self.txt_startp)
self.rw.Render()
self.leftag = self.AddObserver("LeftButtonPressEvent",
self.chooseStartingCell)
if key == "a":
self.txt_target = vtk.vtkTextActor()
self.txt_target.SetInput("Click target point")
txtprop = self.txt_target.GetTextProperty()
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(18)
txtprop.SetColor(1, 1, 1)
self.txt_target.SetDisplayPosition(0, 0)
self.ren.AddActor(self.txt_target)
self.rw.Render()
self.leftag = self.AddObserver("LeftButtonPressEvent",
self.chooseTarget)
def __init__(self, style):
super().__init__()
self.background_color = (0,0,0)
self._renderer = vtk.vtkRenderer()
self._renderer.SetBackground(self.background_color)
self._style = style
self._style.SetDefaultRenderer(self._renderer)
self._textActor = vtk.vtkTextActor()
self.textActorStress = vtk.vtkTextActor()
self.actors = {}
self._inUse = False
self._usePicker = True
self.textProperty = vtk.vtkTextProperty()
self.textProperty.SetFontSize(17)
self.textProperty.SetColor((1,1,1))
self.textProperty.BoldOn()
# self.textProperty.SetItalic(1)
self._logo_pulse = vtk.vtkLogoRepresentation()
self._logo_mopt = vtk.vtkLogoRepresentation()
self._imageReader_pulse = vtk.vtkPNGReader()
self._imageReader_mopt = vtk.vtkPNGReader()
self.changeLogosToGetBetterContrast()
self._createConfigLogos()
def __init__(self, inputs=None):
if inputs is None:
inputs = {
'magnify' : 1,
'debug' : False,
'console' : True,
'is_groups' : False,
}
#GuiCommon.__init__(self, inputs=inputs)
res_widget = MockResWidget()
kwds = {
'inputs' : inputs,
'res_widget' : res_widget
}
#GuiAttributes.__init__(self, **kwds)
GuiCommon.__init__(self, **kwds)
self.res_widget = res_widget
self.vtk_interactor = VTKInteractor()
self.debug = False
self._form = []
self.result_cases = OrderedDict()
#self.geometry_actors = {
#'main' : vtkActor(),
#}
self.main_grid_mappers = {'main' : GridMapper()}
self.grid = vtk.vtkUnstructuredGrid()
#self.scalarBar = ScalarBar()
self.scalar_bar = ScalarBar()
self.alt_geometry_actor = ScalarBar()
self.alt_grids = {
'main' : self.grid,
}
self.main_geometry_actors = {
'main' : vtkActor(),
}
self.glyph_source = ArrowSource()
self.glyphs = Glyph3D()
self.glyph_mapper = PolyDataMapper()
self.arrow_actor = vtkLODActor()
self.arrow_actor_centroid = vtkLODActor()
#self.geometry_properties = {
#'main' : None,
#'caero' : None,
#'caero_sub' : None,
#}
#self._add_alt_actors = _add_alt_actors
level = 'debug' if self.debug else 'info'
self.log = get_logger(log=None, level=level)
self.rend = vtkRenderer()
self.text_actors[0] = vtkTextActor()
self.text_actors[1] = vtkTextActor()
self.text_actors[2] = vtkTextActor()
self.text_actors[3] = vtkTextActor()
self.format_class_map = CLASS_MAP
def Initialize(self):
if not self.Renderer:
self.Renderer = vtk.vtkRenderer()
self.Renderer.SetBackground(self.Background)
self.RenderWindow = vtk.vtkRenderWindow()
self.RenderWindow.AddRenderer(self.Renderer)
self.RenderWindow.SetSize(self.WindowSize[0],self.WindowSize[1])
self.RenderWindow.SetPosition(self.WindowPosition[0],self.WindowPosition[1])
self.RenderWindow.SetPointSmoothing(self.PointSmoothing)
self.RenderWindow.SetLineSmoothing(self.LineSmoothing)
self.RenderWindow.SetPolygonSmoothing(self.PolygonSmoothing)
self.RenderWindowInteractor = vtk.vtkRenderWindowInteractor()
#if 'vtkCocoaRenderWindowInteractor' in dir(vtk) and vtk.vtkCocoaRenderWindowInteractor.SafeDownCast(self.RenderWindowInteractor):
# self.RenderWindowInteractor = vtkvmtk.vtkvmtkCocoaRenderWindowInteractor()
self.RenderWindow.SetInteractor(self.RenderWindowInteractor)
self.RenderWindowInteractor.SetInteractorStyle(vtkvmtk.vtkvmtkInteractorStyleTrackballCamera())
self.RenderWindowInteractor.GetInteractorStyle().KeyPressActivationOff()
self.RenderWindowInteractor.GetInteractorStyle().AddObserver("CharEvent",self.CharCallback)
self.RenderWindowInteractor.GetInteractorStyle().AddObserver("KeyPressEvent",self.KeyPressCallback)
self.AddKeyBinding('x','Take screenshot.',self.ScreenshotCallback,'0')
self.AddKeyBinding('r','Reset camera.',self.ResetCameraCallback,'0')
#self.AddKeyBinding('w','Show wireframe.',None,'0')
#self.AddKeyBinding('r','Reset camera.',self.ResetCameraCallback, '0')
#self.AddKeyBinding('s','Show surface.', None,'0')
#self.AddKeyBinding('e','Quit renderer.',self.QuitRendererCallback,'0')
self.AddKeyBinding('q','Quit renderer/proceed.',self.QuitRendererCallback,'0')
#self.AddKeyBinding('3','3D.', None,'0')
#self.TextActorStd = vtk.vtkTextActor()
#self.TextActorStd.SetPosition(self.PositionStd)
#self.Renderer.AddActor(self.TextActorStd)
fontSize = int(self._GetScreenFontSize())
self.TextActor = vtk.vtkTextActor()
self.TextActor.GetTextProperty().SetFontSize(fontSize)
self.TextActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport()
self.TextActor.GetPosition2Coordinate().SetCoordinateSystemToNormalizedViewport()
self.TextActor.SetPosition(self.Position)
self.Renderer.AddActor(self.TextActor)
#self.TextActorOpmode = vtk.vtkTextActor()
#self.TextActorOpmode.SetPosition(self.PositionOpmode)
#self.Renderer.AddActor(self.TextActorOpmode)
self.TextInputActor = vtk.vtkTextActor()
self.TextInputActor.GetTextProperty().SetFontSize(fontSize)
self.TextInputActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport()
self.TextInputActor.GetPosition2Coordinate().SetCoordinateSystemToNormalizedViewport()
self.TextInputActor.SetPosition(self.InputPosition)
if self.UseRendererInputStream:
self.InputStream = vmtkRendererInputStream(self)
def Initialize(self):
if not self.Renderer:
self.Renderer = vtk.vtkRenderer()
self.Renderer.SetBackground(self.Background)
self.RenderWindow = vtk.vtkRenderWindow()
self.RenderWindow.AddRenderer(self.Renderer)
self.RenderWindow.SetSize(self.WindowSize[0],self.WindowSize[1])
self.RenderWindow.SetPosition(self.WindowPosition[0],self.WindowPosition[1])
self.RenderWindow.SetPointSmoothing(self.PointSmoothing)
self.RenderWindow.SetLineSmoothing(self.LineSmoothing)
self.RenderWindow.SetPolygonSmoothing(self.PolygonSmoothing)
self.RenderWindowInteractor = vtk.vtkRenderWindowInteractor()
#if 'vtkCocoaRenderWindowInteractor' in dir(vtk) and vtk.vtkCocoaRenderWindowInteractor.SafeDownCast(self.RenderWindowInteractor):
# self.RenderWindowInteractor = vtkvmtk.vtkvmtkCocoaRenderWindowInteractor()
self.RenderWindow.SetInteractor(self.RenderWindowInteractor)
self.RenderWindowInteractor.SetInteractorStyle(vtkvmtk.vtkvmtkInteractorStyleTrackballCamera())
self.RenderWindowInteractor.GetInteractorStyle().KeyPressActivationOff()
self.RenderWindowInteractor.GetInteractorStyle().AddObserver("CharEvent",self.CharCallback)
self.RenderWindowInteractor.GetInteractorStyle().AddObserver("KeyPressEvent",self.KeyPressCallback)
self.AddKeyBinding('x','Take screenshot.',self.ScreenshotCallback,'0')
self.AddKeyBinding('r','Reset camera.',self.ResetCameraCallback,'0')
#self.AddKeyBinding('w','Show wireframe.',None,'0')
#self.AddKeyBinding('r','Reset camera.',self.ResetCameraCallback, '0')
#self.AddKeyBinding('s','Show surface.', None,'0')
#self.AddKeyBinding('e','Quit renderer.',self.QuitRendererCallback,'0')
self.AddKeyBinding('q','Quit renderer/proceed.',self.QuitRendererCallback,'0')
#self.AddKeyBinding('3','3D.', None,'0')
#self.TextActorStd = vtk.vtkTextActor()
#self.TextActorStd.SetPosition(self.PositionStd)
#self.Renderer.AddActor(self.TextActorStd)
fontSize = int(self._GetScreenFontSize())
self.TextActor = vtk.vtkTextActor()
self.TextActor.GetTextProperty().SetFontSize(fontSize)
self.TextActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport()
self.TextActor.GetPosition2Coordinate().SetCoordinateSystemToNormalizedViewport()
self.TextActor.SetPosition(self.Position)
self.Renderer.AddActor(self.TextActor)
#self.TextActorOpmode = vtk.vtkTextActor()
#self.TextActorOpmode.SetPosition(self.PositionOpmode)
#self.Renderer.AddActor(self.TextActorOpmode)
self.TextInputActor = vtk.vtkTextActor()
self.TextInputActor.GetTextProperty().SetFontSize(fontSize)
self.TextInputActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport()
self.TextInputActor.GetPosition2Coordinate().SetCoordinateSystemToNormalizedViewport()
self.TextInputActor.SetPosition(self.InputPosition)
if self.UseRendererInputStream:
self.InputStream = vmtkRendererInputStream(self)
def createAnnotations(self):
# Add axes.
self.axesActor = vtk.vtkAxesActor()
self.axesActor.SetTotalLength(30,30,30)
self.axesActor.SetShaftTypeToCylinder()
self.axesActor.SetCylinderRadius(.05)
self.axesActor.GetXAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(12)
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty().ItalicOff()
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty().BoldOff()
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
self.axesActor.GetYAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(12)
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty().ItalicOff()
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty().BoldOff()
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
self.axesActor.GetZAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(12)
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty().ItalicOff()
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty().BoldOff()
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
self.addActor(self.axesActor)
# Add handling info.
self.infoText = vtk.vtkTextActor()
self.infoText.SetInput("Rotate: Left mouse button\nPan: Middle mouse button\nZoom: Right mouse button")
self.infoText.GetTextProperty()
self.infoText.GetTextProperty().SetFontFamilyToArial()
self.infoText.GetTextProperty().SetFontSize(11)
self.infoText.GetTextProperty().SetColor(.6,.6,.6)
self.infoText.SetDisplayPosition(20,30)
self.addActor(self.infoText)
def __init__(self, parent, visualizer, **kws):
"""
Initialization
"""
self.x, self.y, self.z = -1, -1, -1
VisualizationModule.__init__(self, parent, visualizer, **kws)
#self.name = "Scale bar"
self.renew = 1
self.mapper = vtk.vtkDataSetMapper()
self.actor = vtk.vtkActor()
self.actor.SetMapper(self.mapper)
self.width = 10
self.widthPx = 100
self.voxelSize = (1, 1, 1)
self.renderer = self.parent.getRenderer()
self.renderer.AddActor(self.actor)
self.polyLine = vtk.vtkPolyLine()
#self.mapper.SetInput(self.polyLine.GetOutput())
self.actor.GetProperty().SetColor(1, 1, 1)
self.textActor = vtk.vtkTextActor()
#self.textActor.ScaledTextOn()
self.renderer.AddActor2D(self.textActor)
iactor = self.wxrenwin.GetRenderWindow().GetInteractor()
style = iactor.GetInteractorStyle()
# style.AddObserver("StartInteractionEvent",self.updateLine)
style.AddObserver("EndInteractionEvent", self.updateRendering)
def CreateTextActor(text,textprop,xpos,ypos, justification="left", verticaljustification="bottom") : textactor = vtk.vtkTextActor() textactor.SetInput(text) textactor.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport() textactor.SetPosition(xpos,ypos) textactor.GetTextProperty().SetFontFamily(textprop.GetFontFamily()) textactor.GetTextProperty().SetColor(textprop.GetColor()) if justification in (-1,"left") : textactor.GetTextProperty().SetJustificationToLeft() elif justification in (0,"center","middle") : textactor.GetTextProperty().SetJustificationToCentered() elif justification in (1,"right") : textactor.GetTextProperty().SetJustificationToRight() if verticaljustification in (-1,"bottom") : textactor.GetTextProperty().SetVerticalJustificationToBottom() elif verticaljustification in (0,"center","middle") : textactor.GetTextProperty().SetVerticalJustificationToCentered() elif verticaljustification in (1,"top") : textactor.GetTextProperty().SetVerticalJustificationToTop() return textactor
def main():
textActor = vtk.vtkTextActor()
textActor.SetInput("Hello CMR")
textActor.SetTextScaleModeToProp()
tprop = textActor.GetTextProperty()
tprop.SetFontSize(40)
earthSource = vtk.vtkEarthSource()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(earthSource.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderWindow = vtk.vtkRenderWindow()
renderer = vtk.vtkRenderer()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(500, 500)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(actor)
renderer.AddActor2D(textActor)
renderWindow.Render()
renderWindow.Render()
renderWindowInteractor.Start()
def onRenderEnd(self, event=None, e2=None):
"""
Called when rendering ends
"""
self.rendering = 0
if self.rubberband:
self.iren.SetInteractorStyle(self.oldStyle)
self.rubberband = 0
if self.showFPS:
if not self.textActor:
self.textActor = vtk.vtkTextActor()
prop = self.textActor.GetTextProperty()
prop.SetFontSize(14)
self.textActor.SetTextProperty(prop)
# changing w,h to width,height (SS 25.06.07)
width, height = self.renderer.GetSize()
self.textActor.SetDisplayPosition(width - 85, height - 50)
self.renderer.AddActor(self.textActor)
t = time.time() - self.endTime
if not t:
return
fps = 1.0 / t
self.endTime = time.time()
renderTime = self.renderer.GetLastRenderTimeInSeconds()
txt = "fps %.1f\ntime %.3fs" % (fps, renderTime)
self.textActor.SetInput(txt)
def __init__(self,
font_size=14,
color=(0.0, 0.0, 0.0),
relative_position=(0, 1),
absolute_offset=(10, -10),
text="",
**kwargs):
kwargs["text"] = text
kwargs['color'] = color
kwargs["absolute_offset"] = absolute_offset
kwargs["relative_position"] = relative_position
kwargs["font_size"] = font_size
self.actor = vtk.vtkTextActor()
self.text_property = self.actor.GetTextProperty()
self.text_property.SetFontFamilyToCourier()
self.text_property.SetVerticalJustificationToTop()
self.relpos_coord = vtk.vtkCoordinate()
self.relpos_coord.SetCoordinateSystemToNormalizedViewport()
self.actor.GetPositionCoordinate().SetCoordinateSystemToViewport()
self.actor.GetPositionCoordinate().SetReferenceCoordinate(
self.relpos_coord)
self._process_kwargs(**kwargs)
def __init__(self, _drawModel):
self.legendActor = vtk.vtkScalarBarActor()
self.legendActor.SetNumberOfLabels(8)
(self.minCon, self.maxCon) = (0, 0)
self.plane = 'XY'
self.planePos = 0
self.ren = None
dM = ref(_drawModel)
self.drawModel = dM()
self.currentDrawingFunction = None
self.currentActors = {} # dictionary of current actors
self.drawingFcnName = "" # holds a string describing name of the drawing fcn . Used to determine if current actors need to be removed before next drawing
self.drawingFcnHasChanged = True
self.fieldTypes = None
self.currentDrawingParameters = DrawingParameters()
# self.currentFieldType = ("Cell_Field", FIELD_TYPES[0])
self.currentFieldType = ("Cell_Field", 'CellField')
self.__initDist = 0 # initial camera distance - used in zoom functions
self.min_max_text_actor = vtk.vtkTextActor()
# CUSTOM ACTORS
self.customActors = {} # {visName: CustomActorsStorage() }
self.currentCustomVisName = '' # stores name of the current custom visualization
self.currentVisName = '' # stores name of the current visualization
self.cameraSettingsDict = {} # {fieldName:CameraSettings()}
def add(**kwargs):
ren = vtk.vtkRenderer()
ren.SetBackground(0.5, 0.5, 0.5)
#ren.SetViewport(0, 0, 0.5, 1)
renWin.AddRenderer(ren)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(elev.GetOutputPort())
mapper.SetLookupTable(lut)
mapper.SetInterpolateScalarsBeforeMapping(kwargs['interpolate_scalars_before_mapping'])
mapper.SetScalarMaterialMode(kwargs["material_mode"])
actor = vtk.vtkActor()
actor.SetMapper(mapper)
ren.AddActor(actor)
prop = actor.GetProperty()
prop.SetAmbient(kwargs['ambient'])
prop.SetDiffuse(kwargs['diffuse'])
prop.SetAmbientColor(1, 0, 0)
prop.SetDiffuseColor(0, 1, 0)
textActorL = vtk.vtkTextActor()
txt = " InterpolateScalarsBeforeMapping: %d\n"\
" ScalarMaterialMode: %s\n"\
" Ambient: %.2f\t Ambient Color: 1, 0, 0\n"\
" Diffuse: %.2f\t Diffuse Color: 0, 1, 0"
txt = txt % (kwargs['interpolate_scalars_before_mapping'],
mapper.GetScalarMaterialModeAsString(), prop.GetAmbient(), prop.GetDiffuse())
textActorL.SetInput(txt)
ren.AddActor(textActorL)
return (ren, actor, mapper)
def max_disp(reader):
out = reader.GetOutput()
points = out.GetPoints()
data = out.GetPointData()
vectors = data.GetVectors()
u_max = 0
v_max = 0
u_ind = 0
v_ind = 0
for i in range(points.GetNumberOfPoints()):
u_current = vectors.GetTuple(i)[0]
v_current = vectors.GetTuple(i)[1]
if abs(u_current) > abs(u_max):
u_max = u_current
u_ind = i
if abs(v_current) > abs(v_max):
v_max = v_current
v_ind = i
max_text_actor = vtk.vtkTextActor()
u_max_position = out.GetPoint(u_ind)
v_max_position = out.GetPoint(v_ind)
max_text = """
u_max = %.5f mm \n@ (%.2f, %.2f)\n
v_max = %.5f mm \n@ (%.2f, %.2f)
""" %(u_max*100, u_max_position[0], u_max_position[1],
v_max*100, v_max_position[0], v_max_position[1])
max_text_actor.SetInput(max_text)
max_text_actor.SetVisibility(0)
pos = max_text_actor.GetPositionCoordinate()
pos.SetCoordinateSystemToNormalizedDisplay()
max_text_actor.SetPosition(0.8, 0.5)
prop = max_text_actor.GetTextProperty()
prop.SetFontSize(16)
return max_text_actor
def __init__(self, interactor, string, movable=False, on_move=None, on_drag=None, on_click=None, fgcolor=(
1, 1, 1), size=24, font="Arial", left=0, top=0, textproperty=None):
if textproperty is not None:
self.actor = vtkTextActor()
self.actor.SetInput(string)
self.actor.SetTextProperty(textproperty)
if textproperty.GetBackgroundColor() == textproperty.GetColor():
textproperty.SetBackgroundColor(
*
white_or_black(
*
textproperty.GetColor()))
else:
self.actor = text_actor(string, fgcolor, size, font)
widget = WidgetReprShim(interactor, self.actor)
super(Label, self).__init__(interactor, widget)
self.movable = movable
self.action = on_click
self.move_action = on_move
self.dragged = on_drag
self.actor.SetTextScaleModeToNone()
self.actor.SetUseBorderAlign(False)
self.actor.VisibilityOff()
self.left = left
self.top = top
self.register()
def add_text(self, string, pos=[20, 20], size=64):
textActor = vtk.vtkTextActor()
textActor.GetTextProperty().SetFontSize(size)
textActor.SetPosition(pos[0], pos[1])
self.ren.AddActor2D(textActor)
textActor.SetInput(string)
textActor.GetTextProperty().SetColor(0.0, 0.0, 0.0)
def __init__(self, annotation, layer):
############################
# Property-related members #
############################
self._annotation = None
self._layer = None
self._slice_position_world = None
self._text_actor = vtkTextActor()
###################
# Private members #
###################
self._shape = None
self._renderer = None
##################
# Initialization #
##################
text_property = self._text_actor.GetTextProperty()
text_property.ShadowOff()
text_property.SetFontFamilyToArial()
text_property.BoldOff()
text_property.ItalicOff()
text_property.SetFontSize(12)
self._set_annotation(annotation)
self._set_layer(layer)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setCentralWidget(QVTKRenderWindowInteractor())
self.renderWindow = self.centralWidget().GetRenderWindow()
#Set REnderer
self.renderer = vtk.vtkRenderer()
self.renderWindow.GetInteractor().SetInteractorStyle(
vtk.vtkInteractorStyleTrackballCamera())
self.renderWindow.AddRenderer(self.renderer)
self.txtActor = vtk.vtkTextActor()
self.txtActor.SetInput("Preparing...")
self.txtActor.GetTextProperty().SetFontFamilyToArial()
self.txtActor.GetTextProperty().SetFontSize(46)
self.txtActor.GetTextProperty().SetColor(1, 1, 0)
self.txtActor.SetDisplayPosition(100, 900)
self.renderer.AddActor(self.txtActor)
input_actor = utils.MakeActor(input_poly)
self.renderer.AddActor(input_actor)
self.renderer.GetActiveCamera().Pitch(-45)
self.renderer.ResetCamera()
self.renderWindow.Render()
#Thread
self.thread = TrainingThread()
self.thread.signal_log.connect(self.onLog)
self.thread.start()
def onRenderEnd(self, event=None, e2=None):
"""
Called when rendering ends
"""
self.rendering = 0
if self.rubberband:
self.iren.SetInteractorStyle(self.oldStyle)
self.rubberband = 0
if self.showFPS:
if not self.textActor:
self.textActor = vtk.vtkTextActor()
prop = self.textActor.GetTextProperty()
prop.SetFontSize(14)
self.textActor.SetTextProperty(prop)
# changing w,h to width,height (SS 25.06.07)
width, height = self.renderer.GetSize()
self.textActor.SetDisplayPosition(width - 85, height - 50)
self.renderer.AddActor(self.textActor)
t = time.time() - self.endTime
if not t:
return
fps = 1.0 / t
self.endTime = time.time()
renderTime = self.renderer.GetLastRenderTimeInSeconds()
txt = "fps %.1f\ntime %.3fs" % (fps, renderTime)
self.textActor.SetInput(txt)
def add(**kwargs):
ren = vtk.vtkRenderer()
ren.SetBackground(0.5, 0.5, 0.5)
#ren.SetViewport(0, 0, 0.5, 1)
renWin.AddRenderer(ren)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(elev.GetOutputPort())
mapper.SetLookupTable(lut)
mapper.SetInterpolateScalarsBeforeMapping(
kwargs['interpolate_scalars_before_mapping'])
mapper.SetScalarMaterialMode(kwargs["material_mode"])
actor = vtk.vtkActor()
actor.SetMapper(mapper)
ren.AddActor(actor)
prop = actor.GetProperty()
prop.SetAmbient(kwargs['ambient'])
prop.SetDiffuse(kwargs['diffuse'])
prop.SetAmbientColor(1, 0, 0)
prop.SetDiffuseColor(0, 1, 0)
textActorL = vtk.vtkTextActor()
txt = " InterpolateScalarsBeforeMapping: %d\n"\
" ScalarMaterialMode: %s\n"\
" Ambient: %.2f\t Ambient Color: 1, 0, 0\n"\
" Diffuse: %.2f\t Diffuse Color: 0, 1, 0"
txt = txt % (kwargs['interpolate_scalars_before_mapping'],
mapper.GetScalarMaterialModeAsString(), prop.GetAmbient(),
prop.GetDiffuse())
textActorL.SetInput(txt)
ren.AddActor(textActorL)
return (ren, actor, mapper)
def __init__(self):
self.MotionFactor = 10.0
self.MouseWheelMotionFactor = 1.0
self.MinHeight = 5.0
self.MaxHeight = 1e6
self.MinParallelScale = 0.5
self.MaxParallelScale = 2500
self.AddObserver("MouseMoveEvent", self.mouseMoveEvent)
self.AddObserver("LeftButtonPressEvent", self.leftButtonPressEvent)
self.AddObserver("LeftButtonReleaseEvent", self.leftButtonReleaseEvent)
self.AddObserver("RightButtonPressEvent", self.rightButtonPressEvent)
self.AddObserver("RightButtonReleaseEvent",
self.rightButtonReleaseEvent)
self.AddObserver("MiddleButtonPressEvent", self.middleButtonPressEvent)
self.AddObserver("MiddleButtonReleaseEvent",
self.middleButtonReleaseEvent)
self.AddObserver("MouseWheelForwardEvent", self.mouseWheelForwardEvent)
self.AddObserver("MouseWheelBackwardEvent",
self.mouseWheelBackwardEvent)
self.AddObserver("KeyPressEvent", self.keyPressEvent)
self.AddObserver("KeyReleaseEvent", self.keyReleaseEvent)
self.coordText = vtk.vtkTextActor()
self.coordText.GetTextProperty().SetColor(255 / 255.0, 25 / 255.0,
15 / 255.0)
self.coordText.GetTextProperty().BoldOn()
self.ctrlKey = False
def text_actor(string, fgcolor, size, font):
"""
Build a text actor with some sane defaults
"""
actor = vtkTextActor()
actor.SetInput(string)
props = actor.GetTextProperty()
__set_font(font, props)
props.SetFontSize(size)
props.SetColor(*fgcolor)
props.SetBackgroundColor(white_or_black(*fgcolor))
props.SetBackgroundOpacity(0)
# Sane defaults.
props.SetJustificationToCentered()
props.SetVerticalJustificationToTop()
if string.find("\n") != -1:
lines = string.split("\n")
width = size * max([len(s) for s in lines])
actor.SetPosition(width / 2.0, 0)
return actor
def __init__(self,
text_str,
position=(0, 0),
fontsize=18,
use_pixels=False,
color=(1, 1, 1),
opacity=None,
fig="gcf"):
# create a text actor
super().__init__(fig)
self.actor = vtk.vtkTextActor()
self.text = text_str
self.use_pixels = use_pixels
self.property = self.actor.GetTextProperty()
self.property.SetFontFamilyToArial()
self.property.SetFontSize(fontsize)
self.color_opacity(color, opacity)
self.actor.SetPosition(*position)
# assign actor to the renderer
self.fig += self
def createAnnotations(self):
# Add axes.
self.axesActor = vtk.vtkAxesActor()
self.axesActor.SetTotalLength(30,30,30)
self.axesActor.SetShaftTypeToCylinder()
self.axesActor.SetCylinderRadius(.05)
self.axesActor.GetXAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(12)
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty().ItalicOff()
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty().BoldOff()
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
self.axesActor.GetYAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(12)
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty().ItalicOff()
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty().BoldOff()
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
self.axesActor.GetZAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(12)
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty().ItalicOff()
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty().BoldOff()
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
self.addActor(self.axesActor)
# Add handling info.
self.infoText = vtk.vtkTextActor()
self.infoText.SetInput("Rotate: Left mouse button\nPan: Middle mouse button\nZoom: Right mouse button")
self.infoText.GetTextProperty()
self.infoText.GetTextProperty().SetFontFamilyToArial()
self.infoText.GetTextProperty().SetFontSize(11)
self.infoText.GetTextProperty().SetColor(.6,.6,.6)
self.infoText.SetDisplayPosition(20,30)
self.addActor(self.infoText)
def __init__(self, guiText=""):
self.text = vtk.vtkTextActor()
self.text.SetInput(guiText)
textProperties = self.text.GetTextProperty()
textProperties.SetFontSize(15)
textProperties.SetColor(1, 1, 1)
self.text.SetDisplayPosition(10, 2)
def text_actor(string, fgcolor, size, font):
"""
Build a text actor with some sane defaults
"""
actor = vtkTextActor()
actor.SetInput(string)
props = actor.GetTextProperty()
__set_font(font, props)
props.SetFontSize(size)
props.SetColor(*fgcolor)
props.SetBackgroundColor(white_or_black(*fgcolor))
props.SetBackgroundOpacity(0)
# Sane defaults.
props.SetJustificationToCentered()
props.SetVerticalJustificationToTop()
if string.find("\n") != -1:
lines = string.split("\n")
width = size * max([len(s) for s in lines])
actor.SetPosition(width / 2.0, 0)
return actor
def viz_SetViewportName(self, name, x, y, fontsize=14, color=[0, 0, 0]):
text = vtk.vtkTextActor()
text.SetInput(name)
text.SetPosition(x, y)
text.GetTextProperty().SetFontSize(fontsize)
text.GetTextProperty().SetColor(color[0], color[1], color[2])
self.__ren.AddActor2D(text)
def __addText(self, text, x, y):
textActor = vtk.vtkTextActor()
textActor.SetDisplayPosition(x, y)
textActor.SetInput(text)
textActor.GetTextProperty().SetColor(0.5, 0.5, 0.5)
textActor.GetTextProperty().SetFontSize(36)
return textActor
def __init__(self):
self.layer = 99
self.children = []
property = vtk.vtkTextProperty()
property.SetFontSize(const.TEXT_SIZE_LARGE)
property.SetFontFamilyToArial()
property.BoldOn()
property.ItalicOff()
#property.ShadowOn()
property.SetJustificationToLeft()
property.SetVerticalJustificationToTop()
property.SetColor(const.TEXT_COLOUR)
self.property = property
actor = vtk.vtkTextActor()
actor.GetTextProperty().ShallowCopy(property)
actor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay()
actor.PickableOff()
self.actor = actor
self.text = ''
self.position = (0, 0)
self.symbolic_syze = wx.FONTSIZE_MEDIUM
self.bottom_pos = False
self.right_pos = False
def genTextActor(renderer,string=None,x=None,y=None,to='default',tt='default',cmap=None):
if isinstance(to,str):
to = vcs.elements["textorientation"][to]
if isinstance(tt,str):
tt = vcs.elements["texttable"][tt]
if tt.priority==0:
return
if string is None:
string = tt.string
if x is None:
x = tt.x
if y is None:
y = tt.y
if x is None or y is None or string in [['',],[]]:
return
n = max(len(x),len(y),len(string))
for a in [x,y,string]:
while len(a)<n:
a.append(a[-1])
sz = renderer.GetRenderWindow().GetSize()
for i in range(n):
t = vtk.vtkTextActor()
p=t.GetTextProperty()
prepTextProperty(p,sz,to,tt,cmap)
t.SetInput(string[i])
X,Y = world2Renderer(renderer,x[i],y[i],tt.viewport,tt.worldcoordinate)
t.SetPosition(X,Y)
#T=vtk.vtkTransform()
#T.Scale(1.,sz[1]/606.,1.)
#T.RotateY(to.angle)
#t.SetUserTransform(T)
renderer.AddActor(t)
return
def __init__(self, _drawModel):
self.legendActor = vtk.vtkScalarBarActor()
self.legendActor.SetNumberOfLabels(8)
(self.minCon, self.maxCon) = (0, 0)
self.plane = 'XY'
self.planePos = 0
self.ren = None
dM = ref(_drawModel)
self.drawModel = dM()
self.currentDrawingFunction = None
self.currentActors = {} # dictionary of current actors
self.drawingFcnName = "" # holds a string describing name of the drawing fcn . Used to determine if current actors need to be removed before next drawing
self.drawingFcnHasChanged = True
self.fieldTypes = None
self.currentDrawingParameters = DrawingParameters()
# self.currentFieldType = ("Cell_Field", FIELD_TYPES[0])
self.currentFieldType = ("Cell_Field", 'CellField')
self.__initDist = 0 # initial camera distance - used in zoom functions
self.min_max_text_actor = vtk.vtkTextActor()
# CUSTOM ACTORS
self.customActors = {} # {visName: CustomActorsStorage() }
self.currentCustomVisName = '' # stores name of the current custom visualization
self.currentVisName = '' # stores name of the current visualization
self.cameraSettingsDict = {} # {fieldName:CameraSettings()}
def genTextActor(renderer,string=None,x=None,y=None,to='default',tt='default',cmap=None):
if isinstance(to,str):
to = vcs.elements["textorientation"][to]
if isinstance(tt,str):
tt = vcs.elements["texttable"][tt]
if tt.priority==0:
return []
if string is None:
string = tt.string
if x is None:
x = tt.x
if y is None:
y = tt.y
if x is None or y is None or string in [['',],[]]:
return []
n = max(len(x),len(y),len(string))
for a in [x,y,string]:
while len(a)<n:
a.append(a[-1])
sz = renderer.GetRenderWindow().GetSize()
actors=[]
pts = vtk.vtkPoints()
geo = None
if vcs.elements["projection"][tt.projection].type!="linear":
# Need to figure out new WC
Npts = 20
for i in range(Npts+1):
X = tt.worldcoordinate[0]+float(i)/Npts*(tt.worldcoordinate[1]-tt.worldcoordinate[0])
for j in range(Npts+1):
Y = tt.worldcoordinate[2]+float(j)/Npts*(tt.worldcoordinate[3]-tt.worldcoordinate[2])
pts.InsertNextPoint(X,Y,0.)
geo,pts = project(pts,tt.projection,tt.worldcoordinate,geo=None)
wc = pts.GetBounds()[:4]
#renderer.SetViewport(tt.viewport[0],tt.viewport[2],tt.viewport[1],tt.viewport[3])
renderer.SetWorldPoint(wc)
for i in range(n):
t = vtk.vtkTextActor()
p=t.GetTextProperty()
prepTextProperty(p,sz,to,tt,cmap)
pts = vtk.vtkPoints()
pts.InsertNextPoint(x[i],y[i],0.)
if geo is not None:
geo,pts = project(pts,tt.projection,tt.worldcoordinate,geo=geo)
X,Y,tz=pts.GetPoint(0)
X,Y = world2Renderer(renderer,X,Y,tt.viewport,wc)
else:
X,Y = world2Renderer(renderer,x[i],y[i],tt.viewport,tt.worldcoordinate)
t.SetPosition(X,Y)
t.SetInput(string[i])
#T=vtk.vtkTransform()
#T.Scale(1.,sz[1]/606.,1.)
#T.RotateY(to.angle)
#t.SetUserTransform(T)
renderer.AddActor(t)
actors.append(t)
return actors
def create_text(self, settings, viewport):
"""Create text actor for view labels"""
viewport = np.array(viewport)
viewport[[0, 2]] = self.WIN_H_SCALE * viewport[[0, 2]]
viewport[[1, 3]] = self.WIN_V_SCALE * viewport[[1, 3]]
viewport = list(viewport)
# Set defaults if not specified
defaults = {
"Size": 20,
"Anchor": "SW",
"X offset": 0.02,
"Y offset": 0.02,
"Font": "Montserrat",
"Colour": self.COLOUR_FONT
}
for key in defaults:
try:
settings[key]
except KeyError:
settings[key] = defaults[key]
# Position
margin = (self.TEXT_SCALE * settings["X offset"] *
(self.ANCHOR[settings["Anchor"]][0] - 1),
self.TEXT_SCALE * settings["Y offset"] *
(self.ANCHOR[settings["Anchor"]][1] - 1))
posx = int(
(viewport[0] + 0.5 * self.ANCHOR[settings["Anchor"]][0] *
(viewport[2] - viewport[0]) - margin[0]) * self.SCREEN_SIZE[0])
posy = int(
(viewport[1] + 0.5 * self.ANCHOR[settings["Anchor"]][1] *
(viewport[3] - viewport[1]) - margin[1]) * self.SCREEN_SIZE[1])
# Properties
props = vtk.vtkTextProperty()
props.SetFontFamily(vtk.VTK_FONT_FILE)
if settings["Font"] == "Montserrat-SemiBold":
props.SetFontFile("./fonts/Montserrat-SemiBold.ttf")
elif settings["Font"] == "Consolas":
props.SetFontFile("./fonts/consola.ttf")
elif settings["Font"] is "7Segment":
props.SetFontFile("./fonts/digital-7 (mono).ttf")
else:
props.SetFontFile("./fonts/Montserrat.ttf")
props.SetFontSize(int(self.TEXT_SCALE * settings["Size"]))
props.SetColor(settings["Colour"])
props.SetJustification(self.ANCHOR[settings["Anchor"]][0])
props.SetVerticalJustification(self.ANCHOR[settings["Anchor"]][1])
# Create actor
actor = vtk.vtkTextActor()
actor.SetInput(settings["String"])
actor.SetDisplayPosition(posx, posy)
actor.SetTextProperty(props)
return actor
def __init__(self, displayAxes = True):
threading.Thread.__init__(self)
self.footText = "PyVSim ver. " + VERSION
self.windowTitle = "PyVSim Visualization window - powered by VTK"
self.windowColor = [0,0.25,0.40]
self.windowSize = [800,800]
self.actorlist = None
self.displayAxes = displayAxes
self.rend = vtk.vtkRenderer()
self.window = vtk.vtkRenderWindow()
self.interactor = vtk.vtkRenderWindowInteractor()
self.legend = vtk.vtkTextActor()
self.rend.SetBackground(self.windowColor[0],
self.windowColor[1],
self.windowColor[2])
self.window.SetSize(self.windowSize[0],self.windowSize[0])
self.window.AddRenderer(self.rend)
self.interactor.SetRenderWindow(self.window)
self.legend.GetTextProperty().SetFontSize(12)
self.legend.SetPosition2(0,0)
self.legend.SetInput(self.footText)
self.rend.AddActor(self.legend)
def drawVTKText(text,position,fontSize=18,color=[0,0,0],renderer=None): """Draws text in renderer. Args: text (str): Text. position (numpy.ndarray): Position where to draw it. Keyword Args: fontSize (int): Font Size. color (list): Color of text in normed RGB values. renderer (vtk.vtkRenderer): Renderer to draw in. Returns: vtk.vtkTextActor: Text actor """ txt = vtk.vtkTextActor() txt.SetInput(text) txtprop=txt.GetTextProperty() txtprop.SetFontFamilyToArial() txtprop.SetFontSize(fontSize) txtprop.SetColor(color[0],color[1],color[2]) txt.SetDisplayPosition(position[0],position[1]) if renderer!=None: renderer.AddActor(txt) return txt
def __init__(self, fnc, states, c, bc, pos, size, font, bold, italic,
alpha, angle):
self._status = 0
self.states = states
self.colors = c
self.bcolors = bc
self.function = fnc
self.actor = vtk.vtkTextActor()
self.actor.SetDisplayPosition(pos[0], pos[1])
self.framewidth = 3
self.offset = 5
self.spacer = ' '
self.textproperty = self.actor.GetTextProperty()
self.textproperty.SetJustificationToCentered()
if font.lower() == 'courier':
self.textproperty.SetFontFamilyToCourier()
elif font.lower() == 'times':
self.textproperty.SetFontFamilyToTimes()
else:
self.textproperty.SetFontFamilyToArial()
self.textproperty.SetFontSize(size)
self.textproperty.SetBackgroundOpacity(alpha)
self.textproperty.BoldOff()
if bold:
self.textproperty.BoldOn()
self.textproperty.ItalicOff()
if italic:
self.textproperty.ItalicOn()
self.textproperty.ShadowOff()
self.textproperty.SetOrientation(angle)
self.showframe = hasattr(self.textproperty, 'FrameOn')
self.status(0)
def AddText(self, text, position=[10, 10], fontsize=50, color=None,
font='courier', shadow=False):
"""
Adds text to plot object
Parameters
----------
font : string, optional
Font name may be courier, times, or arial
shadow : bool, optional
Adds a black shadow to the text. Defaults to False
Returns
-------
shadow : False
"""
self.textActor = vtk.vtkTextActor()
self.textActor.SetPosition(position)
self.textActor.GetTextProperty().SetFontSize(fontsize)
self.textActor.GetTextProperty().SetColor(ParseColor(color))
self.textActor.GetTextProperty().SetFontFamily(font_keys[font])
self.textActor.GetTextProperty().SetShadow(shadow)
self.textActor.SetInput(text)
self.AddActor(self.textActor)
def __init__(self, interactor, string, movable=False, on_move=None, on_drag=None, on_click=None, fgcolor=(
1, 1, 1), size=24, font="Arial", left=0, top=0, textproperty=None):
if textproperty is not None:
self.actor = vtkTextActor()
self.actor.SetInput(string)
self.actor.SetTextProperty(textproperty)
if textproperty.GetBackgroundColor() == textproperty.GetColor():
textproperty.SetBackgroundColor(
*
white_or_black(
*
textproperty.GetColor()))
else:
self.actor = text_actor(string, fgcolor, size, font)
widget = WidgetReprShim(interactor, self.actor)
super(Label, self).__init__(interactor, widget)
self.movable = movable
self.action = on_click
self.move_action = on_move
self.dragged = on_drag
self.actor.SetTextScaleModeToNone()
self.actor.SetUseBorderAlign(False)
self.actor.VisibilityOff()
self.left = left
self.top = top
self.register()
def displayLine():
global __data_model__
if sg.SelectedCount() != 1:
return
entry = sg.getSelected(0)
obj = ctx.DM.getObject(entry)
if obj is None:
QMessageBox.information(sgPyQt.getDesktop(), 'Info',
'Please, select line!')
return
text = obj.getText()
if text == "\n":
return
renderer = libSalomePy.getRenderer()
actor = getActor(entry)
if actor is None:
actor = vtk.vtkTextActor()
dict_actors[entry] = actor
pass
center = renderer.GetCenter()
actor.SetInput(str(text))
actor.SetPosition(center[0], center[1])
txtPr = vtk.vtkTextProperty()
txtPr.SetFontSize(30)
actor.SetTextProperty(txtPr)
for act in list(dict_actors.values()):
renderer.RemoveActor(act)
renderer.AddActor(actor)
pass
def __init__(self, parent, visualizer, **kws):
"""
Initialization
"""
self.x, self.y, self.z = -1, -1, -1
VisualizationModule.__init__(self, parent, visualizer, **kws)
#self.name = "Scale bar"
self.renew = 1
self.mapper = vtk.vtkDataSetMapper()
self.actor = vtk.vtkActor()
self.actor.SetMapper(self.mapper)
self.width = 10
self.widthPx = 100
self.voxelSize = (1, 1, 1)
self.renderer = self.parent.getRenderer()
self.renderer.AddActor(self.actor)
self.polyLine = vtk.vtkPolyLine()
#self.mapper.SetInput(self.polyLine.GetOutput())
self.actor.GetProperty().SetColor(1, 1, 1)
self.textActor = vtk.vtkTextActor()
#self.textActor.ScaledTextOn()
self.renderer.AddActor2D(self.textActor)
iactor = self.wxrenwin.GetRenderWindow().GetInteractor()
style = iactor.GetInteractorStyle()
# style.AddObserver("StartInteractionEvent",self.updateLine)
style.AddObserver("EndInteractionEvent", self.updateRendering)
def main():
colors = vtk.vtkNamedColors()
# Create a rendering window and renderer.
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetWindowName('TextActor')
renWin.AddRenderer(ren)
# Create a render window interactor.
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Create a text actor.
txt = vtk.vtkTextActor()
txt.SetInput('Hello World!')
txtprop = txt.GetTextProperty()
txtprop.SetFontFamilyToArial()
txtprop.BoldOn()
txtprop.SetFontSize(36)
txtprop.ShadowOn()
txtprop.SetShadowOffset(4, 4)
txtprop.SetColor(colors.GetColor3d('Cornsilk'))
txt.SetDisplayPosition(20, 30)
# Assign actor to the renderer.
ren.AddActor(txt)
ren.SetBackground(colors.GetColor3d('DarkGreen'))
# Enable user interface interactor.
iren.Initialize()
renWin.Render()
iren.Start()
def add_legend_actors(self):
# TODO: Potentially change scale to use hardcoded values (e.g., 5, 10, 50, 100, 500, 1000....) and pick 4 evenly spaced values from this list (all parts of this list smaller than the max_cases)
for i in range(4):
cases = math.pow(2, (math.log2(self.max_cases) / (i+1)))
radius = (math.log2(cases)/math.log2(self.max_cases)) * self.max_radius
legend_polygon_source = vtk.vtkRegularPolygonSource()
legend_polygon_source.SetNumberOfSides(50)
legend_polygon_source.SetRadius(radius)
legend_polygon_source.SetCenter(0, 0, 0)
circle_mapper = vtk.vtkPolyDataMapper2D()
circle_mapper.SetInputConnection(legend_polygon_source.GetOutputPort())
circle_actor = vtk.vtkActor2D()
circle_actor.SetMapper(circle_mapper)
circle_actor.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport()
circle_actor.GetPositionCoordinate().SetValue(.05, .1 + .075 * i)
text_actor = vtk.vtkTextActor()
text_actor.SetInput(str(int(cases)) + " cases")
text_actor.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport()
text_actor.GetPositionCoordinate().SetValue(.075, .1 + .075 * i)
text_actor.GetTextProperty().SetFontSize(25)
self.ren.AddActor(circle_actor)
self.legend_circle_actors.append(circle_actor)
self.ren.AddActor(text_actor)
self.legend_text_actors.append(text_actor)
def __init__(self, model):
print "Put the mouse to desired position and press \"h\" to add a ball"
print "Press \"s\" to save the scene as a picture"
self.screen_name = "ttt.png"
self.renderer = vtk.vtkRenderer()
self.renWin = vtk.vtkRenderWindow()
self.interactor = vtk.vtkRenderWindowInteractor()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(model)
self.modelActor = vtk.vtkActor()
self.modelActor.SetMapper(mapper)
ball = vtk.vtkSphereSource()
ball.SetCenter(0.0, 0.0, 0.0)
ball.SetThetaResolution(50)
ball.SetRadius(5.0)
ball.Update()
ballMapper = vtk.vtkPolyDataMapper()
ballMapper.SetInputData(ball.GetOutput())
self.ballActor = vtk.vtkActor()
self.ballActor.SetMapper(ballMapper)
self.ballActor.GetProperty().SetColor(1, 0, 0)
self.txtActor = vtk.vtkTextActor()
self.renderer.AddActor(self.txtActor)
self.renderer.AddActor(self.ballActor)
self.renderer.AddActor(self.modelActor)
self.registerCallbacks()
self.renWin.AddRenderer(self.renderer)
self.interactor.SetRenderWindow(self.renWin)
self.interactor.Start()
pass
def legendActor(text):
"""Display the given text in the lower left corner of the window.
"""
actor = vtk.vtkTextActor()
actor.GetTextProperty().SetFontSize(24)
actor.SetInput(text)
actor.GetTextProperty().SetColor(0, 0, 0)
return actor
def Execute(self):
self._SourceSeedIds.Initialize()
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
glyphs = vtk.vtkGlyph3D()
glyphSource = vtk.vtkSphereSource()
glyphs.SetInputData(self.PickedSeeds)
glyphs.SetSourceConnection(glyphSource.GetOutputPort())
glyphs.SetScaleModeToDataScalingOff()
glyphs.SetScaleFactor(self._Surface.GetLength()*0.01)
glyphMapper = vtk.vtkPolyDataMapper()
glyphMapper.SetInputConnection(glyphs.GetOutputPort())
self.SeedActor = vtk.vtkActor()
self.SeedActor.SetMapper(glyphMapper)
self.SeedActor.GetProperty().SetColor(1.0,0.0,0.0)
self.SeedActor.PickableOff()
self.vmtkRenderer.Renderer.AddActor(self.SeedActor)
self.vmtkRenderer.AddKeyBinding('u','Undo.',self.UndoCallback)
self.vmtkRenderer.AddKeyBinding('space','Add points.',self.PickCallback)
surfaceMapper = vtk.vtkPolyDataMapper()
surfaceMapper.SetInputData(self._Surface)
surfaceMapper.ScalarVisibilityOff()
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(surfaceMapper)
surfaceActor.GetProperty().SetOpacity(1)
self.vmtkRenderer.Renderer.AddActor(surfaceActor)
# create a text actor
txt = vtk.vtkTextActor()
info = "Position mouse and press space. "
info += "Select seeds in this order: RSpv, RIpv, LIpv, LSpv. "
info += "Fifth seed requires --use_laa_seed command."
txt.SetInput(info)
txtprop=txt.GetTextProperty()
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(13)
txtprop.SetColor(1, 1, 1)
txt.SetDisplayPosition(0, 10)
self.vmtkRenderer.Renderer.AddActor(txt)
any = 0
while any == 0:
self.InitializeSeeds()
self.vmtkRenderer.Render()
any = self.PickedSeedIds.GetNumberOfIds()
self._SourceSeedIds.DeepCopy(self.PickedSeedIds)
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
def createTextActor(self): self.textActor = vtk.vtkTextActor() self.textActor.SetInput(self.text) self.textProperty.SetFontSize(self.fontSize) self.textProperty.SetColor(self.textColor) self.textProperty.SetBold(self.textBold) self.textProperty.SetShadow(self.textShadow) self.textProperty.SetOpacity(self.textOpacity) self.textActor.SetTextProperty(self.textProperty) self.show()
def get_vtk_text(self):
txt = vtk.vtkTextActor()
txt.SetInput(self.text)
txtprop=txt.GetTextProperty()
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(18)
txtprop.SetColor(1,1,1)
txt.SetDisplayPosition(*self.pos)
return txt
def visualise_color(surface,ref,case):
"""Visualise surface in solid color and 'ref' in trasparent."""
# create a text actor
txt = vtk.vtkTextActor()
txt.SetInput(case)
txtprop=txt.GetTextProperty()
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(18)
txtprop.SetColor(0, 0, 0)
txt.SetDisplayPosition(20, 30)
# create a rendering window, renderer, and renderwindowinteractor
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
iren.SetRenderWindow(renWin)
# surface mapper and actor
surfacemapper = vtk.vtkPolyDataMapper()
surfacemapper.SetInputData(surface)
surfacemapper.SetScalarModeToUsePointFieldData()
surfaceactor = vtk.vtkActor()
surfaceactor.GetProperty().SetColor(288/255, 26/255, 28/255)
surfaceactor.SetMapper(surfacemapper)
# refsurface mapper and actor
refmapper = vtk.vtkPolyDataMapper()
refmapper.SetInputData(ref)
refmapper.SetScalarModeToUsePointFieldData()
refactor = vtk.vtkActor()
refactor.GetProperty().SetOpacity(0.5)
refactor.GetProperty().SetColor(1, 1, 1)
refactor.SetMapper(refmapper)
# assign actors to the renderer
ren.AddActor(surfaceactor)
ren.AddActor(refactor)
ren.AddActor(txt)
# set the background and size; zoom in; and render
ren.SetBackground(1, 1, 1)
renWin.SetSize(800 , 800)
ren.ResetCamera()
ren.GetActiveCamera().Zoom(1)
# enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
def _getTextActor(self, color, position, opacity=1, text='Hello World!'):
txt = vtk.vtkTextActor()
txt.SetInput(text)
txtprop = txt.GetTextProperty()
txtprop.SetFontSize(16)
txtprop.SetBold(True)
txtprop.SetFontSize(16)
txtprop.SetColor(color)
txtprop.SetOpacity(opacity)
txt.SetDisplayPosition(position[0], position[1])
# assign actor to the renderer
self.window.ren.AddActor(txt)
return txt
def __init__ (self, mod_m):
debug ("In Text::__init__ ()")
Common.state.busy ()
Base.Objects.Module.__init__ (self, mod_m)
data_src = self.mod_m.get_data_source ()
self.actor = self.act = vtk.vtkTextActor()
self.tprop = self.act.GetTextProperty()
self._initialize()
self.renwin.add_actors (self.act)
# used for the pipeline browser
self.pipe_objs = self.act
self.renwin.Render ()
Common.state.idle ()
def setup_text_actor(x, y):
ta = vtk.vtkTextActor()
c = ta.GetPositionCoordinate()
c.SetCoordinateSystemToNormalizedDisplay()
c.SetValue(x,y)
p = ta.GetTextProperty()
p.SetFontFamilyToArial()
p.SetFontSize(14)
p.SetBold(0)
p.SetItalic(0)
p.SetShadow(0)
return ta
def make_textActor ():
textActor = vtk.vtkTextActor()
#textActor.SetInput (text)
textActor.ScaledTextOn()
textActor.SetDisplayPosition(5, 5)
# Set coordinates to match the old vtk.vtkScaledTextActor default value
textActor.GetPosition2Coordinate().SetCoordinateSystemToNormalizedViewport()
textActor.GetPosition2Coordinate().SetValue(0.6, 0.1)
tprop = textActor.GetTextProperty()
tprop.SetFontSize(18)
tprop.SetFontFamilyToArial()
tprop.SetJustificationToCentered()
tprop.BoldOn()
tprop.ItalicOn()
tprop.ShadowOn()
#tprop.SetColor(0, 0, 1)
return (textActor)
def ShowLabel(self):
self.tprop = vtk.vtkTextProperty()
size = self.GetSize()
self.text_label = vtk.vtkTextActor()
# self.text_label.ScaledTextOn()
self.text_label.SetPosition(10, size[1] - 12)
self.text_label.SetInput(self.label_t)
self.tprop.SetFontSize(12)
self.tprop.SetFontFamilyToArial()
self.tprop.SetJustificationToLeft()
# self.tprop.BoldOn()
# self.tprop.ItalicOn()
self.tprop.ShadowOn()
self.tprop.SetColor(0.9, 0.8, 0.8)
self.text_label.SetTextProperty(self.tprop)
self.AddActor2D(self.text_label)
def __init__(self):
property = vtk.vtkTextProperty()
property.SetFontSize(const.TEXT_SIZE_LARGE)
property.SetFontFamilyToArial()
property.BoldOn()
property.ItalicOff()
#property.ShadowOn()
property.SetJustificationToLeft()
property.SetVerticalJustificationToTop()
property.SetColor(const.TEXT_COLOUR)
self.property = property
actor = vtk.vtkTextActor()
actor.GetTextProperty().ShallowCopy(property)
actor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay()
actor.PickableOff()
self.actor = actor
def __init__(self, font_size=14, color=(0.0, 0.0, 0.0), relative_position=(0, 1), absolute_offset=(10, -10), text="", **kwargs):
kwargs["text"] = text
kwargs['color'] = color
kwargs["absolute_offset"] = absolute_offset
kwargs["relative_position"] = relative_position
kwargs["font_size"] = font_size
self.actor = vtk.vtkTextActor()
self.text_property = self.actor.GetTextProperty()
self.text_property.SetFontFamilyToCourier()
self.text_property.SetVerticalJustificationToTop()
self.relpos_coord = vtk.vtkCoordinate()
self.relpos_coord.SetCoordinateSystemToNormalizedViewport()
self.actor.GetPositionCoordinate().SetCoordinateSystemToViewport()
self.actor.GetPositionCoordinate().SetReferenceCoordinate(self.relpos_coord)
self._process_kwargs(**kwargs)
def createTextActor( self, aid, **args ):
textActor = vtk.vtkTextActor()
textActor.SetTextScaleMode( vtk.vtkTextActor.TEXT_SCALE_MODE_PROP )
textActor.SetMaximumLineHeight( 0.05 )
textprop = textActor.GetTextProperty()
textprop.SetColor( *args.get( 'color', ( VTK_FOREGROUND_COLOR[0], VTK_FOREGROUND_COLOR[1], VTK_FOREGROUND_COLOR[2] ) ) )
textprop.SetOpacity ( args.get( 'opacity', 1.0 ) )
textprop.SetFontSize( 8 )
if args.get( 'bold', False ): textprop.BoldOn()
else: textprop.BoldOff()
textprop.ItalicOff()
textprop.ShadowOff()
textprop.SetJustificationToLeft()
textprop.SetVerticalJustificationToBottom()
textActor.GetPositionCoordinate().SetCoordinateSystemToDisplay()
textActor.GetPosition2Coordinate().SetCoordinateSystemToDisplay()
textActor.VisibilityOff()
textActor.id = aid
return textActor
def __init__(self):
self._rendererScene = vtk.vtkRenderer()
self._rendererScene.SetBackground(self.COLOR_BG)
self._renderWindowScene = vtk.vtkRenderWindow()
self._renderWindowScene.AddRenderer(self._rendererScene)
self._renderWindowInteractor = vtk.vtkRenderWindowInteractor()
self._renderWindowInteractor.SetRenderWindow(self._renderWindowScene)
#self._interactorStyle = vtk.vtkInteractorStyleUnicam()
self._interactorStyle = self.KeyPressInteractorStyle()
self._interactorStyle.SetCamera(self._rendererScene.GetActiveCamera())
self._interactorStyle.SetRenderer(self._rendererScene)
self._interactorStyle.SetRenderWindow(self._renderWindowScene)
self._contextViewPlotCurv = vtk.vtkContextView()
self._contextViewPlotCurv.GetRenderer().SetBackground(self.COLOR_BG_PLOT)
self._contextInteractorStyleCurv = self.KeyPressContextInteractorStyle()
self._contextInteractorStyleCurv.SetRenderWindow(self._contextViewPlotCurv.GetRenderWindow())
self._chartXYCurv = vtk.vtkChartXY()
self._contextViewPlotCurv.GetScene().AddItem(self._chartXYCurv)
self._chartXYCurv.SetShowLegend(True)
self._chartXYCurv.GetAxis(vtk.vtkAxis.LEFT).SetTitle("")
self._chartXYCurv.GetAxis(vtk.vtkAxis.BOTTOM).SetTitle("")
self._contextViewPlotTors = vtk.vtkContextView()
self._contextViewPlotTors.GetRenderer().SetBackground(self.COLOR_BG_PLOT)
self._contextInteractorStyleTors = self.KeyPressContextInteractorStyle()
self._contextInteractorStyleTors.SetRenderWindow(self._contextViewPlotTors.GetRenderWindow())
self._chartXYTors = vtk.vtkChartXY()
self._contextViewPlotTors.GetScene().AddItem(self._chartXYTors)
self._chartXYTors.SetShowLegend(True)
self._chartXYTors.GetAxis(vtk.vtkAxis.LEFT).SetTitle("")
self._chartXYTors.GetAxis(vtk.vtkAxis.BOTTOM).SetTitle("")
self._textActor = vtk.vtkTextActor()
self._textActor.GetTextProperty().SetColor(self.COLOR_LENGTH)
self._addedBSpline = False
def __init__(self, interactor, string, movable=False, on_move=None, on_drag=None, on_click=None, on_release=None, fgcolor=(1,1,1), size=24, font="Arial", left=0, top=0, textproperty=None):
widget = vtkTextWidget()
if textproperty is not None:
self.actor = vtkTextActor()
self.actor.SetInput(string)
self.actor.SetTextProperty(textproperty)
if textproperty.GetBackgroundColor() == textproperty.GetColor():
textproperty.SetBackgroundColor(*white_or_black(*textproperty.GetColor()))
else:
self.actor = text_actor(string, fgcolor, size, font)
widget.SetTextActor(self.actor)
super(Label, self).__init__(interactor, widget)
#self.widget.ResizableOff()
self.movable = movable
self.action = on_click
self.release_action = on_release
self.move_action = on_move
self.dragged = on_drag
self.left, self.top = left, top
self.top_offset = 0
# Assigned by Widget.__init__
self.repr.MovingOff()
self.repr.PickableOff()
self.repr.SetShowBorderToOff()
self.actor.SetTextScaleModeToNone()
# Map events to draggable actions, because standard events aren't propagated
self.add_event_handler("StartInteractionEvent", self.drag_clicked)
self.add_event_handler("InteractionEvent", self.drag_moved)
self.add_event_handler("EndInteractionEvent", self.drag_released)
self.add_event_handler("StartInteractionEvent", self.click)
self.add_event_handler("EndInteractionEvent", self.release)
self.register()
def createTextActor( self, aid, **args ):
textActor = vtk.vtkTextActor()
# textActor.SetTextScaleModeToViewport()
# textActor.SetTextScaleMode( vtk.vtkTextActor.TEXT_SCALE_MODE_PROP )
# textActor.SetMaximumLineHeight( 0.005 )
# print dir( textActor )
# textActor.ScaledTextOn()
textActor.SetTextScaleModeToProp()
textprop = textActor.GetTextProperty()
textprop.SetColor( *args.get( 'color', ( VTK_FOREGROUND_COLOR[0], VTK_FOREGROUND_COLOR[1], VTK_FOREGROUND_COLOR[2] ) ) )
textprop.SetOpacity ( args.get( 'opacity', 1.0 ) )
textprop.SetFontSize( 8 )
if args.get( 'bold', False ): textprop.BoldOn()
else: textprop.BoldOff()
textprop.ItalicOff()
textprop.ShadowOff()
textprop.SetJustificationToLeft()
textprop.SetVerticalJustificationToBottom()
textActor.VisibilityOff()
textActor.id = aid
return textActor
def __init__(self, clusterviz_config):
"""
Initialises with a first message, configuration or default values
and create the first vtk actor.
"""
# first log entry
self.time = [time.strftime("%H:%M:%S")]
self.log = ["Initialisation"]
self.last_seen = [time.time()]
# read config file section
self.config_parser = clusterviz_config.get_config_parser()
if self.config_parser.has_section("log"):
if self.config_parser.has_option("log", "log_pos_h"):
self.log_pos_h = self.config_parser.getfloat("log", "log_pos_h")
else:
self.log_pos_h = 0.99
if self.config_parser.has_option("log", "log_pos_v"):
self.log_pos_v = self.config_parser.getfloat("log", "log_pos_v")
else:
self.log_pos_v = 0.01
if self.config_parser.has_option("log", "max_log_lines"):
self.max_log_lines = self.config_parser.getint("log", "max_log_lines")
else:
self.max_log_lines = 12
else:
self.log_pos_h = 0.99
self.log_pos_v = 0.01
self.max_log_lines = 12
# initialise the vtk actor
txt = self.get_log_txt()
self.log_actor = vtkTextActor()
self.log_actor.SetInput(txt)
text_prop = self.log_actor.GetTextProperty()
# this seems to be documented nowhere: 2 means right-aligned
text_prop.SetJustification(2)
log_position = self.log_actor.GetPositionCoordinate()
log_position.SetCoordinateSystemToNormalizedDisplay()
log_position.SetValue(self.log_pos_h, self.log_pos_v)
