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 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 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 __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 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 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 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 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)