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