def render(points, dirpath, vertice_number): colors = vtk.vtkNamedColors() points_actor = create_points_actor(points) # Create a renderer, render window, and interactor renWin = vtk.vtkRenderWindow() renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renWin) surface_actor = create_surface_actor(points) style = KeyPressInteractorStyle(points, dirpath, renderWindowInteractor, vertice_number, points_actor, surface_actor) renderWindowInteractor.SetInteractorStyle(style) textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(16) textProperty.SetColor(0.3, 0.3, 0.3) # Add the actor to the scene # Create textActors points_textMapper = vtk.vtkTextMapper() points_textMapper.SetTextProperty(textProperty) points_textMapper.SetInput("Points\nKeyPress F5 to Update") points_textActor = vtk.vtkActor2D() points_textActor.SetMapper(points_textMapper) points_textActor.SetPosition(20, 20) points_renderer = vtk.vtkRenderer() points_renderer.AddActor(points_actor) points_renderer.AddActor(points_textActor) points_renderer.SetViewport(0, 0, 1.0 / 2.0, 1) points_renderer.SetBackground(colors.GetColor3d("Green")) viewportBorder(points_renderer, False) surface_textMapper = vtk.vtkTextMapper() surface_textMapper.SetTextProperty(textProperty) surface_textMapper.SetInput("Reconstruction suface") surface_textActor = vtk.vtkActor2D() surface_textActor.SetMapper(surface_textMapper) surface_textActor.SetPosition(20, 20) surface_renderer = vtk.vtkRenderer() surface_renderer.AddActor(surface_actor) surface_renderer.AddActor(surface_textActor) surface_renderer.SetViewport(1.0 / 2.0, 0, 1, 1) surface_renderer.SetBackground(colors.GetColor3d("Green")) viewportBorder(surface_renderer, True) renWin.AddRenderer(points_renderer) renWin.SetSize(800, 600) renWin.AddRenderer(surface_renderer) # Render and interact renWin.Render() renderWindowInteractor.Initialize() renderWindowInteractor.CreateRepeatingTimer(5000) renderWindowInteractor.Start()
def new(renderWindowInteractor): a = vtk.QVTKWidget() reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName("D:\Anaconda\workspace\pytest\patient") # reader.SetDirectoryName("G:\Win64\Anaconda3.4\workplace\\vtk\dicom") reader.Update() imageViewer = vtk.vtkImageViewer2() imageViewer.SetInputConnection(reader.GetOutputPort()) sliceTextProp = vtk.vtkTextProperty() sliceTextProp.SetFontFamilyToCourier() sliceTextProp.SetFontSize(20) sliceTextProp.SetVerticalJustificationToBottom() sliceTextProp.SetJustificationToLeft() sliceTextMapper = vtk.vtkTextMapper() msg = str(imageViewer.GetSliceMin()) + '/' + str(imageViewer.GetSliceMax()) sliceTextMapper.SetInput(msg) sliceTextMapper.SetTextProperty(sliceTextProp) sliceTextActor = vtk.vtkActor2D() sliceTextActor.SetMapper(sliceTextMapper) sliceTextActor.SetPosition(15, 10) usageTextProp = vtk.vtkTextProperty() usageTextProp.SetFontFamilyToCourier() usageTextProp.SetFontSize(14) usageTextProp.SetVerticalJustificationToTop() usageTextProp.SetJustificationToLeft() usageTextMapper = vtk.vtkTextMapper() usageTextMapper.SetInput( "- Slice with mouse wheel\n or Up/Down-Key\n- Zoom with pressed right\n mouse button while dragging" ) usageTextMapper.SetTextProperty(usageTextProp) usageTextActor = vtk.vtkActor2D() usageTextActor.SetMapper(usageTextMapper) usageTextActor.GetPositionCoordinate( ).SetCoordinateSystemToNormalizedDisplay() usageTextActor.GetPositionCoordinate().SetValue(0.05, 0.95) # renderWindowInteractor =vtk.vtkRenderWindowInteractor() # myInteractorStyle = vtk. myVtkInteractorStyleImage() # # myInteractorStyle.SetImageViewer(imageViewer) # myInteractorStyle.SetStatusMapper(sliceTextMapper) imageViewer.SetupInteractor(renderWindowInteractor) imageViewer.SetSlice(12) # style= vtk.vtkInteractorStyleUser(imageViewer=imageViewer) # renderWindowInteractor.SetInteractorStyle(style) imageViewer.GetRenderer().AddActor2D(sliceTextActor) imageViewer.GetRenderer().AddActor2D(usageTextActor) imageViewer.Render() imageViewer.GetRenderer().ResetCamera() imageViewer.Render()
def __init__(self): self.layer = 99 self.children = [] property = vtk.vtkTextProperty() property.SetFontSize(const.TEXT_SIZE) property.SetFontFamilyToArial() property.BoldOff() property.ItalicOff() property.ShadowOn() property.SetJustificationToLeft() property.SetVerticalJustificationToTop() property.SetColor(const.TEXT_COLOUR) self.property = property mapper = vtk.vtkTextMapper() mapper.SetTextProperty(property) self.mapper = mapper actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay() actor.PickableOff() self.actor = actor self.SetPosition(const.TEXT_POS_LEFT_UP)
def InitiateScreenText(self): ''' self.tpropScren = vtk.vtkTextProperty() size = self.GetSize() self.text_screen = vtk.vtkTextActor() self.text_screen.SetPosition(10, 10) self.text_screen.SetInput(' ') self.tpropScren.SetFontSize(10) self.tpropScren.SetFontFamilyToArial() self.tpropScren.SetJustificationToLeft() #self.tprop.BoldOn() #self.tprop.ItalicOn() #self.tpropScren.ShadowOn() self.tpropScren.SetColor(0.9, 0.8, 0.8) self.text_screen.SetTextProperty(self.tpropScren) ''' #self.scree_text_offset = 10 self.textMapper = vtk.vtkTextMapper() tprop = self.textMapper.GetTextProperty() tprop.SetFontFamilyToArial() tprop.SetFontSize(10) #tprop.BoldOn() #tprop.ShadowOn() tprop.SetColor(0.5, 0.9, 0.5) self.textActor = vtk.vtkActor2D() self.textActor.VisibilityOff() self.textActor.SetMapper(self.textMapper) self.AddActor2D(self.textActor)
def init_label(self): """ Initialises the label for a box """ # make a label for the box node_label = vtkTextMapper() node_label.SetInput(self.get_name()) # use the relevant text properties node_label_prop = node_label.GetTextProperty() #node_label_prop.ShallowCopy(node_label_prop) node_label_prop.SetJustificationToCentered() node_label_prop.SetVerticalJustificationToTop() node_label_prop.SetFontSize(8) node_label_prop.BoldOn() node_label_prop.SetFontFamilyToCourier() node_label_prop.SetOpacity(1.0) # make the actor for the label self.label_actor.SetScale(0.02, 0.02, 0.02) self.label_actor.SetTextProperty(node_label_prop) self.label_actor.SetOrientation(30, 0, 0) self.update_label() return self.label_actor
def set_open_text_on_off(self): if not self.islabelon: tm = vtk.vtkTextMapper() tp = tm.GetTextProperty() tp.SetFontFamilyToArial() tp.SetFontSize(20) tp.BoldOff() tp.ShadowOff() tp.SetColor(1, 1, 1) tp.SetOpacity(0.8) self.label = vtk.vtkActor2D() self.label.VisibilityOn() self.label.SetMapper(tm) v = [200, 100] self.label.SetPosition(v) tm.SetInput( "VEDA - Visual Environment for Docking Algorithms - Version (%s)\n \nDevelopped by Gael Goret and Jorge Navaza" % self.version) self.renderer.AddActor2D(self.label) self.renwin.Render() self.islabelon = 1 else: self.label.VisibilityOff() self.renderer.RemoveActor2D(self.label) self.renwin.Render() self.islabelon = 0
def addText(self, text, x=0.03, y=0.97, size=12, orientation="left"): property = vtk.vtkTextProperty() property.SetFontSize(size) property.SetFontFamilyToArial() property.BoldOff() property.ItalicOff() # property.ShadowOn() if orientation == "left": property.SetJustificationToLeft() elif orientation == "right": property.SetJustificationToRight() elif orientation == "center": property.SetJustificationToCenter() property.SetVerticalJustificationToTop() property.SetColor(1, 1, 1) mapper = vtk.vtkTextMapper() mapper.SetTextProperty(property) mapper.SetInput(str(text)) textActor = vtk.vtkActor2D() self.textActors.append(textActor) textActor.SetMapper(mapper) textActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay() textActor.GetPositionCoordinate().SetValue(x, y) textActor.VisibilityOn() self.render.AddActor(textActor) self.Render()
def __init__(self, parent=None): QtWidgets.QMainWindow.__init__(self, parent) self.dicom_image_path = './IM-0008-0034.dcm' # '----------set up dicom reader---------------' self.dcmReader = vtk.vtkDICOMImageReader() self.dcmReader.SetDataByteOrderToLittleEndian() self.dcmReader.SetDirectoryName( r"D:\Users\user\Desktop\NTUCT\1323\Ct_Without_ContrastBrain - 1323\InnerEar_C_06_U70u_4" ) self.dcmRescaleSlope = self.dcmReader.GetRescaleSlope() self.dcmRescaleOffset = self.dcmReader.GetRescaleOffset() self.dcmReader.Update() # '----------viewer---------' self.dcmViewer = vtk.vtkImageViewer2() self.dcmViewer.SetInputConnection(self.dcmReader.GetOutputPort()) # '------deal with WW & WL-----' self.ww = 3500 # WW self.wl = 600 # WL self.dcmViewer.SetColorLevel(self.wl) self.dcmViewer.SetColorWindow(self.ww) # '----------TextOverLay---------' # slice status message self.sliceTextProp = vtk.vtkTextProperty() self.sliceTextProp.SetFontFamilyToCourier() self.sliceTextProp.SetFontSize(20) self.sliceTextProp.SetVerticalJustificationToBottom() self.sliceTextProp.SetJustificationToLeft() # '---------set up Text Overlay mapper----------' self.sliceTextMapper = vtk.vtkTextMapper() cur_slice = self.dcmViewer.GetSlice() print('cur_slice = ', cur_slice, ' viewer.GetSliceMax() = ', self.dcmViewer.GetSliceMax()) msg = ( ' %d / %d ' % (self.dcmViewer.GetSlice() + 1, self.dcmViewer.GetSliceMax() + 1)) # '---------set up Text Overlay Actor----------' self.sliceTextMapper.SetInput(msg) sliceTextActor = vtk.vtkActor2D() sliceTextActor.SetMapper(self.sliceTextMapper) sliceTextActor.SetPosition(15, 10) self.window_interactor = vtk.vtkRenderWindowInteractor() self.dcmViewer.SetupInteractor(self.window_interactor) self.dcmViewer.GetRenderer().AddActor2D(sliceTextActor) '----------add keyboard observer---------' self.window_interactor.AddObserver(vtk.vtkCommand.KeyPressEvent, self.keyboard_callback_func) self.window_interactor.Initialize() self.dcmViewer.Render() self.dcmViewer.GetRenderer().ResetCamera() self.dcmViewer.Render() self.window_interactor.Start()
def DisplayHelp(self): help_actor = self._viewer.helpActor slice_actor = self._viewer.sliceActor if help_actor.GetVisibility(): help_actor.VisibilityOff() slice_actor.VisibilityOn() self.ShowActor(1) self.Render() return font_size = 24 # Create the text mappers and the associated Actor2Ds. # The font and text properties (except justification) are the same for # each multi line mapper. Let's create a common text property object multiLineTextProp = vtk.vtkTextProperty() multiLineTextProp.SetFontSize(font_size) multiLineTextProp.SetFontFamilyToArial() multiLineTextProp.BoldOn() multiLineTextProp.ItalicOn() multiLineTextProp.ShadowOn() multiLineTextProp.SetLineSpacing(1.3) # The text is on multiple lines and center-justified (both horizontal and # vertical). textMapperC = vtk.vtkTextMapper() textMapperC.SetInput( "Mouse Interactions:\n" "\n" " - Slice: Mouse Scroll\n" " - Zoom: Right Mouse + Move Up/Down\n" " - Pan: Middle Mouse Button + Move or Shift + Left Mouse + Move\n" " - Adjust Camera: Left Mouse + Move\n" " - Rotate: Ctrl + Left Mouse + Move\n" "\n" "Keyboard Interactions:\n" "\n" " - YZ Plane: x\n" " - XZ Plane: y\n" " - XY Plane: z\n" " - Save render to current_render.png: r\n" " - Toggle visibility of volume render: v\n" " - Toggle visibility of slice: s\n" " - Whole image Auto Window/Level: a\n") tprop = textMapperC.GetTextProperty() tprop.ShallowCopy(multiLineTextProp) tprop.SetJustificationToLeft() tprop.SetVerticalJustificationToCentered() tprop.SetColor(0, 1, 0) help_actor.SetMapper(textMapperC) help_actor.VisibilityOn() slice_actor.VisibilityOff() self.HideActor(1) self.Render()
def __init__(self, id): # Create text mapper and 2d actor to display finger position. self.textMapper = vtk.vtkTextMapper() self.textMapper.SetInput(id) self.tprop = self.textMapper.GetTextProperty() self.tprop.SetFontFamilyToArial() self.tprop.SetFontSize(30) self.tprop.BoldOn() self.tprop.ShadowOn() self.tprop.SetColor(1, 0, 0) self.textActor = vtk.vtkActor2D() self.textActor.VisibilityOff() self.textActor.SetMapper(self.textMapper)
def addPicker(self): self.textMapper = vtk.vtkTextMapper() tprop = self.textMapper.GetTextProperty() tprop.SetFontFamilyToArial() tprop.SetFontSize(10) tprop.BoldOn() tprop.ShadowOn() tprop.SetColor(1, 0, 0) self.textActor.VisibilityOff() self.textActor.SetMapper(self.textMapper) self.picker = vtk.vtkCellPicker() def annotatePick(object, event): print("pick") if self.picker.GetCellId() < 0: self.textActor.VisibilityOff() else: selPt = self.picker.GetSelectionPoint() pickPos = self.picker.GetPickPosition() pickPosInt = (round(pickPos[0]), round(pickPos[1]),round(pickPos[2])) pickPosIntStr = str(pickPosInt) pickPosIntQStr = Qt.QString(pickPosIntStr) i = self.materialControl.currentIndex() j = self.controlTypeTab[i].currentIndex() if j == 0: if self.firstPlanePt[i].isChecked(): self.firstPlanePtValueRecord[i] = pickPos self.firstPlanePtValue[i].setText(pickPosIntQStr) if self.secondPlanePt[i].isChecked(): self.secondPlanePtValueRecord[i] = pickPos self.secondPlanePtValue[i].setText(pickPosIntQStr) if self.thirdPlanePt[i].isChecked(): self.thirdPlanePtValueRecord[i] = pickPos self.thirdPlanePtValue[i].setText(pickPosIntQStr) else: if self.controlPt[i].isChecked(): self.controlPtValueRecord[i] = pickPos self.controlPtValue[i].setText(pickPosIntQStr) pickValue = self.data_matrix_red[round(pickPos[2]),round(pickPos[1]),round(pickPos[0])] self.textMapper.SetInput("(%.3i, %.3i, %.3i)"%pickPosInt) print pickValue self.textActor.SetPosition(selPt[:2]) self.textActor.VisibilityOn() # Now at the end of the pick event call the above function. self.picker.AddObserver("EndPickEvent", annotatePick) self.iren.SetPicker(self.picker) # Add the actors to the renderer, set the background and size self.ren.AddActor2D(self.textActor)
def display_info(self, info): self.infotxt_mapper = vtk.vtkTextMapper() tprops = self.infotxt_mapper.GetTextProperty() tprops.SetFontSize(14) tprops.SetFontFamilyToTimes() tprops.SetColor(0, 0, 1) tprops.BoldOn() tprops.SetVerticalJustificationToTop() self.infotxt = "INFO : {}".format(info) self.infotxt_actor = vtk.vtkActor2D() self.infotxt_actor.VisibilityOn() self.infotxt_actor.SetMapper(self.infotxt_mapper) self.ren.AddActor(self.infotxt_actor) self.infotxt_mapper.SetInput(self.infotxt) winsize = self.ren_win.GetSize() self.infotxt_actor.SetPosition(10, winsize[1] - 10) self.infotxt_actor.VisibilityOn()
def display_info(self, info): self.infotxt_mapper = vtk.vtkTextMapper() tprops = self.infotxt_mapper.GetTextProperty() tprops.SetFontSize(14) tprops.SetFontFamilyToTimes() tprops.SetColor(0, 0, 1) tprops.BoldOn() tprops.SetVerticalJustificationToTop() self.infotxt = "INFO : {}".format(info) self.infotxt_actor = vtk.vtkActor2D() self.infotxt_actor.VisibilityOn() self.infotxt_actor.SetMapper(self.infotxt_mapper) self.ren.AddActor(self.infotxt_actor) self.infotxt_mapper.SetInput(self.infotxt) winsize = self.ren_win.GetSize() self.infotxt_actor.SetPosition(10, winsize[1]-10) self.infotxt_actor.VisibilityOn()
def display_warning(self, warning): self.warningtxt_mapper = vtk.vtkTextMapper() tprops = self.warningtxt_mapper.GetTextProperty() tprops.SetFontSize(14) tprops.SetFontFamilyToTimes() tprops.SetColor(1, 0, 0) tprops.BoldOn() tprops.SetJustificationToRight() self.warningtxt = "WARNING : {}".format(warning) self.warningtxt_actor = vtk.vtkActor2D() self.warningtxt_actor.VisibilityOn() self.warningtxt_actor.SetMapper(self.warningtxt_mapper) self.ren.AddActor(self.warningtxt_actor) self.warningtxt_mapper.SetInput(self.warningtxt) winsize = self.ren_win.GetSize() self.warningtxt_actor.SetPosition(winsize[0]-10, 10) self.warningtxt_actor.VisibilityOn()
def display_warning(self, warning): self.warningtxt_mapper = vtk.vtkTextMapper() tprops = self.warningtxt_mapper.GetTextProperty() tprops.SetFontSize(14) tprops.SetFontFamilyToTimes() tprops.SetColor(1, 0, 0) tprops.BoldOn() tprops.SetJustificationToRight() self.warningtxt = "WARNING : {}".format(warning) self.warningtxt_actor = vtk.vtkActor2D() self.warningtxt_actor.VisibilityOn() self.warningtxt_actor.SetMapper(self.warningtxt_mapper) self.ren.AddActor(self.warningtxt_actor) self.warningtxt_mapper.SetInput(self.warningtxt) winsize = self.ren_win.GetSize() self.warningtxt_actor.SetPosition(winsize[0] - 10, 10) self.warningtxt_actor.VisibilityOn()
def display_progression(self): self.tm = vtk.vtkTextMapper() tp = self.tm.GetTextProperty() #tp.SetFontFamilyToArial() tp.SetFontSize(25) #tp.BoldOff() tp.ShadowOff() tp.SetColor(1, 1, 1) tp.SetOpacity(1) label = vtk.vtkActor2D() label.VisibilityOn() label.SetMapper(self.tm) v = [20, 20] label.SetPosition(v) self.tm.SetInput("Loading, please wait ... ") self.renderer.AddActor2D(label) self.renwin.Render()
def display_pick(self, images, image_pos_pat, image_ori_pat, postS, LesionZslice): #subtract volumes based on indicated postS # define image based on subtraction of postS -preS image = self.subImage(images, postS) # Proceed to build reference frame for display objects based on DICOM coords [transformed_image, transform_cube] = self.dicomTransform(image, image_pos_pat, image_ori_pat) # Calculate the center of the volume transformed_image.UpdateInformation() # Set up ortogonal planes self.xImagePlaneWidget.SetInput( transformed_image ) self.yImagePlaneWidget.SetInput( transformed_image ) self.zImagePlaneWidget.SetInput( transformed_image ) self.zImagePlaneWidget.SetSliceIndex( LesionZslice ) self.xImagePlaneWidget.On() self.yImagePlaneWidget.On() self.zImagePlaneWidget.On() ############ self.textMapper = vtk.vtkTextMapper() tprop = self.textMapper.GetTextProperty() tprop.SetFontFamilyToArial() tprop.SetFontSize(10) tprop.BoldOn() tprop.ShadowOn() tprop.SetColor(1, 0, 0) # initialize self.seeds = vtk.vtkPoints() self.textActor = vtk.vtkActor2D() self.textActor.VisibilityOff() self.textActor.SetMapper(self.textMapper) # Initizalize self.iren1.SetPicker(self.picker) self.picker.AddObserver("EndPickEvent", self.annotatePick) self.renWin1.Render() self.renderer1.Render() self.iren1.Start() return self.seeds
def display_pick(self, images, image_pos_pat, image_ori_pat, postS, LesionZslice): '''Display a z-slice and use picker to pick coordinates with a mouse right-click''' #subtract volumes based on indicated postS # define image based on subtraction of postS -preS image = self.subImage(images, postS) # Proceed to build reference frame for display objects based on DICOM coords [transformed_image, transform_cube] = self.dicomTransform(image, image_pos_pat, image_ori_pat) # Calculate the center of the volume transformed_image.UpdateInformation() # Set up ortogonal planes self.xImagePlaneWidget.SetInput( transformed_image ) self.yImagePlaneWidget.SetInput( transformed_image ) self.zImagePlaneWidget.SetInput( transformed_image ) self.zImagePlaneWidget.SetSliceIndex( LesionZslice ) self.xImagePlaneWidget.On() self.yImagePlaneWidget.On() self.zImagePlaneWidget.On() ############ self.textMapper = vtk.vtkTextMapper() tprop = self.textMapper.GetTextProperty() tprop.SetFontFamilyToArial() tprop.SetFontSize(10) tprop.BoldOn() tprop.ShadowOn() tprop.SetColor(1, 0, 0) # initialize self.seeds = vtk.vtkPoints() self.textActor = vtk.vtkActor2D() self.textActor.VisibilityOff() self.textActor.SetMapper(self.textMapper) # Initizalize self.iren1.SetPicker(self.picker) self.picker.AddObserver("EndPickEvent", self.annotatePick) self.renWin1.Render() self.renderer1.Render() self.iren1.Start() return self.seeds
def generate_info_actor(message,ren): ''' Returns an information actor comprised of the incoming message string positioned correctly according to the incoming renderer ''' textmapper = vtk.vtkTextMapper() textmapper.SetInput(message) textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(16) textProperty.SetJustificationToCentered() textProperty.SetColor(vtk.vtkNamedColors().GetColor3d('tomato')) textmapper.SetTextProperty(textProperty) info_actor = vtk.vtkActor2D() info_actor.SetMapper(textmapper) #get size of renderwindow size = ren.GetSize() #(width,height) info_actor.SetPosition(int(0.5*size[0]), int(0.001*size[1])) return info_actor
def setTitle(self): """Put a text at the top of the figure.""" tprop = self.textProperty(fontsize = self.opt.title_fontsize) tprop.SetVerticalJustificationToTop() tprop.SetJustificationToCentered() mapper = vtk.vtkTextMapper() mapper.SetInput(self.opt.title) mapper.SetTextProperty(tprop) actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay() if self.opt.title_coord: actor.GetPositionCoordinate().SetValue(self.opt.title_coord[0], self.opt.title_coord[1]) else: actor.GetPositionCoordinate().SetValue(0.5, 0.99) return actor
def display_rottra(self,mod): tm = vtk.vtkTextMapper() tp = tm.GetTextProperty() #tp.SetFontFamilyToArial() tp.SetFontSize(10) #tp.BoldOff() tp.ShadowOff() tp.SetColor(1, 1, 1) tp.SetOpacity(1) label = vtk.vtkActor2D() label.VisibilityOn() label.SetMapper(tm) v=[0,15] label.SetPosition(v) rottra = mod.rottra tm.SetInput("R:[%.3f,%.3f,%.3f] T:[%.3f,%.3f,%.3f]"%(rottra[0],rottra[1],rottra[2],rottra[3],rottra[4],rottra[5])) self.renderer.AddActor2D(label) self.renwin.Render()
def __init__(self, parent): wxVTKRenderWindow.__init__(self, parent, wx.NewId(), stereo=0) self.ren = vtkRenderer() self.GetRenderWindow().AddRenderer(self.ren) self.ren.SetBackground(0, 0, 0) self.sphereActor = vtkActor() # Settings for creation of sample self.x_uc = 1 self.y_uc = 1 self.use_sym = True self.fold_sym = True # Some defualts self.radius = 1.0 self.theta_res = 15 self.phi_res = 15 self.amb_col = (1., 1., 1.) self.diffuse = 1.0 self.ambient = 0.2 self.specular = 0.5 self.specular_power = 50. self.specular_col = (1., 1., 1.) self.element_col = atom_colors.jmol self.default_col = vtkc.yellow self.search_radius = 0.1 self.toolbar = None self.cursor_mode = 'orbit' self.textMapper = vtkTextMapper() tprop = self.textMapper.GetTextProperty() tprop.SetFontFamilyToArial() tprop.SetFontSize(10) tprop.BoldOn() tprop.ShadowOn() tprop.SetColor(1, 1, 1) self.textActor = vtkActor2D() self.textActor.VisibilityOff() self.textActor.SetMapper(self.textMapper) self.ren.AddActor(self.textActor)
def text(text, font_size=10, position=(0, 0), color=(0, 0, 0), is_visible=True): """ Generate a 2d text actor. """ mapper = vtk.vtkTextMapper() mapper.SetInput(text) properties = mapper.GetTextProperty() properties.SetFontFamilyToArial() properties.SetFontSize(font_size) properties.BoldOn() properties.ShadowOn() properties.SetColor(color) actor = vtk.vtkActor2D() actor.SetPosition(position) if not is_visible: actor.VisibilityOff() actor.SetMapper(mapper) return actor
def __setupPicking(self): # Create a text mapper and actor to display the results of picking. textMapper = vtk.vtkTextMapper() tprop = textMapper.GetTextProperty() tprop.SetFontFamilyToArial() tprop.SetFontSize(10) tprop.BoldOn() tprop.ShadowOn() tprop.SetColor(1, 0, 0) self.textActor = vtk.vtkActor2D() self.textActor.VisibilityOff() self.textActor.SetMapper(textMapper) # Create a cell picker. self.pick_opacity_init = 0.5 self._picker = vtk.vtkVolumePicker() self._picker.SetTolerance(0.00005) self._picker.SetVolumeOpacityIsovalue(self.pick_opacity_init) self._picker.PickCroppingPlanesOff()
def redraw(self, reset_camera=False): """ Redraw the render window. Args: reset_camera: Set to True to reset the camera to a pre-determined default for each structure. Defaults to False. """ self.ren.RemoveAllViewProps() self.picker = None self.add_picker_fixed() self.helptxt_mapper = vtk.vtkTextMapper() tprops = self.helptxt_mapper.GetTextProperty() tprops.SetFontSize(14) tprops.SetFontFamilyToTimes() tprops.SetColor(0, 0, 0) if self.structure is not None: self.set_structure(self.structure, reset_camera) self.ren_win.Render()
def setText(self, text): logging.debug("In TextWidget::setText()") self.text = text if self.scene: self.property.SetJustificationToLeft() self.property.SetVerticalJustificationToBottom() self.property.SetColor(self.fontColor) self.mapper = vtk.vtkTextMapper() self.mapper.SetTextProperty(self.property) self.mapper.SetInput(self.text) if self.textActor: self.scene.renderer.RemoveActor(self.textActor) self.textActor = vtk.vtkActor2D() self.textActor.SetMapper(self.mapper) self.textActor.PickableOff() self.textActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay() self.textActor.GetPositionCoordinate().SetValue(self.position[0], self.position[1]) self.textActor.VisibilityOn() self.scene.renderer.AddActor(self.textActor) self.autoResizeBox() self.scene.window.Render()
def MakeLabel(textLabel, renWinSize): """ Create a label. :param textLabel: The label. :param renWinSize: The size of the render window. Used to set the font size. :return: The actor for the text label. """ # Create one text property for all textProperty = vtk.vtkTextProperty() textProperty.SetJustificationToCentered() textProperty.SetFontSize(int(renWinSize / 20)) mapper = vtk.vtkTextMapper() mapper.SetInput(textLabel) mapper.SetTextProperty(textProperty) actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.SetPosition(renWinSize / 2.0, 16) return actor
def set_open_text_on_off(self): if not self.islabelon: tm = vtk.vtkTextMapper() tp = tm.GetTextProperty() tp.SetFontFamilyToArial() tp.SetFontSize(20) tp.BoldOff() tp.ShadowOff() tp.SetColor(1, 1, 1) tp.SetOpacity(0.8) self.label = vtk.vtkActor2D() self.label.VisibilityOn() self.label.SetMapper(tm) v=[200,100] self.label.SetPosition(v) tm.SetInput("VEDA - Visual Environment for Docking Algorithms - Version (%s)\n \nDevelopped by Gael Goret and Jorge Navaza"%self.version) self.renderer.AddActor2D(self.label) self.renwin.Render() self.islabelon=1 else : self.label.VisibilityOff() self.renderer.RemoveActor2D(self.label) self.renwin.Render() self.islabelon=0
def main(): titles = list() textMappers = list() textActors = list() uGrids = list() mappers = list() actors = list() renderers = list() uGrids.append(MakeVertex()) titles.append('VTK_VERTEX (=1)') uGrids.append(MakePolyVertex()) titles.append('VTK_POLY_VERTEX (=2)') uGrids.append(MakeLine()) titles.append('VTK_LINE (=3)') uGrids.append(MakePolyLine()) titles.append('VTK_POLY_LINE (=4)') uGrids.append(MakeTriangle()) titles.append('VTK_TRIANGLE (=5)') uGrids.append(MakeTriangleStrip()) titles.append('VTK_TRIANGLE_STRIP (=6)') uGrids.append(MakePolygon()) titles.append('VTK_POLYGON (=7)') uGrids.append(MakePixel()) titles.append('VTK_PIXEL (=8)') uGrids.append(MakeQuad()) titles.append('VTK_QUAD (=9)') uGrids.append(MakeTetra()) titles.append('VTK_TETRA (=10)') uGrids.append(MakeVoxel()) titles.append('VTK_VOXEL (=11)') uGrids.append(MakeHexahedron()) titles.append('VTK_HEXAHEDRON (=12)') uGrids.append(MakeWedge()) titles.append('VTK_WEDGE (=13)') uGrids.append(MakePyramid()) titles.append('VTK_PYRAMID (=14)') uGrids.append(MakePentagonalPrism()) titles.append('VTK_PENTAGONAL_PRISM (=15)') uGrids.append(MakeHexagonalPrism()) titles.append('VTK_HEXAGONAL_PRISM (=16)') colors = vtk.vtkNamedColors() renWin = vtk.vtkRenderWindow() renWin.SetSize(600, 600) renWin.SetWindowName('LinearCellDemo') iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) # Create one sphere for all sphere = vtk.vtkSphereSource() sphere.SetPhiResolution(21) sphere.SetThetaResolution(21) sphere.SetRadius(.08) # Create one text property for all textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(10) textProperty.SetJustificationToCentered() # Create and link the mappers actors and renderers together. for i in range(0, len(uGrids)): print('Creating:', titles[i]) textMappers.append(vtk.vtkTextMapper()) textActors.append(vtk.vtkActor2D()) mappers.append(vtk.vtkDataSetMapper()) actors.append(vtk.vtkActor()) renderers.append(vtk.vtkRenderer()) mappers[i].SetInputData(uGrids[i]) actors[i].SetMapper(mappers[i]) actors[i].GetProperty().SetColor(colors.GetColor3d('Tomato')) actors[i].GetProperty().EdgeVisibilityOn() actors[i].GetProperty().SetLineWidth(3) actors[i].GetProperty().SetOpacity(.5) renderers[i].AddViewProp(actors[i]) textMappers[i].SetInput(titles[i]) textActors[i].SetMapper(textMappers[i]) textActors[i].SetPosition(50, 10) renderers[i].AddViewProp(textActors[i]) # Label the points labelMapper = vtk.vtkLabeledDataMapper() labelMapper.SetInputData(uGrids[i]) labelActor = vtk.vtkActor2D() labelActor.SetMapper(labelMapper) renderers[i].AddViewProp(labelActor) # Glyph the points pointMapper = vtk.vtkGlyph3DMapper() pointMapper.SetInputData(uGrids[i]) pointMapper.SetSourceConnection(sphere.GetOutputPort()) pointMapper.ScalingOff() pointMapper.ScalarVisibilityOff() pointActor = vtk.vtkActor() pointActor.SetMapper(pointMapper) pointActor.GetProperty().SetDiffuseColor(colors.GetColor3d('Banana')) pointActor.GetProperty().SetSpecular(.6) pointActor.GetProperty().SetSpecularColor(1.0, 1.0, 1.0) pointActor.GetProperty().SetSpecularPower(100) renderers[i].AddViewProp(pointActor) renWin.AddRenderer(renderers[i]) # Setup the viewports xGridDimensions = 4 yGridDimensions = 4 rendererSize = 240 renWin.SetSize(rendererSize * xGridDimensions, rendererSize * yGridDimensions) for row in range(0, yGridDimensions): for col in range(0, xGridDimensions): index = row * xGridDimensions + col # (xmin, ymin, xmax, ymax) viewport = [float(col) / xGridDimensions, float(yGridDimensions - (row + 1)) / yGridDimensions, float(col + 1) / xGridDimensions, float(yGridDimensions - row) / yGridDimensions] if index > (len(actors) - 1): # Add a renderer even if there is no actor. # This makes the render window background all the same color. ren = vtk.vtkRenderer() ren.SetBackground(colors.GetColor3d('SlateGray')) ren.SetViewport(viewport) renWin.AddRenderer(ren) continue renderers[index].SetViewport(viewport) renderers[index].SetBackground(colors.GetColor3d('SlateGray')) renderers[index].ResetCamera() renderers[index].GetActiveCamera().Azimuth(30) renderers[index].GetActiveCamera().Elevation(-30) if index == 0: renderers[index].GetActiveCamera().Dolly(0.1) renderers[index].ResetCameraClippingRange() if index == 4: renderers[index].GetActiveCamera().Dolly(0.8) renderers[index].ResetCameraClippingRange() renderers[index].ResetCameraClippingRange() renWin.Render() iRen.Initialize() iRen.Start()
i = i + 1 attribs = [] if bold: attribs.append("b") if italic: attribs.append("i") if shadow: attribs.append("s") face_name = "Arial" if attribs: face_name = face_name + " (" + ",".join(attribs) + ")" mapper = vtk.vtkTextMapper() mapper.SetInput(face_name + ": " + default_text) tprop = mapper.GetTextProperty() tprop.SetFontFamilyToArial() tprop.SetColor(text_color[0], text_color[1], text_color[2]) tprop.SetBold(bold) tprop.SetItalic(italic) tprop.SetShadow(shadow) tprop.SetFontSize(current_font_size) actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.SetDisplayPosition(10, i * (current_font_size + 5)) ren.AddActor(actor)
def testParametricFunctions(self): # ------------------------------------------------------------ # Get a texture # ------------------------------------------------------------ textureReader = vtk.vtkJPEGReader() textureReader.SetFileName(VTK_DATA_ROOT + "/Data/beach.jpg") texture = vtk.vtkTexture() texture.SetInputConnection(textureReader.GetOutputPort()) # ------------------------------------------------------------ # For each parametric surface: # 1) Create it # 2) Assign mappers and actors # 3) Position the object # 5) Add a label # ------------------------------------------------------------ # ------------------------------------------------------------ # Create a torus # ------------------------------------------------------------ torus = vtk.vtkParametricTorus() torusSource = vtk.vtkParametricFunctionSource() torusSource.SetParametricFunction(torus) torusSource.SetScalarModeToPhase() torusMapper = vtk.vtkPolyDataMapper() torusMapper.SetInputConnection(torusSource.GetOutputPort()) torusMapper.SetScalarRange(0, 360) torusActor = vtk.vtkActor() torusActor.SetMapper(torusMapper) torusActor.SetPosition(0, 12, 0) torusTextMapper = vtk.vtkTextMapper() torusTextMapper.SetInput("Torus") torusTextMapper.GetTextProperty().SetJustificationToCentered() torusTextMapper.GetTextProperty().SetVerticalJustificationToCentered() torusTextMapper.GetTextProperty().SetColor(1, 0, 0) torusTextMapper.GetTextProperty().SetFontSize(14) torusTextActor = vtk.vtkActor2D() torusTextActor.SetMapper(torusTextMapper) torusTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() torusTextActor.GetPositionCoordinate().SetValue(0, 9.5, 0) # ------------------------------------------------------------ # Create a Klein bottle # ------------------------------------------------------------ klein = vtk.vtkParametricKlein() kleinSource = vtk.vtkParametricFunctionSource() kleinSource.SetParametricFunction(klein) kleinSource.SetScalarModeToU0V0() kleinMapper = vtk.vtkPolyDataMapper() kleinMapper.SetInputConnection(kleinSource.GetOutputPort()) kleinMapper.SetScalarRange(0, 3) kleinActor = vtk.vtkActor() kleinActor.SetMapper(kleinMapper) kleinActor.SetPosition(8, 10.5, 0) kleinTextMapper = vtk.vtkTextMapper() kleinTextMapper.SetInput("Klein") kleinTextMapper.GetTextProperty().SetJustificationToCentered() kleinTextMapper.GetTextProperty().SetVerticalJustificationToCentered() kleinTextMapper.GetTextProperty().SetColor(1, 0, 0) kleinTextMapper.GetTextProperty().SetFontSize(14) kleinTextActor = vtk.vtkActor2D() kleinTextActor.SetMapper(kleinTextMapper) kleinTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() kleinTextActor.GetPositionCoordinate().SetValue(8, 9.5, 0) # ------------------------------------------------------------ # Create a Figure-8 Klein # ------------------------------------------------------------ klein2 = vtk.vtkParametricFigure8Klein() klein2Source = vtk.vtkParametricFunctionSource() klein2Source.SetParametricFunction(klein2) klein2Source.GenerateTextureCoordinatesOn() klein2Mapper = vtk.vtkPolyDataMapper() klein2Mapper.SetInputConnection(klein2Source.GetOutputPort()) klein2Mapper.SetScalarRange(0, 3) klein2Actor = vtk.vtkActor() klein2Actor.SetMapper(klein2Mapper) klein2Actor.SetPosition(16, 12, 0) klein2Actor.SetTexture(texture) fig8KleinTextMapper = vtk.vtkTextMapper() fig8KleinTextMapper.SetInput("Fig-8.Klein") fig8KleinTextMapper.GetTextProperty().SetJustificationToCentered() fig8KleinTextMapper.GetTextProperty().SetVerticalJustificationToCentered() fig8KleinTextMapper.GetTextProperty().SetColor(1, 0, 0) fig8KleinTextMapper.GetTextProperty().SetFontSize(14) fig8KleinTextActor = vtk.vtkActor2D() fig8KleinTextActor.SetMapper(fig8KleinTextMapper) fig8KleinTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() fig8KleinTextActor.GetPositionCoordinate().SetValue(16, 9.5, 0) # ------------------------------------------------------------ # Create a Mobius strip # ------------------------------------------------------------ mobius = vtk.vtkParametricMobius() mobiusSource = vtk.vtkParametricFunctionSource() mobiusSource.SetParametricFunction(mobius) mobiusSource.GenerateTextureCoordinatesOn() mobiusMapper = vtk.vtkPolyDataMapper() mobiusMapper.SetInputConnection(mobiusSource.GetOutputPort()) mobiusActor = vtk.vtkActor() mobiusActor.SetMapper(mobiusMapper) mobiusActor.RotateX(45) mobiusActor.SetPosition(24, 12, 0) mobiusActor.SetTexture(texture) mobiusTextMapper = vtk.vtkTextMapper() mobiusTextMapper.SetInput("Mobius") mobiusTextMapper.GetTextProperty().SetJustificationToCentered() mobiusTextMapper.GetTextProperty().SetVerticalJustificationToCentered() mobiusTextMapper.GetTextProperty().SetColor(1, 0, 0) mobiusTextMapper.GetTextProperty().SetFontSize(14) mobiusTextActor = vtk.vtkActor2D() mobiusTextActor.SetMapper(mobiusTextMapper) mobiusTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() mobiusTextActor.GetPositionCoordinate().SetValue(24, 9.5, 0) # ------------------------------------------------------------ # Create a super toroid # ------------------------------------------------------------ toroid = vtk.vtkParametricSuperToroid() toroid.SetN1(2) toroid.SetN2(3) toroidSource = vtk.vtkParametricFunctionSource() toroidSource.SetParametricFunction(toroid) toroidSource.SetScalarModeToU() toroidMapper = vtk.vtkPolyDataMapper() toroidMapper.SetInputConnection(toroidSource.GetOutputPort()) toroidMapper.SetScalarRange(0, 6.28) toroidActor = vtk.vtkActor() toroidActor.SetMapper(toroidMapper) toroidActor.SetPosition(0, 4, 0) superToroidTextMapper = vtk.vtkTextMapper() superToroidTextMapper.SetInput("Super.Toroid") superToroidTextMapper.GetTextProperty().SetJustificationToCentered() superToroidTextMapper.GetTextProperty().SetVerticalJustificationToCentered() superToroidTextMapper.GetTextProperty().SetColor(1, 0, 0) superToroidTextMapper.GetTextProperty().SetFontSize(14) superToroidTextActor = vtk.vtkActor2D() superToroidTextActor.SetMapper(superToroidTextMapper) superToroidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() superToroidTextActor.GetPositionCoordinate().SetValue(0, 1.5, 0) # ------------------------------------------------------------ # Create a super ellipsoid # ------------------------------------------------------------ superEllipsoid = vtk.vtkParametricSuperEllipsoid() superEllipsoid.SetXRadius(1.25) superEllipsoid.SetYRadius(1.5) superEllipsoid.SetZRadius(1.0) superEllipsoid.SetN1(1.1) superEllipsoid.SetN2(1.75) superEllipsoidSource = vtk.vtkParametricFunctionSource() superEllipsoidSource.SetParametricFunction(superEllipsoid) superEllipsoidSource.SetScalarModeToV() superEllipsoidMapper = vtk.vtkPolyDataMapper() superEllipsoidMapper.SetInputConnection(superEllipsoidSource.GetOutputPort()) superEllipsoidMapper.SetScalarRange(0, 3.14) superEllipsoidActor = vtk.vtkActor() superEllipsoidActor.SetMapper(superEllipsoidMapper) superEllipsoidActor.SetPosition(8, 4, 0) superEllipsoidTextMapper = vtk.vtkTextMapper() superEllipsoidTextMapper.SetInput("Super.Ellipsoid") superEllipsoidTextMapper.GetTextProperty().SetJustificationToCentered() superEllipsoidTextMapper.GetTextProperty().SetVerticalJustificationToCentered() superEllipsoidTextMapper.GetTextProperty().SetColor(1, 0, 0) superEllipsoidTextMapper.GetTextProperty().SetFontSize(14) superEllipsoidTextActor = vtk.vtkActor2D() superEllipsoidTextActor.SetMapper(superEllipsoidTextMapper) superEllipsoidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() superEllipsoidTextActor.GetPositionCoordinate().SetValue(8, 1.5, 0) # ------------------------------------------------------------ # Create an open 1D spline # ------------------------------------------------------------ splinePoints = [ [0.50380158308139134, -0.60679315105396936, -0.37248976406291578], [-0.4354646054261665, -0.85362339758017258, -0.84844312996065385], [0.2163147512899315, -0.39797507012168643, -0.76700353518454523], [0.97158415334838644, -0.58513467367046257, -0.35846037946569753], [-0.64359767997804918, -0.94620739107309249, -0.90762176546623086], [-0.39901219094126117, -0.1978931497772658, 0.0098316934936828471], [-0.75872745167404765, 0.067719714281950116, 0.165237936733867], [-0.84599731389712418, -0.67685466896596114, 0.10357868909071133], [0.84702754758625654, -0.0080077177882230677, -0.58571286666473044], [-0.076150034124101484, 0.14637647622561856, 0.1494359239700418] ] inputPoints = vtk.vtkPoints() for i in range(0, 10): inputPoints.InsertPoint(i, splinePoints[i]) spline = vtk.vtkParametricSpline() spline.SetPoints(inputPoints) spline.ClosedOff() splineSource = vtk.vtkParametricFunctionSource() splineSource.SetParametricFunction(spline) splineMapper = vtk.vtkPolyDataMapper() splineMapper.SetInputConnection(splineSource.GetOutputPort()) splineActor = vtk.vtkActor() splineActor.SetMapper(splineMapper) splineActor.SetPosition(16, 4, 0) splineActor.GetProperty().SetColor(0, 0, 0) splineTextMapper = vtk.vtkTextMapper() splineTextMapper.SetInput("Open.Spline") splineTextMapper.GetTextProperty().SetJustificationToCentered() splineTextMapper.GetTextProperty().SetVerticalJustificationToCentered() splineTextMapper.GetTextProperty().SetColor(1, 0, 0) splineTextMapper.GetTextProperty().SetFontSize(14) splineTextActor = vtk.vtkActor2D() splineTextActor.SetMapper(splineTextMapper) splineTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() splineTextActor.GetPositionCoordinate().SetValue(16, 1.5, 0) # ------------------------------------------------------------ # Create a closed 1D spline # ------------------------------------------------------------ spline2 = vtk.vtkParametricSpline() spline2.SetPoints(inputPoints) spline2.ClosedOn() spline2Source = vtk.vtkParametricFunctionSource() spline2Source.SetParametricFunction(spline2) spline2Mapper = vtk.vtkPolyDataMapper() spline2Mapper.SetInputConnection(spline2Source.GetOutputPort()) spline2Actor = vtk.vtkActor() spline2Actor.SetMapper(spline2Mapper) spline2Actor.SetPosition(24, 4, 0) spline2Actor.GetProperty().SetColor(0, 0, 0) spline2TextMapper = vtk.vtkTextMapper() spline2TextMapper.SetInput("Closed.Spline") spline2TextMapper.GetTextProperty().SetJustificationToCentered() spline2TextMapper.GetTextProperty().SetVerticalJustificationToCentered() spline2TextMapper.GetTextProperty().SetColor(1, 0, 0) spline2TextMapper.GetTextProperty().SetFontSize(14) spline2TextActor = vtk.vtkActor2D() spline2TextActor.SetMapper(spline2TextMapper) spline2TextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() spline2TextActor.GetPositionCoordinate().SetValue(24, 1.5, 0) # ------------------------------------------------------------ # Create a spiral conic # ------------------------------------------------------------ sconic = vtk.vtkParametricConicSpiral() sconic.SetA(0.8) sconic.SetB(2.5) sconic.SetC(0.4) sconicSource = vtk.vtkParametricFunctionSource() sconicSource.SetParametricFunction(sconic) sconicSource.SetScalarModeToDistance() sconicMapper = vtk.vtkPolyDataMapper() sconicMapper.SetInputConnection(sconicSource.GetOutputPort()) sconicActor = vtk.vtkActor() sconicActor.SetMapper(sconicMapper) sconicMapper.SetScalarRange(0, 9) sconicActor.SetPosition(0, -4, 0) sconicActor.SetScale(1.2, 1.2, 1.2) sconicTextMapper = vtk.vtkTextMapper() sconicTextMapper.SetInput("Spiral.Conic") sconicTextMapper.GetTextProperty().SetJustificationToCentered() sconicTextMapper.GetTextProperty().SetVerticalJustificationToCentered() sconicTextMapper.GetTextProperty().SetColor(1, 0, 0) sconicTextMapper.GetTextProperty().SetFontSize(14) sconicTextActor = vtk.vtkActor2D() sconicTextActor.SetMapper(sconicTextMapper) sconicTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() sconicTextActor.GetPositionCoordinate().SetValue(0, -6.5, 0) # ------------------------------------------------------------ # Create Boy's surface # ------------------------------------------------------------ boy = vtk.vtkParametricBoy() boySource = vtk.vtkParametricFunctionSource() boySource.SetParametricFunction(boy) boySource.SetScalarModeToModulus() boyMapper = vtk.vtkPolyDataMapper() boyMapper.SetInputConnection(boySource.GetOutputPort()) boyMapper.SetScalarRange(0, 2) boyActor = vtk.vtkActor() boyActor.SetMapper(boyMapper) boyActor.SetPosition(8, -4, 0) boyActor.SetScale(1.5, 1.5, 1.5) boyTextMapper = vtk.vtkTextMapper() boyTextMapper.SetInput("Boy") boyTextMapper.GetTextProperty().SetJustificationToCentered() boyTextMapper.GetTextProperty().SetVerticalJustificationToCentered() boyTextMapper.GetTextProperty().SetColor(1, 0, 0) boyTextMapper.GetTextProperty().SetFontSize(14) boyTextActor = vtk.vtkActor2D() boyTextActor.SetMapper(boyTextMapper) boyTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() boyTextActor.GetPositionCoordinate().SetValue(8, -6.5, 0) # ------------------------------------------------------------ # Create a cross cap # ------------------------------------------------------------ crossCap = vtk.vtkParametricCrossCap() crossCapSource = vtk.vtkParametricFunctionSource() crossCapSource.SetParametricFunction(crossCap) crossCapSource.SetScalarModeToY() crossCapMapper = vtk.vtkPolyDataMapper() crossCapMapper.SetInputConnection(crossCapSource.GetOutputPort()) crossCapActor = vtk.vtkActor() crossCapActor.SetMapper(crossCapMapper) crossCapActor.RotateX(65) crossCapActor.SetPosition(16, -4, 0) crossCapActor.SetScale(1.5, 1.5, 1.5) crossCapTextMapper = vtk.vtkTextMapper() crossCapTextMapper.SetInput("Cross.Cap") crossCapTextMapper.GetTextProperty().SetJustificationToCentered() crossCapTextMapper.GetTextProperty().SetVerticalJustificationToCentered() crossCapTextMapper.GetTextProperty().SetColor(1, 0, 0) crossCapTextMapper.GetTextProperty().SetFontSize(14) crossCapTextActor = vtk.vtkActor2D() crossCapTextActor.SetMapper(crossCapTextMapper) crossCapTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() crossCapTextActor.GetPositionCoordinate().SetValue(16, -6.5, 0) # ------------------------------------------------------------ # Create Dini's surface # ------------------------------------------------------------ dini = vtk.vtkParametricDini() diniSource = vtk.vtkParametricFunctionSource() diniSource.SetScalarModeToDistance() diniSource.SetParametricFunction(dini) diniMapper = vtk.vtkPolyDataMapper() diniMapper.SetInputConnection(diniSource.GetOutputPort()) diniActor = vtk.vtkActor() diniActor.SetMapper(diniMapper) diniActor.RotateX(-90) diniActor.SetPosition(24, -3, 0) diniActor.SetScale(1.5, 1.5, 0.5) diniTextMapper = vtk.vtkTextMapper() diniTextMapper.SetInput("Dini") diniTextMapper.GetTextProperty().SetJustificationToCentered() diniTextMapper.GetTextProperty().SetVerticalJustificationToCentered() diniTextMapper.GetTextProperty().SetColor(1, 0, 0) diniTextMapper.GetTextProperty().SetFontSize(14) diniTextActor = vtk.vtkActor2D() diniTextActor.SetMapper(diniTextMapper) diniTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() diniTextActor.GetPositionCoordinate().SetValue(24, -6.5, 0) # ------------------------------------------------------------ # Create Enneper's surface # ------------------------------------------------------------ enneper = vtk.vtkParametricEnneper() enneperSource = vtk.vtkParametricFunctionSource() enneperSource.SetParametricFunction(enneper) enneperSource.SetScalarModeToQuadrant() enneperMapper = vtk.vtkPolyDataMapper() enneperMapper.SetInputConnection(enneperSource.GetOutputPort()) enneperMapper.SetScalarRange(1, 4) enneperActor = vtk.vtkActor() enneperActor.SetMapper(enneperMapper) enneperActor.SetPosition(0, -12, 0) enneperActor.SetScale(0.25, 0.25, 0.25) enneperTextMapper = vtk.vtkTextMapper() enneperTextMapper.SetInput("Enneper") enneperTextMapper.GetTextProperty().SetJustificationToCentered() enneperTextMapper.GetTextProperty().SetVerticalJustificationToCentered() enneperTextMapper.GetTextProperty().SetColor(1, 0, 0) enneperTextMapper.GetTextProperty().SetFontSize(14) enneperTextActor = vtk.vtkActor2D() enneperTextActor.SetMapper(enneperTextMapper) enneperTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() enneperTextActor.GetPositionCoordinate().SetValue(0, -14.5, 0) # ------------------------------------------------------------ # Create an ellipsoidal surface # ------------------------------------------------------------ ellipsoid = vtk.vtkParametricEllipsoid() ellipsoid.SetXRadius(1) ellipsoid.SetYRadius(0.75) ellipsoid.SetZRadius(0.5) ellipsoidSource = vtk.vtkParametricFunctionSource() ellipsoidSource.SetParametricFunction(ellipsoid) ellipsoidSource.SetScalarModeToZ() ellipsoidMapper = vtk.vtkPolyDataMapper() ellipsoidMapper.SetInputConnection(ellipsoidSource.GetOutputPort()) ellipsoidMapper.SetScalarRange(-0.5, 0.5) ellipsoidActor = vtk.vtkActor() ellipsoidActor.SetMapper(ellipsoidMapper) ellipsoidActor.SetPosition(8, -12, 0) ellipsoidActor.SetScale(1.5, 1.5, 1.5) ellipsoidTextMapper = vtk.vtkTextMapper() ellipsoidTextMapper.SetInput("Ellipsoid") ellipsoidTextMapper.GetTextProperty().SetJustificationToCentered() ellipsoidTextMapper.GetTextProperty().SetVerticalJustificationToCentered() ellipsoidTextMapper.GetTextProperty().SetColor(1, 0, 0) ellipsoidTextMapper.GetTextProperty().SetFontSize(14) ellipsoidTextActor = vtk.vtkActor2D() ellipsoidTextActor.SetMapper(ellipsoidTextMapper) ellipsoidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() ellipsoidTextActor.GetPositionCoordinate().SetValue(8, -14.5, 0) # ------------------------------------------------------------ # Create a surface with random hills on it. # ------------------------------------------------------------ randomHills = vtk.vtkParametricRandomHills() randomHills.AllowRandomGenerationOn() randomHillsSource = vtk.vtkParametricFunctionSource() randomHillsSource.SetParametricFunction(randomHills) randomHillsSource.GenerateTextureCoordinatesOn() randomHillsMapper = vtk.vtkPolyDataMapper() randomHillsMapper.SetInputConnection(randomHillsSource.GetOutputPort()) randomHillsActor = vtk.vtkActor() randomHillsActor.SetMapper(randomHillsMapper) randomHillsActor.SetPosition(16, -14, 0) randomHillsActor.SetScale(0.2, 0.2, 0.2) randomHillsActor.SetTexture(texture) randomHillsTextMapper = vtk.vtkTextMapper() randomHillsTextMapper.SetInput("Random.Hills") randomHillsTextMapper.GetTextProperty().SetJustificationToCentered() randomHillsTextMapper.GetTextProperty().SetVerticalJustificationToCentered() randomHillsTextMapper.GetTextProperty().SetColor(1, 0, 0) randomHillsTextMapper.GetTextProperty().SetFontSize(14) randomHillsTextActor = vtk.vtkActor2D() randomHillsTextActor.SetMapper(randomHillsTextMapper) randomHillsTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() randomHillsTextActor.GetPositionCoordinate().SetValue(16, -14.5, 0) # ------------------------------------------------------------ # Create Steiner's Roman Surface. # ------------------------------------------------------------ roman = vtk.vtkParametricRoman() roman.SetRadius(1.5) romanSource = vtk.vtkParametricFunctionSource() romanSource.SetParametricFunction(roman) romanSource.SetScalarModeToX() romanMapper = vtk.vtkPolyDataMapper() romanMapper.SetInputConnection(romanSource.GetOutputPort()) romanActor = vtk.vtkActor() romanActor.SetMapper(romanMapper) romanActor.SetPosition(24, -12, 0) romanTextMapper = vtk.vtkTextMapper() romanTextMapper.SetInput("Roman") romanTextMapper.GetTextProperty().SetJustificationToCentered() romanTextMapper.GetTextProperty().SetVerticalJustificationToCentered() romanTextMapper.GetTextProperty().SetColor(1, 0, 0) romanTextMapper.GetTextProperty().SetFontSize(14) romanTextActor = vtk.vtkActor2D() romanTextActor.SetMapper(romanTextMapper) romanTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() romanTextActor.GetPositionCoordinate().SetValue(24, -14.5, 0) # ------------------------------------------------------------ # Create the RenderWindow, Renderer and both Actors # ------------------------------------------------------------ ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # add actors ren.AddViewProp(torusActor) ren.AddViewProp(kleinActor) ren.AddViewProp(klein2Actor) ren.AddViewProp(toroidActor) ren.AddViewProp(superEllipsoidActor) ren.AddViewProp(mobiusActor) ren.AddViewProp(splineActor) ren.AddViewProp(spline2Actor) ren.AddViewProp(sconicActor) ren.AddViewProp(boyActor) ren.AddViewProp(crossCapActor) ren.AddViewProp(diniActor) ren.AddViewProp(enneperActor) ren.AddViewProp(ellipsoidActor) ren.AddViewProp(randomHillsActor) ren.AddViewProp(romanActor) #add text actors ren.AddViewProp(torusTextActor) ren.AddViewProp(kleinTextActor) ren.AddViewProp(fig8KleinTextActor) ren.AddViewProp(mobiusTextActor) ren.AddViewProp(superToroidTextActor) ren.AddViewProp(superEllipsoidTextActor) ren.AddViewProp(splineTextActor) ren.AddViewProp(spline2TextActor) ren.AddViewProp(sconicTextActor) ren.AddViewProp(boyTextActor) ren.AddViewProp(crossCapTextActor) ren.AddViewProp(diniTextActor) ren.AddViewProp(enneperTextActor) ren.AddViewProp(ellipsoidTextActor) ren.AddViewProp(randomHillsTextActor) ren.AddViewProp(romanTextActor) ren.SetBackground(0.7, 0.8, 1) renWin.SetSize(500, 500) ren.ResetCamera() ren.GetActiveCamera().Zoom(1.3) iren.Initialize() renWin.Render() img_file = "TestParametricFunctions.png" # NOTE: this test has a companion .tcl test. The threshold set # here should be the same as the threshold in the .tcl # test. Both tests should produce exactly the same results. vtk.test.Testing.compareImage(iren.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=10) vtk.test.Testing.interact()
def _CreateButton(self): borderwidth = self._Config['borderwidth'] width, height = self._DisplaySize x, y = self._DisplayOrigin x0, y0 = self._Renderer.GetOrigin() self._Points = vtk.vtkPoints() self._SetPoints() cells = vtk.vtkCellArray() cells.InsertNextCell(4) cells.InsertCellPoint(1) cells.InsertCellPoint(3) cells.InsertCellPoint(5) cells.InsertCellPoint(7) if borderwidth > 0: cells.InsertNextCell(4) cells.InsertCellPoint(0) cells.InsertCellPoint(1) cells.InsertCellPoint(3) cells.InsertCellPoint(2) cells.InsertNextCell(4) cells.InsertCellPoint(2) cells.InsertCellPoint(3) cells.InsertCellPoint(5) cells.InsertCellPoint(4) cells.InsertNextCell(4) cells.InsertCellPoint(4) cells.InsertCellPoint(5) cells.InsertCellPoint(7) cells.InsertCellPoint(6) cells.InsertNextCell(4) cells.InsertCellPoint(6) cells.InsertCellPoint(7) cells.InsertCellPoint(1) cells.InsertCellPoint(0) scalars = vtk.vtkUnsignedCharArray() scalars.InsertTuple1(0, 0) scalars.InsertTuple1(1, 2) scalars.InsertTuple1(2, 2) scalars.InsertTuple1(3, 3) scalars.InsertTuple1(4, 3) data = vtk.vtkPolyData() data.SetPoints(self._Points) data.SetPolys(cells) data.GetCellData().SetScalars(scalars) mapper = vtk.vtkPolyDataMapper2D() mapper.SetInput(data) mapper.SetLookupTable(self._LookupTable) mapper.SetColorModeToMapScalars() mapper.SetScalarRange(0, 3) actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.SetPosition(x - x0, y - y0) self._Scalars = scalars self._Actors.append(actor) if self._Renderer: self._Renderer.AddActor2D(actor) mapper = vtk.vtkTextMapper() mapper.SetInput(self._Config['text']) try: property = mapper.GetTextProperty() except AttributeError: property = mapper property.SetFontSize(self._Config['fontsize']) if self._Config['font'] in ('courier', 'Courier'): property.SetFontFamilyToCourier() elif self._Config['font'] in ('arial', 'Arial'): property.SetFontFamilyToArial() elif self._Config['font'] in ('times', 'Times'): property.SetFontFamilyToTimes() property.SetJustificationToCentered() property.SetVerticalJustificationToCentered() property.BoldOn() self._TextMapper = mapper actor = vtk.vtkActor2D() apply(actor.GetProperty().SetColor, self._Config['foreground']) actor.SetMapper(mapper) if "FreeType" in mapper.GetClassName(): actor.SetPosition(x + width / 2 - x0, y + height / 2 - y0) else: # not a FreeType font, needs position correction actor.SetPosition(x + width / 2 - x0 + 1, y + height / 2 - y0 + 1) self._Actors.append(actor) if self._Renderer: self._Renderer.AddActor2D(actor)
#!/usr/bin/env python import vtk from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # # display text over an image # ellipse = vtk.vtkImageEllipsoidSource() mapImage = vtk.vtkImageMapper() mapImage.SetInputConnection(ellipse.GetOutputPort()) mapImage.SetColorWindow(255) mapImage.SetColorLevel(127.5) img = vtk.vtkActor2D() img.SetMapper(mapImage) mapText = vtk.vtkTextMapper() mapText.SetInput("Text Overlay") mapText.GetTextProperty().SetFontSize(15) mapText.GetTextProperty().SetColor(0,1,1) mapText.GetTextProperty().BoldOn() mapText.GetTextProperty().ShadowOn() txt = vtk.vtkActor2D() txt.SetMapper(mapText) txt.SetPosition(138,128) ren1 = vtk.vtkRenderer() ren1.AddActor2D(img) ren1.AddActor2D(txt) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin)
def main(): colors = vtk.vtkNamedColors() # Set the background color. colors.SetColor("BkgColor", [51, 77, 102, 255]) sourceObjects = list() sourceObjects.append(vtk.vtkSphereSource()) sourceObjects[-1].SetPhiResolution(21) sourceObjects[-1].SetThetaResolution(21) sourceObjects.append(vtk.vtkConeSource()) sourceObjects[-1].SetResolution(51) sourceObjects.append(vtk.vtkCylinderSource()) sourceObjects[-1].SetResolution(51) sourceObjects.append(vtk.vtkCubeSource()) sourceObjects.append(vtk.vtkPlaneSource()) sourceObjects.append(vtk.vtkTextSource()) sourceObjects[-1].SetText("Hello") sourceObjects[-1].BackingOff() sourceObjects.append(vtk.vtkPointSource()) sourceObjects[-1].SetNumberOfPoints(500) sourceObjects.append(vtk.vtkDiskSource()) sourceObjects[-1].SetCircumferentialResolution(51) sourceObjects.append(vtk.vtkLineSource()) renderers = list() mappers = list() actors = list() textmappers = list() textactors = list() # Create one text property for all. textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(16) textProperty.SetJustificationToCentered() backProperty = vtk.vtkProperty() backProperty.SetColor(colors.GetColor3d("Red")) # Create a source, renderer, mapper, and actor # for each object. for i in range(0, len(sourceObjects)): mappers.append(vtk.vtkPolyDataMapper()) mappers[i].SetInputConnection(sourceObjects[i].GetOutputPort()) actors.append(vtk.vtkActor()) actors[i].SetMapper(mappers[i]) actors[i].GetProperty().SetColor(colors.GetColor3d("Seashell")) actors[i].SetBackfaceProperty(backProperty) textmappers.append(vtk.vtkTextMapper()) textmappers[i].SetInput(sourceObjects[i].GetClassName()) textmappers[i].SetTextProperty(textProperty) textactors.append(vtk.vtkActor2D()) textactors[i].SetMapper(textmappers[i]) textactors[i].SetPosition(120, 16) renderers.append(vtk.vtkRenderer()) gridDimensions = 3 # We need a renderer even if there is no actor. for i in range(len(sourceObjects), gridDimensions ** 2): renderers.append(vtk.vtkRenderer()) renderWindow = vtk.vtkRenderWindow() renderWindow.SetWindowName("Source Objects Demo") rendererSize = 300 renderWindow.SetSize(rendererSize * gridDimensions, rendererSize * gridDimensions) for row in range(0, gridDimensions): for col in range(0, gridDimensions): index = row * gridDimensions + col x0 = float(col) / gridDimensions y0 = float(gridDimensions - row - 1) / gridDimensions x1 = float(col + 1) / gridDimensions y1 = float(gridDimensions - row) / gridDimensions renderWindow.AddRenderer(renderers[index]) renderers[index].SetViewport(x0, y0, x1, y1) if index > (len(sourceObjects) - 1): continue renderers[index].AddActor(actors[index]) renderers[index].AddActor(textactors[index]) renderers[index].SetBackground(colors.GetColor3d("BkgColor")) renderers[index].ResetCamera() renderers[index].GetActiveCamera().Azimuth(30) renderers[index].GetActiveCamera().Elevation(30) renderers[index].GetActiveCamera().Zoom(0.8) renderers[index].ResetCameraClippingRange() interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
def testFreetypeTextMapperBigger(self): currentFontSize = 55 defaultText = "MmNnKk @" textColor = [246, 255, 11] bgColor = [56, 56, 154] for i in range(0, len(textColor)): textColor[i] /= 255.0 bgColor[i] /= 255.0 renWin = vtk.vtkRenderWindow() renWin.SetSize(790, 450) ren = vtk.vtkRenderer() ren.SetBackground(bgColor) renWin.AddRenderer(ren) families = ["Arial", "Courier", "Times"] attributes = [[0, 0], [1, 1]] # bold, italic def SetAttributesText(attrib): """ Expects a list of attributes of size 2, returns a string """ s = "" if attrib[0] != 0: s += "b" if attrib[1] != 0: s += "i" return ','.join(list(s)) mapper = dict() actor = dict() pos = 0 for i, family in enumerate(families): for j, attrib in enumerate(attributes): pos += 1 txt = "" txtAttrib = SetAttributesText(attrib) if len(txtAttrib) != 0: txt = family + " (" + SetAttributesText( attrib) + "): " + defaultText else: txt = family + ": " + defaultText idx = ''.join(map(str, [i, j])) mapper.update({idx: vtk.vtkTextMapper()}) mapper[idx].SetInput(txt) tprop = mapper[idx].GetTextProperty() eval('tprop.SetFontFamilyTo' + family + '()') tprop.SetColor(textColor) tprop.SetBold(attrib[0]) tprop.SetItalic(attrib[1]) tprop.SetFontSize(currentFontSize) actor.update({idx: vtk.vtkActor2D()}) actor[idx].SetMapper(mapper[idx]) actor[idx].SetDisplayPosition(10, pos * (currentFontSize + 5)) ren.AddActor(actor[idx]) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) renWin.Render()
singleLineTextProp.SetFontFamilyToArial() singleLineTextProp.BoldOff() singleLineTextProp.ItalicOff() singleLineTextProp.ShadowOff() # The font and text properties (except justification) are the same for # each multi line mapper. Let's create a common text property object multiLineTextProp = vtk.vtkTextProperty() multiLineTextProp.ShallowCopy(singleLineTextProp) multiLineTextProp.BoldOn() multiLineTextProp.ItalicOn() multiLineTextProp.ShadowOn() multiLineTextProp.SetLineSpacing(0.8) # The text is on a single line and bottom-justified. singleLineTextB = vtk.vtkTextMapper() singleLineTextB.SetInput("Single line (bottom)") tprop = singleLineTextB.GetTextProperty() tprop.ShallowCopy(singleLineTextProp) tprop.SetVerticalJustificationToBottom() tprop.SetColor(1, 0, 0) singleLineTextActorB = vtk.vtkActor2D() singleLineTextActorB.SetMapper(singleLineTextB) singleLineTextActorB.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay() singleLineTextActorB.GetPositionCoordinate().SetValue(0.05, 0.85) # The text is on a single line and center-justified (vertical # justification). singleLineTextC = vtk.vtkTextMapper() singleLineTextC.SetInput("Single line (centered)") tprop = singleLineTextC.GetTextProperty()
# set up the actor actor = vtk.vtkActor() actor.SetMapper(mapper) # set up the text properties for nice text font_size = 20 textProp = vtk.vtkTextProperty() textProp.SetFontSize(font_size) textProp.SetFontFamilyToArial() textProp.BoldOff() textProp.ItalicOff() textProp.ShadowOff() textProp.SetColor(0.0, 0.0, 0.0) # make a title title = vtk.vtkTextMapper() title.SetInput("Example 3D arrow/quiver/vector field plot") # make the title text use the text properties titleProp = title.GetTextProperty() titleProp.ShallowCopy(textProp) titleProp.SetJustificationToCentered() titleProp.SetVerticalJustificationToTop() titleProp.BoldOn() # make the actor for the title titleActor = vtk.vtkTextActor() titleActor.SetMapper(title) titleActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay() titleActor.GetPositionCoordinate().SetValue(0.5, 0.95)
def ParametricObjects(self): parametricObjects = list() parametricObjects.append(vtk.vtkParametricBoy()) parametricObjects.append(vtk.vtkParametricConicSpiral()) parametricObjects.append(vtk.vtkParametricCrossCap()) parametricObjects.append(vtk.vtkParametricDini()) parametricObjects.append(vtk.vtkParametricEllipsoid()) parametricObjects[-1].SetXRadius(0.5) parametricObjects[-1].SetYRadius(2.0) parametricObjects.append(vtk.vtkParametricEnneper()) parametricObjects.append(vtk.vtkParametricFigure8Klein()) parametricObjects.append(vtk.vtkParametricKlein()) parametricObjects.append(vtk.vtkParametricMobius()) parametricObjects[-1].SetRadius(2) parametricObjects[-1].SetMinimumV(-0.5) parametricObjects[-1].SetMaximumV(0.5) parametricObjects.append(vtk.vtkParametricRandomHills()) parametricObjects[-1].AllowRandomGenerationOff() parametricObjects.append(vtk.vtkParametricRoman()) parametricObjects.append(vtk.vtkParametricSuperEllipsoid()) parametricObjects[-1].SetN1(0.5) parametricObjects[-1].SetN2(0.1) parametricObjects.append(vtk.vtkParametricSuperToroid()) parametricObjects[-1].SetN1(0.2) parametricObjects[-1].SetN2(3.0) parametricObjects.append(vtk.vtkParametricTorus()) parametricObjects.append(vtk.vtkParametricSpline()) # Add some points to the parametric spline. inputPoints = vtk.vtkPoints() vtk.vtkMath.RandomSeed(8775070) for i in range(10): x = vtk.vtkMath.Random(0.0,1.0) y = vtk.vtkMath.Random(0.0,1.0) z = vtk.vtkMath.Random(0.0,1.0) inputPoints.InsertNextPoint(x, y, z) parametricObjects[-1].SetPoints(inputPoints) # There are only 15 objects. parametricFunctionSources = list() renderers = list() mappers = list() actors = list() textmappers = list() textactors = list() # Create a common text property. textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(10) textProperty.SetJustificationToCentered() # Create a parametric function source, renderer, mapper # and actor for each object. for idx, item in enumerate(parametricObjects): parametricFunctionSources.append(vtk.vtkParametricFunctionSource()) parametricFunctionSources[idx].SetParametricFunction(item) parametricFunctionSources[idx].Update() mappers.append(vtk.vtkPolyDataMapper()) mappers[idx].SetInputConnection(parametricFunctionSources[idx].GetOutputPort()) actors.append(vtk.vtkActor()) actors[idx].SetMapper(mappers[idx]) textmappers.append(vtk.vtkTextMapper()) textmappers[idx].SetInput(item.GetClassName()) textmappers[idx].SetTextProperty(textProperty) textactors.append(vtk.vtkActor2D()) textactors[idx].SetMapper(textmappers[idx]) textactors[idx].SetPosition(100, 16) renderers.append(vtk.vtkRenderer()) gridDimensions = 4 for idx in range(len(parametricObjects)): if idx < gridDimensions * gridDimensions: renderers.append(vtk.vtkRenderer) rendererSize = 200 # Create the RenderWindow # renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(rendererSize * gridDimensions, rendererSize * gridDimensions) # Add and position the renders to the render window. viewport = list() for row in range(gridDimensions): for col in range(gridDimensions): idx = row * gridDimensions + col viewport[:] = [] viewport.append(float(col) * rendererSize / (gridDimensions * rendererSize)) viewport.append(float(gridDimensions - (row+1)) * rendererSize / (gridDimensions * rendererSize)) viewport.append(float(col+1)*rendererSize / (gridDimensions * rendererSize)) viewport.append(float(gridDimensions - row) * rendererSize / (gridDimensions * rendererSize)) if idx > (len(parametricObjects) - 1): continue renderers[idx].SetViewport(viewport) renderWindow.AddRenderer(renderers[idx]) renderers[idx].AddActor(actors[idx]) renderers[idx].AddActor(textactors[idx]) renderers[idx].SetBackground(0.2,0.3,0.4) renderers[idx].ResetCamera() renderers[idx].GetActiveCamera().Azimuth(30) renderers[idx].GetActiveCamera().Elevation(-30) renderers[idx].GetActiveCamera().Zoom(0.9) renderers[idx].ResetCameraClippingRange() interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
from vtkAtamai.WindowLevelLabel import WindowLevelLabel as oldWindowLevelLabel from vtkAtamai.Label import Label import vtk # # Enhanced WindowLevelLabel Widget # - Adds Get/Set Opacity functions # - Adds Command/Observer pattern hooks # - Adds highlight capability if 'FreeType' in vtk.vtkTextMapper().GetClassName(): _FS = 18 else: _FS = 14 class WindowLevelLabel(oldWindowLevelLabel): def __init__( self, parent=None, x=0, y=0, width=100, height=27, fontsize=_FS, **kw): kw["height"] = height kw["width"] = width kw["x"] = x kw["y"] = y kw["fontsize"] = fontsize kw["font"] = "arial" kw["text"] = "W/L" apply(Label.__init__, (self, parent), kw)
# We create the render window which will show up on the screen # We put our renderer into the render window using AddRenderer. # Do not set the size of the window here. renWin = vtk.vtkRenderWindow() ren = vtk.vtkRenderer() ren.SetBackground(bg_color) renWin.AddRenderer(ren) # We create text actors for each font family and several combinations # of bold, italic and shadowed style. text_actors = [] for family in ("Arial", "Courier", "Times"): for (bold, italic, shadow) in ((0, 0, 0), (0, 0, 1), (1, 0, 0), (0, 1, 0), (1, 1, 0)): mapper = vtk.vtkTextMapper() attribs = [] if bold: attribs.append("b") if italic: attribs.append("i") if shadow: attribs.append("s") face_name = family if len(attribs): face_name = face_name + "(" + \ string.join(attribs, ",") + ")" mapper.SetInput(face_name + ": " + default_text) tprop = mapper.GetTextProperty()
def __init__(self, parent = None): super(VTKFrame, self).__init__(parent) self.vtkWidget = QVTKRenderWindowInteractor(self) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() vl = QtGui.QVBoxLayout(self) vl.addWidget(self.vtkWidget) vl.setContentsMargins(0, 0, 0, 0) # Create source # Each face has a different cell scalar # So create a lookup table with a different colour # for each face. lut = vtk.vtkLookupTable() lut.SetNumberOfTableValues(20) lut.SetTableRange(0.0, 19.0) lut.Build() lut.SetTableValue(0, 0, 0, 0) lut.SetTableValue(1, 0, 0, 1) lut.SetTableValue(2, 0, 1, 0) lut.SetTableValue(3, 0, 1, 1) lut.SetTableValue(4, 1, 0, 0) lut.SetTableValue(5, 1, 0, 1) lut.SetTableValue(6, 1, 1, 0) lut.SetTableValue(7, 1, 1, 1) lut.SetTableValue(8, 0.7, 0.7, 0.7) lut.SetTableValue(9, 0, 0, 0.7) lut.SetTableValue(10, 0, 0.7, 0) lut.SetTableValue(11, 0, 0.7, 0.7) lut.SetTableValue(12, 0.7, 0, 0) lut.SetTableValue(13, 0.7, 0, 0.7) lut.SetTableValue(14, 0.7, 0.7, 0) lut.SetTableValue(15, 0, 0, 0.4) lut.SetTableValue(16, 0, 0.4, 0) lut.SetTableValue(17, 0, 0.4, 0.4) lut.SetTableValue(18, 0.4, 0, 0) lut.SetTableValue(19, 0.4, 0, 0.4) platonicSolids = list() # There are five Platonic solids. platonicSolids.append(vtk.vtkPlatonicSolidSource()) platonicSolids.append(vtk.vtkPlatonicSolidSource()) platonicSolids.append(vtk.vtkPlatonicSolidSource()) platonicSolids.append(vtk.vtkPlatonicSolidSource()) platonicSolids.append(vtk.vtkPlatonicSolidSource()) # Specify the Platonic Solid to create. for idx, item in enumerate(platonicSolids): platonicSolids[idx].SetSolidType(idx) names = ["Tetrahedron","Cube","Octahedron","Icosahedron", "Dodecahedron"] renderers = list() mappers = list() actors = list() textmappers = list() textactors = list() # Create a common text property. textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(10) textProperty.SetJustificationToCentered() # Create a parametric function source, renderer, mapper # and actor for each object. for idx, item in enumerate(platonicSolids): platonicSolids[idx].Update() mappers.append(vtk.vtkPolyDataMapper()) mappers[idx].SetInputConnection(platonicSolids[idx].GetOutputPort()) mappers[idx].SetLookupTable(lut) mappers[idx].SetScalarRange(0, 20) actors.append(vtk.vtkActor()) actors[idx].SetMapper(mappers[idx]) textmappers.append(vtk.vtkTextMapper()) textmappers[idx].SetInput(names[idx]) textmappers[idx].SetTextProperty(textProperty) textactors.append(vtk.vtkActor2D()) textactors[idx].SetMapper(textmappers[idx]) textactors[idx].SetPosition(120, 16) renderers.append(vtk.vtkRenderer()) rowDimensions = 3 colDimensions = 2 for idx in range(rowDimensions * colDimensions): if idx >= len(platonicSolids): renderers.append(vtk.vtkRenderer) rendererSize = 300 # Setup the RenderWindow self.vtkWidget.GetRenderWindow().SetSize(rendererSize * rowDimensions / colDimensions, rendererSize * colDimensions ) # Add and position the renders to the render window. viewport = list() idx = -1 for row in range(rowDimensions): for col in range(colDimensions): idx += 1 viewport[:] = [] viewport.append(float(col) * rendererSize / (colDimensions * rendererSize)) viewport.append(float(rowDimensions - (row+1)) * rendererSize / (rowDimensions * rendererSize)) viewport.append(float(col+1)*rendererSize / (colDimensions * rendererSize)) viewport.append(float(rowDimensions - row) * rendererSize / (rowDimensions * rendererSize)) if idx > (len(platonicSolids) - 1): continue renderers[idx].SetViewport(viewport) self.vtkWidget.GetRenderWindow().AddRenderer(renderers[idx]) renderers[idx].AddActor(actors[idx]) renderers[idx].AddActor(textactors[idx]) renderers[idx].SetBackground(0.4,0.3,0.2) self._initialized = False
def main(): colors = vtk.vtkNamedColors() # Set the background color. colors.SetColor("BkgColor", [51, 77, 102, 255]) # Create container to hold the 3D object generators (sources) geometricObjectSources = list() # Populate the container with the various object sources to be demonstrated geometricObjectSources.append(vtk.vtkArrowSource()) geometricObjectSources.append(vtk.vtkConeSource()) geometricObjectSources.append(vtk.vtkCubeSource()) geometricObjectSources.append(vtk.vtkCylinderSource()) geometricObjectSources.append(vtk.vtkDiskSource()) geometricObjectSources.append(vtk.vtkLineSource()) geometricObjectSources.append(vtk.vtkRegularPolygonSource()) geometricObjectSources.append(vtk.vtkSphereSource()) # Create containers for the remaining nodes of each pipeline mappers = list() actors = list() textmappers = list() textactors = list() # Create a common text property. textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(16) textProperty.SetJustificationToCentered() # Create a mapper and actor for each object and the corresponding text label for i in range(0, len(geometricObjectSources)): geometricObjectSources[i].Update() mappers.append(vtk.vtkPolyDataMapper()) mappers[i].SetInputConnection(geometricObjectSources[i].GetOutputPort()) actors.append(vtk.vtkActor()) actors[i].SetMapper(mappers[i]) actors[i].GetProperty().SetColor( colors.GetColor3d("Seashell")) textmappers.append(vtk.vtkTextMapper()) textmappers[i].SetInput( geometricObjectSources[i].GetClassName()) # set text label to the name of the object source textmappers[i].SetTextProperty(textProperty) textactors.append(vtk.vtkActor2D()) textactors[i].SetMapper(textmappers[i]) textactors[i].SetPosition(120, 16) # Note: the position of an Actor2D is specified in display coordinates # Define size of the grid that will hold the objects gridCols = 3 gridRows = 3 # Define side length (in pixels) of each renderer square rendererSize = 300 renderWindow = vtk.vtkRenderWindow() renderWindow.SetWindowName("Geometric Objects Demo") renderWindow.SetSize(rendererSize * gridCols, rendererSize * gridRows) # Set up a grid of viewports for each renderer for row in range(0, gridRows): for col in range(0, gridCols): index = row * gridCols + col # Create a renderer for this grid cell renderer = vtk.vtkRenderer() renderer.SetBackground(colors.GetColor3d("BkgColor")) # Set the renderer's viewport dimensions (xmin, ymin, xmax, ymax) within the render window. # Note that for the Y values, we need to subtract the row index from gridRows # because the viewport Y axis points upwards, but we want to draw the grid from top to down viewport = [ float(col) / gridCols, float(gridRows - row - 1) / gridRows, float(col + 1) / gridCols, float(gridRows - row) / gridRows ] renderer.SetViewport(viewport) # Add the corresponding actor and label for this grid cell, if they exist if index < len(geometricObjectSources): renderer.AddActor(actors[index]) renderer.AddActor(textactors[index]) renderer.ResetCameraClippingRange() renderWindow.AddRenderer(renderer) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
See Also: Widget Public Methods: SetCursor(*cursor*) -- set the cursor to read the position of SetTransform(*transform*) -- set a transform to apply before printing the coordinates """ from vtkAtamai.Label import * import vtk if "FreeType" in vtk.vtkTextMapper().GetClassName(): _FS = 18 else: _FS = 14 class CoordinateLabel(Label): def __init__( self, parent=None, x=0, y=0, width=280, height=27, fontsize=_FS, **kw): kw["height"] = height kw["width"] = width kw["x"] = x kw["y"] = y
def GeometricObjects(self): GeometricObjects = list() GeometricObjects.append(vtk.vtkArrowSource()) GeometricObjects.append(vtk.vtkConeSource()) GeometricObjects.append(vtk.vtkCubeSource()) GeometricObjects.append(vtk.vtkCylinderSource()) GeometricObjects.append(vtk.vtkDiskSource()) GeometricObjects.append(vtk.vtkLineSource()) GeometricObjects.append(vtk.vtkRegularPolygonSource()) GeometricObjects.append(vtk.vtkSphereSource()) renderers = list() mappers = list() actors = list() textmappers = list() textactors = list() # Create a common text property. textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(10) textProperty.SetJustificationToCentered() # Create a parametric function source, renderer, mapper # and actor for each object. for idx, item in enumerate(GeometricObjects): GeometricObjects[idx].Update() mappers.append(vtk.vtkPolyDataMapper()) mappers[idx].SetInputConnection(GeometricObjects[idx].GetOutputPort()) actors.append(vtk.vtkActor()) actors[idx].SetMapper(mappers[idx]) textmappers.append(vtk.vtkTextMapper()) textmappers[idx].SetInput(item.GetClassName()) textmappers[idx].SetTextProperty(textProperty) textactors.append(vtk.vtkActor2D()) textactors[idx].SetMapper(textmappers[idx]) textactors[idx].SetPosition(150, 16) renderers.append(vtk.vtkRenderer()) gridDimensions = 3 for idx in range(len(GeometricObjects)): if idx < gridDimensions * gridDimensions: renderers.append(vtk.vtkRenderer) rendererSize = 300 # Create the RenderWindow # renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(rendererSize * gridDimensions, rendererSize * gridDimensions) # Add and position the renders to the render window. viewport = list() for row in range(gridDimensions): for col in range(gridDimensions): idx = row * gridDimensions + col viewport[:] = [] viewport.append(float(col) * rendererSize / (gridDimensions * rendererSize)) viewport.append(float(gridDimensions - (row+1)) * rendererSize / (gridDimensions * rendererSize)) viewport.append(float(col+1)*rendererSize / (gridDimensions * rendererSize)) viewport.append(float(gridDimensions - row) * rendererSize / (gridDimensions * rendererSize)) if idx > (len(GeometricObjects) - 1): continue renderers[idx].SetViewport(viewport) renderWindow.AddRenderer(renderers[idx]) renderers[idx].AddActor(actors[idx]) renderers[idx].AddActor(textactors[idx]) renderers[idx].SetBackground(0.4,0.3,0.2) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
def DisplayBodies(): titles = list() textMappers = list() textActors = list() uGrids = list() mappers = list() actors = list() renderers = list() uGrids.append(MakeHexagonalPrism()) titles.append('Hexagonal Prism') uGrids.append(MakeHexahedron()) titles.append('Hexahedron') uGrids.append(MakePentagonalPrism()) titles.append('Pentagonal Prism') uGrids.append(MakePolyhedron()) titles.append('Polyhedron') uGrids.append(MakePyramid()) titles.append('Pyramid') uGrids.append(MakeTetrahedron()) titles.append('Tetrahedron') uGrids.append(MakeVoxel()) titles.append('Voxel') uGrids.append(MakeWedge()) titles.append('Wedge') renWin = vtk.vtkRenderWindow() renWin.SetSize(600, 600) renWin.SetWindowName('Cell3D Demonstration') iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) # Create one text property for all textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(10) textProperty.SetJustificationToCentered() # Create and link the mappers actors and renderers together. for i in range(0, len(uGrids)): textMappers.append(vtk.vtkTextMapper()) textActors.append(vtk.vtkActor2D()) mappers.append(vtk.vtkDataSetMapper()) actors.append(vtk.vtkActor()) renderers.append(vtk.vtkRenderer()) mappers[i].SetInputData(uGrids[i]) actors[i].SetMapper(mappers[i]) renderers[i].AddViewProp(actors[i]) textMappers[i].SetInput(titles[i]) textActors[i].SetMapper(textMappers[i]) textActors[i].SetPosition(50, 10) renderers[i].AddViewProp(textActors[i]) renWin.AddRenderer(renderers[i]) gridDimensions = 3 rendererSize = 200 renWin.SetSize(rendererSize * gridDimensions, rendererSize * gridDimensions) for row in range(0, gridDimensions): for col in range(0, gridDimensions): index = row * gridDimensions + col # (xmin, ymin, xmax, ymax) viewport = [ float(col) * rendererSize / (gridDimensions * rendererSize), float(gridDimensions - (row + 1)) * rendererSize / (gridDimensions * rendererSize), float(col + 1) * rendererSize / (gridDimensions * rendererSize), float(gridDimensions - row) * rendererSize / (gridDimensions * rendererSize)] if index > len(actors) - 1: # Add a renderer even if there is no actor. # This makes the render window background all the same color. ren = vtk.vtkRenderer() ren.SetBackground(.2, .3, .4) ren.SetViewport(viewport) renWin.AddRenderer(ren) continue renderers[index].SetViewport(viewport) renderers[index].SetBackground(.2, .3, .4) renderers[index].ResetCamera() renderers[index].GetActiveCamera().Azimuth(30) renderers[index].GetActiveCamera().Elevation(-30) renderers[index].GetActiveCamera().Zoom(0.85) renderers[index].ResetCameraClippingRange() iRen.Initialize() renWin.Render() return iRen
# single line mapper. Let's create a common text property object singleLineTextProp = vtk.vtkTextProperty() singleLineTextProp.SetFontSize(font_size) singleLineTextProp.SetFontFamilyToArial() singleLineTextProp.BoldOff() singleLineTextProp.ItalicOff() singleLineTextProp.ShadowOff() # The font and text properties (except justification) are the same for each # multi line mapper. Let's create a common text property object multiLineTextProp = vtk.vtkTextProperty() multiLineTextProp.ShallowCopy(singleLineTextProp) multiLineTextProp.BoldOn() multiLineTextProp.ItalicOn() multiLineTextProp.ShadowOn() # The text is on a single line and bottom-justified. singleLineTextB = vtk.vtkTextMapper() singleLineTextB.SetInput("Single line (bottom)") tprop = singleLineTextB.GetTextProperty() tprop.ShallowCopy(singleLineTextProp) tprop.SetVerticalJustificationToBottom() tprop.SetColor(1,0,0) singleLineTextActorB = vtk.vtkActor2D() singleLineTextActorB.SetMapper(singleLineTextB) singleLineTextActorB.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay() singleLineTextActorB.GetPositionCoordinate().SetValue(0.05,0.85) # The text is on a single line and center-justified (vertical justification). singleLineTextC = vtk.vtkTextMapper() singleLineTextC.SetInput("Single line (centered)") tprop = singleLineTextC.GetTextProperty() tprop.ShallowCopy(singleLineTextProp) tprop.SetVerticalJustificationToCentered()
SetInput(*image*) -- set the vtkImageData to get the value of SetInterpolate(*i*) -- set interpolation on/off (default: on) GetInterpolate() -- is interpolation on SetShift(*shift*) -- add this offset to the image values SetScale(*scale*) -- use this scale factor with the image values """ from vtkAtamai.Label import * import vtk if "FreeType" in vtk.vtkTextMapper().GetClassName(): _FS = 18 else: _FS = 14 class IntensityLabel(Label): def __init__( self, parent=None, x=0, y=0, width=100, height=27, fontsize=_FS, **kw): kw["height"] = height kw["width"] = width kw["x"] = x kw["y"] = y
liverFilter.SetValue(0, 255.0) liverMapper = vtk.vtkPolyDataMapper() liverMapper.SetInputConnection(liverFilter.GetOutputPort()) liverMapper.SetScalarRange(0.0, 255.0) lut = vtk.vtkLookupTable() liverMapper.SetLookupTable(lut) lut.SetHueRange(0.10, 0.10) lut.Build() liverActor = vtk.vtkActor() liverActor.SetMapper(liverMapper) #Info Text 1 showInfoText = vtk.vtkTextMapper() showInfoText.SetInput( "Press the following keys to move the planes\nNormal to X: G ; B \nNormal to Y: H ; N\nNormal to Z: J ; M" ) tprop = showInfoText.GetTextProperty() tprop.SetFontSize(14) tprop.SetJustificationToCentered() tprop.SetVerticalJustificationToBottom() tprop.SetColor(1, 1, 1) showInfoTextActor = vtk.vtkActor2D() showInfoTextActor.SetMapper(showInfoText) showInfoTextActor.GetPositionCoordinate( ).SetCoordinateSystemToNormalizedDisplay() showInfoTextActor.GetPositionCoordinate().SetValue(0.5, 0.01)
def testFreetypeTextMapper(self): currentFontSize = 16 defaultText = "ABCDEFGHIJKLMnopqrstuvwxyz 0123456789 !@#$%()-=_+{};:,./<>?" textColor = [246, 255, 11] bgColor = [56, 56, 154] for i in range(0, len(textColor)): textColor[i] /= 255.0 bgColor[i] /= 255.0 renWin = vtk.vtkRenderWindow() renWin.SetSize(790, 350) ren = vtk.vtkRenderer() ren.SetBackground(bgColor) renWin.AddRenderer(ren) families = ["Arial", "Courier", "Times"] attributes = [[0, 0, 0], [0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 1, 0]] # bold, italic, shadow def SetAttributesText(attrib): """ Expects a list of attributes of size 3, returns a string """ s = "" if attrib[0] != 0: s += "b" if attrib[1] != 0: s += "i" if attrib[2] != 0: s += "s" return ','.join(list(s)) mapper = dict() actor = dict() pos = 0 for i, family in enumerate(families): for j, attrib in enumerate(attributes): pos += 1 txt = "" txtAttrib = SetAttributesText(attrib) if len(txtAttrib) != 0: txt = family + " (" + SetAttributesText( attrib) + "): " + defaultText else: txt = family + ": " + defaultText idx = ''.join(map(str, [i, j])) mapper.update({idx: vtk.vtkTextMapper()}) mapper[idx].SetInput(txt) tprop = mapper[idx].GetTextProperty() eval('tprop.SetFontFamilyTo' + family + '()') tprop.SetColor(textColor) tprop.SetBold(attrib[0]) tprop.SetItalic(attrib[1]) tprop.SetShadow(attrib[2]) tprop.SetFontSize(currentFontSize) actor.update({idx: vtk.vtkActor2D()}) actor[idx].SetMapper(mapper[idx]) actor[idx].SetDisplayPosition(10, pos * (currentFontSize + 5)) ren.AddActor(actor[idx]) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) renWin.Render() img_file = "TestFreetypeTextMapper.png" vtk.test.Testing.compareImage( iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def _CreateButton(self): borderwidth = self._Config['borderwidth'] width, height = self._DisplaySize x, y = self._DisplayOrigin x0, y0 = self._Renderer.GetOrigin() self._Points = vtk.vtkPoints() self._SetPoints() cells = vtk.vtkCellArray() cells.InsertNextCell(4) cells.InsertCellPoint(1) cells.InsertCellPoint(3) cells.InsertCellPoint(5) cells.InsertCellPoint(7) if borderwidth > 0: cells.InsertNextCell(4) cells.InsertCellPoint(0) cells.InsertCellPoint(1) cells.InsertCellPoint(3) cells.InsertCellPoint(2) cells.InsertNextCell(4) cells.InsertCellPoint(2) cells.InsertCellPoint(3) cells.InsertCellPoint(5) cells.InsertCellPoint(4) cells.InsertNextCell(4) cells.InsertCellPoint(4) cells.InsertCellPoint(5) cells.InsertCellPoint(7) cells.InsertCellPoint(6) cells.InsertNextCell(4) cells.InsertCellPoint(6) cells.InsertCellPoint(7) cells.InsertCellPoint(1) cells.InsertCellPoint(0) scalars = vtk.vtkUnsignedCharArray() scalars.InsertTuple1(0, 0) scalars.InsertTuple1(1, 2) scalars.InsertTuple1(2, 2) scalars.InsertTuple1(3, 3) scalars.InsertTuple1(4, 3) data = vtk.vtkPolyData() data.SetPoints(self._Points) data.SetPolys(cells) data.GetCellData().SetScalars(scalars) mapper = vtk.vtkPolyDataMapper2D() mapper.SetInput(data) mapper.SetLookupTable(self._LookupTable) mapper.SetColorModeToMapScalars() mapper.SetScalarRange(0, 3) actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.SetPosition(x - x0, y - y0) self._Scalars = scalars self._Actors.append(actor) if self._Renderer: self._Renderer.AddActor2D(actor) mapper = vtk.vtkTextMapper() mapper.SetInput(self._Config['text']) try: property = mapper.GetTextProperty() except AttributeError: property = mapper property.SetFontSize(self._Config['fontsize']) if self._Config['font'] in ('courier', 'Courier'): property.SetFontFamilyToCourier() elif self._Config['font'] in ('arial', 'Arial'): property.SetFontFamilyToArial() elif self._Config['font'] in ('times', 'Times'): property.SetFontFamilyToTimes() property.SetJustificationToCentered() property.SetVerticalJustificationToCentered() property.BoldOn() self._TextMapper = mapper actor = vtk.vtkActor2D() actor.GetProperty().SetColor(*self._Config['foreground']) actor.SetMapper(mapper) if "FreeType" in mapper.GetClassName(): actor.SetPosition(x + old_div(width, 2) - x0, y + old_div(height, 2) - y0) else: # not a FreeType font, needs position correction actor.SetPosition(x + old_div(width, 2) - x0 + 1, y + old_div(height, 2) - y0 + 1) self._Actors.append(actor) if self._Renderer: self._Renderer.AddActor2D(actor)
def CurvaturesDemo(self): # We are going to handle two different sources. # The first source is a superquadric source. torus = vtk.vtkSuperquadricSource() torus.SetCenter(0.0, 0.0, 0.0) torus.SetScale(1.0, 1.0, 1.0) torus.SetPhiResolution(64) torus.SetThetaResolution(64) torus.SetThetaRoundness(1) torus.SetThickness(0.5) torus.SetSize(0.5) torus.SetToroidal(1) # Rotate the torus towards the observer (around the x-axis) torusT = vtk.vtkTransform() torusT.RotateX(55) torusTF = vtk.vtkTransformFilter() torusTF.SetInputConnection(torus.GetOutputPort()) torusTF.SetTransform(torusT) # The quadric is made of strips, so pass it through a triangle filter as # the curvature filter only operates on polys tri = vtk.vtkTriangleFilter() tri.SetInputConnection(torusTF.GetOutputPort()) # The quadric has nasty discontinuities from the way the edges are generated # so let's pass it though a CleanPolyDataFilter and merge any points which # are coincident, or very close cleaner = vtk.vtkCleanPolyData() cleaner.SetInputConnection(tri.GetOutputPort()) cleaner.SetTolerance(0.005) # The next source will be a parametric function rh = vtk.vtkParametricRandomHills() rhFnSrc = vtk.vtkParametricFunctionSource() rhFnSrc.SetParametricFunction(rh) # Now we have the sources, lets put them into a list. sources = list() sources.append(cleaner) sources.append(cleaner) sources.append(rhFnSrc) sources.append(rhFnSrc) # Colour transfer function. ctf = vtk.vtkColorTransferFunction() ctf.SetColorSpaceToDiverging() ctf.AddRGBPoint(0.0, 0.230, 0.299, 0.754) ctf.AddRGBPoint(1.0, 0.706, 0.016, 0.150) cc = list() for i in range(256): cc.append(ctf.GetColor(float(i) / 255.0)) # Lookup table. lut = list() for idx in range(len(sources)): lut.append(vtk.vtkLookupTable()) lut[idx].SetNumberOfColors(256) for i, item in enumerate(cc): lut[idx].SetTableValue(i, item[0], item[1], item[2], 1.0) if idx == 0: lut[idx].SetRange(-10, 10) if idx == 1: lut[idx].SetRange(0, 4) if idx == 2: lut[idx].SetRange(-1, 1) if idx == 3: lut[idx].SetRange(-1, 1) lut[idx].Build() curvatures = list() for idx in range(len(sources)): curvatures.append(vtk.vtkCurvatures()) if idx % 2 == 0: curvatures[idx].SetCurvatureTypeToGaussian() else: curvatures[idx].SetCurvatureTypeToMean() renderers = list() mappers = list() actors = list() textmappers = list() textactors = list() # Create a common text property. textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(10) textProperty.SetJustificationToCentered() names = [ 'Torus - Gaussian Curvature', 'Torus - Mean Curvature', 'Random Hills - Gaussian Curvature', 'Random Hills - Mean Curvature' ] # Link the pipeline together. for idx, item in enumerate(sources): sources[idx].Update() curvatures[idx].SetInputConnection(sources[idx].GetOutputPort()) mappers.append(vtk.vtkPolyDataMapper()) mappers[idx].SetInputConnection(curvatures[idx].GetOutputPort()) mappers[idx].SetLookupTable(lut[idx]) mappers[idx].SetUseLookupTableScalarRange(1) actors.append(vtk.vtkActor()) actors[idx].SetMapper(mappers[idx]) textmappers.append(vtk.vtkTextMapper()) textmappers[idx].SetInput(names[idx]) textmappers[idx].SetTextProperty(textProperty) textactors.append(vtk.vtkActor2D()) textactors[idx].SetMapper(textmappers[idx]) textactors[idx].SetPosition(150, 16) renderers.append(vtk.vtkRenderer()) gridDimensions = 2 for idx in range(len(sources)): if idx < gridDimensions * gridDimensions: renderers.append(vtk.vtkRenderer) rendererSize = 300 # Create the RenderWindow # renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(rendererSize * gridDimensions, rendererSize * gridDimensions) # Add and position the renders to the render window. viewport = list() for row in range(gridDimensions): for col in range(gridDimensions): idx = row * gridDimensions + col viewport[:] = [] viewport.append( float(col) * rendererSize / (gridDimensions * rendererSize)) viewport.append( float(gridDimensions - (row + 1)) * rendererSize / (gridDimensions * rendererSize)) viewport.append( float(col + 1) * rendererSize / (gridDimensions * rendererSize)) viewport.append( float(gridDimensions - row) * rendererSize / (gridDimensions * rendererSize)) if idx > (len(sources) - 1): continue renderers[idx].SetViewport(viewport) renderWindow.AddRenderer(renderers[idx]) renderers[idx].AddActor(actors[idx]) renderers[idx].AddActor(textactors[idx]) renderers[idx].SetBackground(0.4, 0.3, 0.2) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
liverFilter.SetValue(0, 255.0) liverMapper = vtk.vtkPolyDataMapper() liverMapper.SetInputConnection(liverFilter.GetOutputPort()) liverMapper.SetScalarRange(0.0, 255.0) lut = vtk.vtkLookupTable() liverMapper.SetLookupTable(lut) lut.SetHueRange(0.10,0.10) lut.Build() liverActor = vtk.vtkActor() liverActor.SetMapper(liverMapper) #Info Text 1 showInfoText = vtk.vtkTextMapper() showInfoText.SetInput("Press the following keys to move the planes\nNormal to X: G ; B \nNormal to Y: H ; N\nNormal to Z: J ; M") tprop = showInfoText.GetTextProperty() tprop.SetFontSize(14) tprop.SetJustificationToCentered() tprop.SetVerticalJustificationToBottom() tprop.SetColor(1, 1, 1) showInfoTextActor = vtk.vtkActor2D() showInfoTextActor.SetMapper(showInfoText) showInfoTextActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay() showInfoTextActor.GetPositionCoordinate().SetValue(0.5, 0.01) #Info Text 2 showInfoText2 = vtk.vtkTextMapper() showInfoText2.SetInput("Toggle MPR: K\nToggle Individual Planes: 6 ; 7 ; 8\nToggle Segmentation: L")
def main(): colors = vtk.vtkNamedColors() colors.SetColor("BkgColor", [26, 51, 102, 255]) parametricObjects = list() parametricObjects.append(vtk.vtkParametricBohemianDome()) parametricObjects[-1].SetA(5.0) parametricObjects[-1].SetB(1.0) parametricObjects[-1].SetC(2.0) parametricObjects.append(vtk.vtkParametricBour()) parametricObjects.append(vtk.vtkParametricCatalanMinimal()) parametricObjects.append(vtk.vtkParametricHenneberg()) parametricObjects.append(vtk.vtkParametricKuen()) parametricObjects.append(vtk.vtkParametricPluckerConoid()) parametricObjects.append(vtk.vtkParametricPseudosphere()) parametricFunctionSources = list() renderers = list() mappers = list() actors = list() textmappers = list() textactors = list() # Create one text property for all textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(12) textProperty.SetJustificationToCentered() backProperty = vtk.vtkProperty() backProperty.SetColor(colors.GetColor3d("Tomato")) # Create a parametric function source, renderer, mapper, and actor # for each object for i in range(0, len(parametricObjects)): parametricFunctionSources.append( vtk.vtkParametricFunctionSource()) parametricFunctionSources[i].SetParametricFunction(parametricObjects[i]) parametricFunctionSources[i].Update() mappers.append(vtk.vtkPolyDataMapper()) mappers[i].SetInputConnection( parametricFunctionSources[i].GetOutputPort()) actors.append(vtk.vtkActor()) actors[i].SetMapper(mappers[i]) actors[i].GetProperty().SetColor(colors.GetColor3d("Banana")) actors[i].GetProperty().SetSpecular(.5) actors[i].GetProperty().SetSpecularPower(20) actors[i].SetBackfaceProperty(backProperty) textmappers.append(vtk.vtkTextMapper()) textmappers[i].SetInput(parametricObjects[i].GetClassName()) textmappers[i].SetTextProperty(textProperty) textactors.append(vtk.vtkActor2D()) textactors[i].SetMapper(textmappers[i]) textactors[i].SetPosition(100, 16) renderers.append(vtk.vtkRenderer()) renderers[i].AddActor(actors[i]) renderers[i].AddActor(textactors[i]) renderers[i].SetBackground(colors.GetColor3d("BkgColor")) # Setup the viewports xGridDimensions = 4 yGridDimensions = 2 rendererSize = 200 renderWindow = vtk.vtkRenderWindow() renderWindow.SetWindowName("Parametric Objects Demonstration2") renderWindow.SetSize(rendererSize * xGridDimensions, rendererSize * yGridDimensions) for row in range(0, yGridDimensions): for col in range(0, xGridDimensions): index = row * xGridDimensions + col # (xmin, ymin, xmax, ymax) viewport = [float(col) / xGridDimensions, float(yGridDimensions - (row + 1)) / yGridDimensions, float(col + 1) / xGridDimensions, float(yGridDimensions - row) / yGridDimensions] if index > (len(actors) - 1): # Add a renderer even if there is no actor. # This makes the render window background all the same color. ren = vtk.vtkRenderer() ren.SetBackground(colors.GetColor3d("BkgColor")) ren.SetViewport(viewport) renderWindow.AddRenderer(ren) continue renderers[index].SetViewport(viewport) renderers[index].ResetCamera() renderers[index].GetActiveCamera().Azimuth(30) renderers[index].GetActiveCamera().Elevation(-30) renderers[index].GetActiveCamera().Zoom(0.9) renderers[index].ResetCameraClippingRange() renderWindow.AddRenderer(renderers[index]) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
def BindTkImageViewer(self): imager = self._ImageViewer.GetRenderer() # stuff for window level text. mapper = vtk.vtkTextMapper() mapper.SetInput("none") t_prop = mapper.GetTextProperty() t_prop.SetFontFamilyToTimes() t_prop.SetFontSize(18) t_prop.BoldOn() t_prop.ShadowOn() self._LevelMapper = mapper actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.SetLayerNumber(1) actor.GetPositionCoordinate().SetValue(4,22) actor.GetProperty().SetColor(1,1,0.5) actor.SetVisibility(0) imager.AddActor2D(actor) self._LevelActor = actor mapper = vtk.vtkTextMapper() mapper.SetInput("none") t_prop = mapper.GetTextProperty() t_prop.SetFontFamilyToTimes() t_prop.SetFontSize(18) t_prop.BoldOn() t_prop.ShadowOn() self._WindowMapper = mapper actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.SetLayerNumber(1) actor.GetPositionCoordinate().SetValue(4,4) actor.GetProperty().SetColor(1,1,0.5) actor.SetVisibility(0) imager.AddActor2D(actor) self._WindowActor = actor self._LastX = 0 self._LastY = 0 self._OldFocus = 0 self._InExpose = 0 # bindings # window level self.bind("<ButtonPress-1>", lambda e,s=self: s.StartWindowLevelInteraction(e.x,e.y)) self.bind("<B1-Motion>", lambda e,s=self: s.UpdateWindowLevelInteraction(e.x,e.y)) self.bind("<ButtonRelease-1>", lambda e,s=self: s.EndWindowLevelInteraction()) # Get the value self.bind("<ButtonPress-3>", lambda e,s=self: s.StartQueryInteraction(e.x,e.y)) self.bind("<B3-Motion>", lambda e,s=self: s.UpdateQueryInteraction(e.x,e.y)) self.bind("<ButtonRelease-3>", lambda e,s=self: s.EndQueryInteraction()) self.bind("<Expose>", lambda e,s=self: s.ExposeTkImageViewer()) self.bind("<Enter>", lambda e,s=self: s.EnterTkViewer()) self.bind("<Leave>", lambda e,s=self: s.LeaveTkViewer()) self.bind("<KeyPress-e>", lambda e,s=self: s.quit()) self.bind("<KeyPress-r>", lambda e,s=self: s.ResetTkImageViewer())