def Paint(self, vtkSelf, context2D):
context2D.DrawPolyData(0.0,
0.0,
self.polydata,
self.polydata.GetCellData().GetScalars(),
vtk.VTK_SCALAR_MODE_USE_CELL_DATA)
pen = context2D.GetPen()
penColor = [0, 0, 0]
pen.GetColor(penColor)
penWidth = pen.GetWidth()
brush = context2D.GetBrush()
brushColor = [0, 0, 0, 0]
brush.GetColor(brushColor)
pen.SetColor([0, 0, 255])
brush.SetColor([0, 0, 255])
context2D.DrawWedge(0.75, 0.25, 0.125, 0.005, 30.0, 60.0)
pen.SetWidth(20.0)
pen.SetColor([0, 0, 0])
brush.SetColor([0, 0, 0])
context2D.DrawMarkers(vtk.vtkMarkerUtilities.CIRCLE, False, [0.1, 0.1, 0.5, 0.5, 0.9, 0.9], 3)
pen.SetWidth(1.0)
textProp = vtk.vtkTextProperty()
textProp.BoldOn()
textProp.ItalicOn()
textProp.SetFontSize(22)
textProp.SetColor(0.5, 0.0, 1.0)
textProp.SetOrientation(45)
context2D.ApplyTextProp(textProp)
context2D.DrawString(0.35, 0.4, "Context2D!")
pen.SetColor([200, 200, 30])
brush.SetColor([200, 200, 30])
brush.SetOpacity(128)
context2D.DrawPolygon([0.5, 0.5, 0.75, 0.0, 1.0, 0.5], 3)
pen.SetColor([133, 70, 70])
brush.SetColor([133, 70, 70])
brush.SetOpacity(255)
context2D.DrawArc(0.25, 0.75, 0.125, 0.0, 360.0)
pen.SetWidth(penWidth)
pen.SetColor(penColor)
brush.SetColor(brushColor[:3])
brush.SetOpacity(brushColor[3])
return True
def createActor( self, **args ):
if self.colorBarActor == None:
pos = args.get( 'pos', [ 0.9, 0.2 ] )
title = args.get( 'title', '' )
self.colorBarActor = vtk.vtkScalarBarActor()
# self.colorBarActor.SetMaximumWidthInPixels( 50 )
self.colorBarActor.SetNumberOfLabels(9)
labelFormat = vtk.vtkTextProperty()
labelFormat.SetFontSize( 160 )
labelFormat.SetColor( VTK_FOREGROUND_COLOR[0], VTK_FOREGROUND_COLOR[1], VTK_FOREGROUND_COLOR[2] )
titleFormat = vtk.vtkTextProperty()
titleFormat.SetFontSize( 160 )
titleFormat.SetColor( VTK_FOREGROUND_COLOR[0], VTK_FOREGROUND_COLOR[1], VTK_FOREGROUND_COLOR[2] )
# titleFormat.SetVerticalJustificationToTop ()
# titleFormat.BoldOn()
self.colorBarActor.SetPosition( pos[0], pos[1] )
self.colorBarActor.SetLabelTextProperty( labelFormat )
self.colorBarActor.SetTitleTextProperty( titleFormat )
self.colorBarActor.SetTitle( title )
self.colorBarActor.SetLookupTable( self.getDisplayLookupTable() )
self.colorBarActor.SetVisibility(0)
self.colorBarActor.SetMaximumWidthInPixels(75)
else:
self.colorBarActor.SetLookupTable( self.getDisplayLookupTable() )
self.colorBarActor.Modified()
return self.colorBarActor
def __init__(self):
# Skip the parent constructor
# super(Axes, self).__init__(renderer)
text_property_x = vtk.vtkTextProperty()
text_property_x.ItalicOn()
text_property_x.ShadowOn()
text_property_x.BoldOn()
text_property_x.SetFontFamilyToTimes()
text_property_x.SetColor(1, 0, 0)
text_property_y = vtk.vtkTextProperty()
text_property_y.ShallowCopy(text_property_x)
text_property_y.SetColor(0, 1, 0)
text_property_z = vtk.vtkTextProperty()
text_property_z.ShallowCopy(text_property_x)
text_property_z.SetColor(0, 0, 1)
self.axes = vtk.vtkAxesActor()
self.axes.SetShaftTypeToCylinder()
self.axes.SetCylinderRadius(0.05)
self.axes.SetTotalLength(3 * [1.5])
self.axes.GetXAxisCaptionActor2D().SetCaptionTextProperty(
text_property_x)
self.axes.GetYAxisCaptionActor2D().SetCaptionTextProperty(
text_property_y)
self.axes.GetZAxisCaptionActor2D().SetCaptionTextProperty(
text_property_z)
def build_axes(self, noZaxis = False):
if self.axes is None:
self.axes = vtk.vtkAxesActor()
# self.axes.SetShaftTypeToCylinder()
if not noZaxis:
self.axes.SetTotalLength( self.data.shape[0] - 1, self.data.shape[1] - 1, self.data.shape[2] - 1)
else:
self.axes.SetTotalLength( self.data.shape[0] - 1, self.data.shape[1] - 1, 0 )
self.axes.SetNormalizedShaftLength( 1, 1, 1 )
self.axes.SetNormalizedTipLength( 0, 0, 0 )
# self.axes.SetNormalizedShaftLength( 0.85, 0.85, 0.85 )
# self.axes.SetNormalizedTipLength( 0.15, 0.15, 0.15 )
self.axes.AxisLabelsOn()
self.axes.GetXAxisTipProperty().SetColor( 0, 0, 1)
self.axes.GetXAxisShaftProperty().SetColor( 0, 0, 1)
self.axes.GetXAxisShaftProperty().SetLineWidth (2)
self.axes.SetXAxisLabelText('x')
txtprop = vtk.vtkTextProperty()
txtprop.SetColor(0, 0, 0)
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(12)
txtprop.SetOpacity(0.5)
self.axes.GetXAxisCaptionActor2D().SetCaptionTextProperty(txtprop)
self.axes.GetYAxisTipProperty().SetColor( 0, 1, 0)
self.axes.GetYAxisShaftProperty().SetColor( 0, 1, 0)
self.axes.GetYAxisShaftProperty().SetLineWidth (2)
self.axes.SetYAxisLabelText('y')
txtprop = vtk.vtkTextProperty()
txtprop.SetColor(0, 0, 0)
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(12)
txtprop.SetOpacity(0.5)
self.axes.GetYAxisCaptionActor2D().SetCaptionTextProperty(txtprop)
self.axes.GetZAxisTipProperty().SetColor( 1, 0, 0 )
self.axes.GetZAxisShaftProperty().SetColor( 1, 0, 0)
self.axes.GetZAxisShaftProperty().SetLineWidth (2)
self.axes.SetZAxisLabelText('z')
txtprop = vtk.vtkTextProperty()
txtprop.SetColor(0, 0, 0)
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(12)
txtprop.SetOpacity(0.5)
self.axes.GetZAxisCaptionActor2D().SetCaptionTextProperty(txtprop)
self.renderer.AddActor(self.axes)
self.iren.Render()
else :
if self.axes.GetVisibility():
self.axes.VisibilityOff()
else:
self.axes.VisibilityOn()
self.iren.Render()
def buildLookupTable(self):
self.colorFunction = vtk.vtkColorTransferFunction()
self.colorFunction.SetColorSpaceToHSV()
self.colorFunction.HSVWrapOff()
drange = [10., 20.]
self.colorFunction.AddRGBPoint(drange[0], 0.0, 0.0, 1.0)
self.colorFunction.AddRGBPoint(drange[1], 1.0, 0.0, 0.0)
self.scalarBar.SetTitle("Title1")
self.scalarBar.SetLookupTable(self.colorFunction)
self.scalarBar.SetOrientationToVertical()
#self.scalarBar.GetLabelTextProperty().SetFontSize(8)
self.scalarBar.SetHeight(0.9)
self.scalarBar.SetWidth(0.20) # the width is set first
# after the width is set, this is adjusted
self.scalarBar.SetPosition(0.77, 0.1)
#self.scalarBar.SetPosition2(0.1, 0.3)
#print self.scalarBar.GetPosition()
propTitle = vtk.vtkTextProperty()
propTitle.SetFontFamilyToArial()
#propTitle.ItalicOff()
propTitle.BoldOn()
propTitle.ShadowOn()
propLabel = vtk.vtkTextProperty()
propLabel.BoldOff()
propLabel.ShadowOn()
#propLabel.SetFontSize(8)
scalar_range = self.grid.GetScalarRange()
self.aQuadMapper.SetScalarRange(scalar_range)
self.aQuadMapper.SetLookupTable(self.colorFunction)
#self.scalarBar.SetTitleTextProperty(propTitle);
#self.scalarBar.SetLabelTextProperty(propLabel);
self.scalarBar.SetLabelFormat("%i")
# allows 0-1 to be nice number when ranging values (gotta pick something)
self.scalarBar.SetNumberOfLabels(11)
self.scalarBar.SetMaximumNumberOfColors(11)
#self.scalarBar.VisibilityOff() # first load -> scalar bar off
#self.scalarBar.ShadowOn()
#self.scalarBar.RepositionableOn()
self.rend.AddActor(self.scalarBar)
def __init__(self):
self.IsProcessed = False
self.Interaction = True
self.ShowAnnotations = True
self.ShowDirections = True
self.AboutDataVisibility = True
self.LinkRender = True
self.LinkCameraFocalAndPosition = False
self.Renderer = None
self.RenderWindow = None
self.RenderWindowInteractor = None
self.Children = []
self.InteractorStyle = None
# Initilize Annotations
self.CornerAnnotation = vtk.vtkCornerAnnotation()
self.CornerAnnotation.SetNonlinearFontScaleFactor(0.3)
self.TextProperty = vtk.vtkTextProperty()
self.CornerAnnotation.SetTextProperty(self.TextProperty)
#self.OrientationAnnotation = vtkOrientationAnnotation()
#self.OrientationAnnotation.SetNonlinearFontScaleFactor(0.25)
#self.InteractorStyle = vtk.vtkInteractorStyleSwitch()
self.Parent = None
self.downRightAnnotation = ""
self.upLeftAnnotation = ""
self.upRightAnnotation = ""
self.downLeftAnnotation = ""
self.AboutData = ""
self.InternalMTime = 0
def __create_time_legend(self):
time_legend = vtk.vtkLegendBoxActor()
# Create legend actor
time_legend.SetNumberOfEntries(1)
time_legend.SetPosition(
self.__get_legend_position(
self.settings.time_legend_location,
self.settings.time_legend_height,
self.settings.time_legend_width,
self.settings.time_legend_offset,
)
)
time_legend.SetWidth(self.settings.time_legend_width)
time_legend.SetHeight(self.settings.time_legend_height)
tprop = vtk.vtkTextProperty()
tprop.SetColor(rgb_colors.RGB_WHITE)
tprop.SetVerticalJustificationToCentered()
time_legend.SetEntryTextProperty(tprop)
if self.settings.time_legend_border_display:
time_legend.BorderOn()
else:
time_legend.BorderOff()
return time_legend
def __init__(self, cell):
assert isinstance(cell, vtkUnitCellModule)
self.cell = cell
l0 = self.cell.get_characteristic_length()
# Create VTK axes actor (not really a VTK actor though)
self.vtk_ax = vtkAxesActor()
self.vtk_ax.SetTipTypeToCone()
self.vtk_ax.SetConeRadius(5e-2*l0)
self.vtk_ax.SetShaftTypeToCylinder()
self.vtk_ax.SetCylinderRadius(5e-3*l0)
# Create VTK two-dimensional property
p2d = vtkProperty2D()
p2d.SetDisplayLocationToBackground()
vtkModule.__init__(self, self.vtk_ax, p2d)
# Create VTK text property and apply to axes
vtk_textproperty = vtkTextProperty()
vtk_textproperty.SetFontSize(14)
vtk_textproperty.SetBold(True)
vtk_textproperty.SetItalic(True)
vtk_textproperty.SetShadow(True)
vtk_textproperty.SetJustificationToRight()
vtk_textproperty.SetVerticalJustificationToCentered()
self.set_text_property(vtk_textproperty)
def do_test(self):
prop = vtk.vtkTextProperty()
set_font("Arial", prop)
if prop.GetFontFamily() != vtk.VTK_ARIAL:
print "Font was not set to Arial"
return
set_font("Courier", prop)
if prop.GetFontFamily() != vtk.VTK_COURIER:
print "Font was not set to Courier"
return
set_font("Times", prop)
if prop.GetFontFamily() != vtk.VTK_TIMES:
print "Font was not set to Times"
return
path = os.path.abspath("blex.ttf")
set_font(path, prop)
if prop.GetFontFamily() == vtk.VTK_FONT_FILE:
if path != prop.GetFontFile():
print "Set path incorrectly"
return
else:
print "Did not set Font File correctly"
return
self.passed = 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 addT2transvisualize(self, T2images, image_pos_pat, image_ori_pat, T2dims, T2spacing, sideBreast, interact):
'''Added to build second reference frame and display T2 overlayed into T1 reference frame'''
# Proceed to build reference frame for display objects based on DICOM coords
[transformed_T2image, transform_cube] = self.dicomTransform(T2images, image_pos_pat, image_ori_pat)
#alignR = int(raw_input('\nAlign right? Yes:1 No:0 : '))
#if alignR:
if(sideBreast=="Right"):
zf1 = self.T1spacing[2]*self.T1extent[5] + self.T1origin[2]
self.T2origin[2] = zf1 - T2spacing[2]*self.T2extent[5] # this is z-span
else:
self.T2origin[2] = self.T1origin[2]
# Change info origin
translated_T2image = vtk.vtkImageChangeInformation()
translated_T2image.SetInput( transformed_T2image )
translated_T2image.SetOutputOrigin(self.T2origin)
translated_T2image.Update()
# Set up ortogonal planes
self.xImagePlaneWidget.SetInput( translated_T2image.GetOutput() )
self.xImagePlaneWidget.SetSliceIndex(0)
self.yImagePlaneWidget.SetInput( translated_T2image.GetOutput() )
self.yImagePlaneWidget.SetSliceIndex(0)
self.zImagePlaneWidget.SetInput( translated_T2image.GetOutput() )
self.zImagePlaneWidget.SetSliceIndex(0)
# Create a text property for both cube axes
tprop = vtk.vtkTextProperty()
tprop.SetColor(0.5, 0.5, 0)
tprop.ShadowOff()
# Update the reneder window to receive new image !Important*****
self.renderer1.Modified()
self.renWin1.Modified()
# Create a vtkCubeAxesActor2D. Use the outer edges of the bounding box to
# draw the axes. Add the actor to the renderer.
axesT2 = vtk.vtkCubeAxesActor2D()
axesT2.SetInput(translated_T2image.GetOutput())
axesT2.SetCamera(self.renderer1.GetActiveCamera())
axesT2.SetLabelFormat("%6.4g")
axesT2.SetFlyModeToOuterEdges()
axesT2.SetFontFactor(1.2)
axesT2.SetAxisTitleTextProperty(tprop)
axesT2.SetAxisLabelTextProperty(tprop)
self.renderer1.AddViewProp(axesT2)
### Update T2Images
t_T2images = vtk.vtkImageChangeInformation()
t_T2images.SetInput( T2images )
t_T2images.SetOutputOrigin(self.T2origin)
t_T2images.Update()
############
if(interact==True):
interactor = self.renWin1.GetInteractor()
interactor.Start()
return
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 do_test(self):
text_property = vtk.vtkTextProperty()
text_property.SetFontFamilyToArial()
text_property.SetFontSize(24)
dpi = self.win.GetDPI()
w, h = vcs.vtk_ui.text.text_dimensions("no descenders", text_property,
dpi)
if w != 174 or h != 23:
print "no descenders width/height changed (%d,%d)"%(w,h)
return
w, h = vcs.vtk_ui.text.text_dimensions("couple good descenders",
text_property, dpi)
if w != 298 or h != 23:
print "couple good descenders width/height changed (%d, %d)"%(w,h)
return
w, h = vcs.vtk_ui.text.text_dimensions(
"This one\nis on\nmultiple lines", text_property, dpi)
if w != 150 or h != 73:
print "Multi-line width/height changed (%d,%d)"%(w,h)
return
self.passed = 0
def __init__(self, interactor, text, index, dp, configurator):
self.interactor = interactor
self.text = text
self.display = dp
self.actors = dp.backend["vtk_backend_text_actors"]
self.index = index
self.configurator = configurator
for actor in self.actors:
actor.SetVisibility(0)
self.textboxes = None
self.toolbar = Toolbar(self.interactor, "Text Options")
self.toolbar.add_slider_button(
text.height,
1,
100,
"Height",
update=self.update_height)
halign = self.toolbar.add_button(
["Left Align", "Center Align", "Right Align"], action=self.halign)
valign = self.toolbar.add_button(
["Top Align", "Half Align", "Bottom Align"], action=self.valign)
halign.set_state(self.text.halign)
valign.set_state(__valign_map__[self.text.valign])
self.toolbar.add_slider_button(
text.angle,
0,
360,
"Angle",
update=self.update_angle)
self.picker = None
self.toolbar.add_button(["Change Color"], action=self.change_color)
self.toolbar.show()
prop = vtkTextProperty()
prop.SetBackgroundColor(.87, .79, .55)
prop.SetBackgroundOpacity(1)
prop.SetColor(0, 0, 0)
prop.SetVerticalJustificationToTop()
self.tooltip = Label(
self.interactor,
"%s + Click to place new text." %
("Cmd" if sys.platform == "darwin" else "Ctrl"),
textproperty=prop)
self.tooltip.left = 0
self.tooltip.top = self.interactor.GetRenderWindow(
).GetSize()[1] - self.tooltip.get_dimensions()[1]
self.tooltip.show()
super(TextEditor, self).__init__()
self.register()
self.update()
def __init__(self):
'''
Constructor
'''
self.__OrientationMatrix = vtk.vtkMatrix4x4()
self.__CornerAnnotation = vtk.vtkCornerAnnotation()
self.__TextProperty = vtk.vtkTextProperty()
self.__LookupTable = vtk.vtkLookupTable()
self.__ScalarBarActor = vtk.vtkScalarBarActor()
self.__Prop3DCollection = vtk.vtkProp3DCollection()
self.__DataSetCollection = vtk.vtkDataSetCollection()
self.__OrientationTransform = vtk.vtkMatrixToLinearTransform()
self.__OrientationMatrix.Identity()
self.__CornerAnnotation.SetNonlinearFontScaleFactor(0.30)
self.__CornerAnnotation.SetText(0, "Jolly - (c) summit 2009 ref vtkINRIA3D")
self.__CornerAnnotation.SetMaximumFontSize(46)
self.__ScalarBarActor.SetLabelTextProperty(self.__TextProperty)
self.__ScalarBarActor.GetLabelTextProperty().BoldOff()
self.__ScalarBarActor.GetLabelTextProperty().ItalicOff()
self.__ScalarBarActor.SetNumberOfLabels(3)
self.__ScalarBarActor.SetWidth(0.1)
self.__ScalarBarActor.SetHeight(0.5)
self.__ScalarBarActor.SetPosition(0.9, 0.3)
self.__LookupTable.SetTableRange(0, 1)
self.__LookupTable.SetSaturationRange(0, 0)
self.__LookupTable.SetHueRange(0, 0)
self.__LookupTable.SetValueRange(0, 1)
self.__LookupTable.Build()
self.__ShowAnnotations = True
self.__ShowScalarBar = True
self.__OrientationTransform.SetInput(self.__OrientationMatrix)
self.__WindowLevel = self.GetWindowLevel()
self.__WindowLevel.SetLookupTable( self.__LookupTable )
self.__ScalarBarActor.SetLookupTable(self.__LookupTable)
self.__Renderer = self.GetRenderer()
self.__Renderer.AddViewProp(self.__CornerAnnotation)
self.__Renderer.AddViewProp(self.__ScalarBarActor)
self.__ImageActor = self.GetImageActor()
self.__RenderWindow = self.GetRenderWindow ()
self.__InteractorStyle = self.GetInteractorStyle()
self.__Interactor = None
self.__CornerAnnotation.SetWindowLevel(self.__WindowLevel)
self.__CornerAnnotation.SetImageActor(self.__ImageActor)
self.__CornerAnnotation.ShowSliceAndImageOn()
# Sometime we would want to set the default window/level value instead
# of the ImageData's ScalarRange
self.__RefWindow = None
self.__RefLevel = None
def update(self):
if self.textboxes:
for box in self.textboxes:
box.stop_editing()
box.detach()
del self.textboxes
self.textboxes = []
renWin = self.interactor.GetRenderWindow()
w, h = renWin.GetSize()
dpi = renWin.GetDPI()
cmap = vcs.getcolormap()
prop = vtkTextProperty()
vcs.vcs2vtk.prepTextProperty(prop, (w, h), to=self.text, tt=self.text, cmap=cmap)
prop.SetOrientation(-1 * self.text.angle)
for ind, x in enumerate(self.text.x):
self.actors[ind].SetTextProperty(prop)
y = self.text.y[ind]
string = self.text.string[ind]
text_width, text_height = text_dimensions(self.text, ind, (w, h),
dpi)
x = x * w
y = y * h
box_prop = vtkTextProperty()
vcs.vcs2vtk.prepTextProperty(box_prop, (w, h), to=self.text, tt=self.text, cmap=cmap)
box_prop.SetOrientation(-1 * self.text.angle)
text_color = box_prop.GetColor()
highlight_color = vcs.vtk_ui.text.contrasting_color(*text_color)
textbox = Textbox(self.interactor, string, highlight_color=highlight_color, highlight_opacity=.8, movable=True, on_editing_end=self.finished_editing, on_drag=self.moved_textbox, textproperty=box_prop, on_click=self.textbox_clicked)
textbox.x = x
textbox.y = y
textbox.show()
textbox.show_highlight()
if ind == self.index:
textbox.start_editing()
self.textboxes.append(textbox)
def text_dimensions(text, text_prop, dpi, at_angle=0):
ren = vtkTextRenderer()
bounds = [0, 0, 0, 0]
p = vtkTextProperty()
p.ShallowCopy(text_prop)
p.SetOrientation(at_angle)
ren.GetBoundingBox(p, text, bounds, dpi)
return bounds[1] - bounds[0] + 1, bounds[3] - bounds[2] + 1
def textProperty(self, fontsize = 20):
"""Return properties for a text."""
tprop = vtk.vtkTextProperty()
tprop.SetColor(0., 0., 0.)
tprop.SetFontSize(fontsize)
tprop.SetFontFamilyToArial()
tprop.BoldOff()
return tprop
def __init__(self, parent):
QVTKRenderWindowInteractor.__init__(self, parent)
self.renderer = vtk.vtkRenderer()
self.GetRenderWindow().AddRenderer(self.renderer)
interactor = vtk.vtkInteractorStyleSwitch()
self._Iren.SetInteractorStyle(interactor)
self.surface = None
# Remainng calls set up axes.
tprop = vtk.vtkTextProperty()
tprop.SetColor(1,1,1)
# Create a faint outline to go with the axes.
self.outline = vtk.vtkOutlineFilter()
# Initially set up with a box as input. This will be changed
# to a plot once the user clicks something.
self.box = vtk.vtkBox()
self.box.SetBounds(0,10,0,10,0,10)
sample = vtk.vtkSampleFunction()
sample.SetImplicitFunction(self.box)
sample.SetSampleDimensions(2,2,2)
sample.SetModelBounds(0,10,0,10,0,5)
sample.ComputeNormalsOff()
self.outline.SetInputConnection(sample.GetOutputPort())
mapOutline = vtk.vtkPolyDataMapper()
mapOutline.SetInputConnection(self.outline.GetOutputPort())
self.outlineActor = vtk.vtkActor()
self.outlineActor.SetMapper(mapOutline)
self.outlineActor.GetProperty().SetColor(1,1,1)
self.outlineActor.GetProperty().SetOpacity(.25)
self.renderer.AddActor(self.outlineActor)
self.axes = vtk.vtkCubeAxesActor2D()
self.axes.SetCamera(self.renderer.GetActiveCamera())
self.axes.SetFlyModeToOuterEdges()
self.axes.SetLabelFormat("%6.4g")
self.axes.SetFontFactor(0.8)
self.axes.SetAxisTitleTextProperty(tprop)
self.axes.SetAxisLabelTextProperty(tprop)
self.axes.SetXLabel("MPI Rank")
self.axes.SetYLabel("Progress")
self.axes.SetZLabel("Effort")
self.axes.SetInput(sample.GetOutput())
self.renderer.AddViewProp(self.axes)
# Keep original camera around in case it gets changed
self.originalCamera = self.renderer.GetActiveCamera()
self.renderer.GetActiveCamera().Pitch(90) # Want effort to be vertical
self.renderer.GetActiveCamera().OrthogonalizeViewUp()
self.renderer.ResetCamera()
self.renderer.GetActiveCamera().Elevation(15) # Be slightly above the data
def text_dimensions(text, index, winsize, dpi):
prop = vtkTextProperty()
vcs.vcs2vtk.prepTextProperty(
prop,
winsize,
text.To,
text.Tt,
vcs.getcolormap())
return vcs.vtk_ui.text.text_dimensions(text.string[index], prop, dpi)
def __init__(self, interactor, marker, index, display, configurator):
self.interactor = interactor
self.marker = marker
self.index = index
self.configurator = configurator
actors = display.backend["vtk_backend_marker_actors"][index]
self.glyph, self.glyph_source, self.polydata, self.actor, self.geo = actors
self.display = display
self.handles = []
for ind, x in enumerate(marker.x[index]):
y = marker.y[index][ind]
h = vtk_ui.Handle(self.interactor, (x, y), dragged=self.adjust, color=(0,0,0), normalize=True)
h.show()
self.handles.append(h)
self.toolbar = vtk_ui.toolbar.Toolbar(self.interactor, "Marker Options")
self.toolbar.show()
self.toolbar.add_button(["Change Color"], action=self.change_color)
self.toolbar.add_slider_button(marker.size[index], 1, 300, "Marker Size", update=self.set_size)
self.type_bar = self.toolbar.add_toolbar("Marker Type", open_label="Change")
shapes = marker_shapes()
shapes.insert(0, "Select Shape")
self.shape_button = self.type_bar.add_button(shapes, action=self.change_shape)
wmos = wmo_shapes()
wmos.insert(0, "Select WMO Marker")
self.wmo_button = self.type_bar.add_button(wmos, action=self.change_wmo)
if self.marker.type[self.index] in shapes:
self.shape_button.set_state(shapes.index(self.marker.type[self.index]))
else:
self.wmo_button.set_state(wmos.index(self.marker.type[self.index]))
# Used to store the color picker when it's active
self.picker = None
prop = vtk.vtkTextProperty()
prop.SetBackgroundColor(.87, .79, .55)
prop.SetBackgroundOpacity(1)
prop.SetColor(0, 0, 0)
self.tooltip = vtk_ui.Label(self.interactor, "%s + Click to place new markers." % ("Cmd" if sys.platform == "darwin" else "Ctrl"), textproperty=prop)
self.tooltip.left = 0
self.tooltip.top = self.interactor.GetRenderWindow().GetSize()[1] - self.tooltip.get_dimensions()[1]
self.tooltip.show()
super(MarkerEditor, self).__init__()
self.register()
def __init__(self, parent, visualizer, **kws):
"""
Initialization
"""
self.x, self.y, self.z = -1, -1, -1
self.renew = 1
self.mapper = vtk.vtkPolyDataMapper()
self.axes = None
VisualizationModule.__init__(self, parent, visualizer, **kws)
iactor = self.wxrenwin.GetRenderWindow().GetInteractor()
self.descs = {"X": "X axis", "Y": "Y axis", "Z": "Z axis"}
self.axes = axes = vtk.vtkAxesActor()
axes.SetShaftTypeToCylinder()
axes.SetXAxisLabelText("X")
axes.SetYAxisLabelText("Y")
axes.SetZAxisLabelText("Z")
axes.SetTotalLength(2.0, 2.0, 2.0)
self.length = math.sqrt(2.0**2 + 2.0**2 + 2.0**2)
tprop = vtk.vtkTextProperty()
tprop.ItalicOn()
tprop.ShadowOn()
tprop.SetFontFamilyToTimes()
axes.GetXAxisCaptionActor2D().SetCaptionTextProperty(tprop)
tprop2 = vtk.vtkTextProperty()
tprop2.ShallowCopy(tprop)
axes.GetYAxisCaptionActor2D().SetCaptionTextProperty(tprop2)
tprop3 = vtk.vtkTextProperty()
tprop3.ShallowCopy(tprop)
axes.GetZAxisCaptionActor2D().SetCaptionTextProperty(tprop3)
self.renderer = self.parent.getRenderer()
self.actor = self.axes
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetOutlineColor(0.93, 0.57, 0.13)
self.marker.SetOrientationMarker(axes)
self.marker.SetViewport(0.0, 0.0, 0.2, 0.2)
self.marker.SetInteractor(iactor)
self.marker.SetEnabled(1)
self.marker.InteractiveOff()
self.filterDesc = "Add axes in 3D view"
def init_buttons(self):
# An "off" and "on" state
states = [vtk_ui.button.ButtonState(bgcolor=x) for x in ((.5, .5, .5), (.75, .75, .75))]
prop = vtk.vtkTextProperty()
prop.SetBackgroundColor(.87, .79, .55)
prop.SetBackgroundOpacity(1)
prop.SetColor(0, 0, 0)
self.text_button = vtk_ui.button.Button(self.interactor, states=states, image=os.path.join(sys.prefix, "share", "vcs", "text_icon.png"), top=10, left=10, halign=vtk_ui.button.RIGHT_ALIGN, action=self.text_click, tooltip="Create Text: click to place.", tooltip_property=prop)
self.marker_button = vtk_ui.button.Button(self.interactor, states=states, image=os.path.join(sys.prefix, "share", "vcs", "marker_icon.png"), top=10, left=63, halign=vtk_ui.button.RIGHT_ALIGN, action=self.marker_click, tooltip="Create Marker: click to place.", tooltip_property=prop)
def __init__(self,data_reader,scalar_bar_number):
# Create a colorscale lookup table
self.lut=vtk.vtkLookupTable()
self.lut.SetNumberOfColors(256)
self.lut.SetTableRange(data_reader.get_scalar_range())
self.lut.SetHueRange(0,1)
self.lut.SetRange(data_reader.get_scalar_range())
self.lut.Build()
self.actor= vtk.vtkScalarBarActor()
self.actor.SetOrientationToVertical()
self.actor.SetPosition( 0.9, 0.77-0.25*scalar_bar_number)
self.actor.SetPosition2( 0.09, 0.24 )
self.propT = vtk.vtkTextProperty()
self.propL = vtk.vtkTextProperty()
self.propT.SetFontFamilyToArial()
self.propT.SetColor(0.5,0.5,0.5)
self.propT.ItalicOff()
self.propT.BoldOn()
self.propL.BoldOff()
self.actor.SetLookupTable(self.lut)
def visualize_map(self, VOIclip):
# get info from image before visualization
VOIclip.UpdateInformation()
self.dims = VOIclip.GetDimensions()
(xMin, xMax, yMin, yMax, zMin, zMax) = VOIclip.GetWholeExtent()
self.spacing = VOIclip.GetSpacing()
# Set up ortogonal planes
self.xImagePlaneWidget.SetInput( VOIclip )
self.xImagePlaneWidget.SetPlaneOrientationToXAxes()
self.xImagePlaneWidget.SetSliceIndex(0)
self.yImagePlaneWidget.SetInput( VOIclip )
self.yImagePlaneWidget.SetPlaneOrientationToYAxes()
self.yImagePlaneWidget.SetSliceIndex(0)
self.zImagePlaneWidget.SetInput( VOIclip )
self.zImagePlaneWidget.SetPlaneOrientationToZAxes()
self.zImagePlaneWidget.SetSliceIndex(0)
self.xImagePlaneWidget.On()
self.yImagePlaneWidget.On()
self.zImagePlaneWidget.On()
# Create a text property for both cube axes
tprop = vtk.vtkTextProperty()
tprop.SetColor(1, 1, 1)
tprop.ShadowOff()
# Create a vtkCubeAxesActor2D. Use the outer edges of the bounding box to
# draw the axes. Add the actor to the renderer.
axes = vtk.vtkCubeAxesActor2D()
axes.SetInput(VOIclip)
axes.SetCamera(self.renderer1.GetActiveCamera())
axes.SetLabelFormat("%6.4g")
axes.SetFlyModeToOuterEdges()
axes.SetFontFactor(1.2)
axes.SetAxisTitleTextProperty(tprop)
axes.SetAxisLabelTextProperty(tprop)
self.renderer1.AddViewProp(axes)
############
# bounds and initialize camera
bounds = VOIclip.GetBounds()
self.renderer1.ResetCamera(bounds)
self.renderer1.ResetCameraClippingRange()
self.camera.SetViewUp(0.0,-1.0,0.0)
self.camera.Azimuth(360)
# Initizalize
#self.renWin1.Render()
self.renderer1.Render()
self.iren1.Start()
return
def _create_species_legend(self):
species_legend = vtk.vtkLegendBoxActor()
# Get number of lines
legend_line_numbers = len(self._mapped_species_idset) \
+ len(domain_kind_constants.DOMAIN_KIND_NAME)
# Create legend actor
species_legend.SetNumberOfEntries(legend_line_numbers)
species_legend.SetPosition(
self._get_legend_position(
self.settings.species_legend_location,
self.settings.species_legend_height,
self.settings.species_legend_width,
self.settings.species_legend_offset))
species_legend.SetWidth(self.settings.species_legend_width)
species_legend.SetHeight(self.settings.species_legend_height)
tprop = vtk.vtkTextProperty()
tprop.SetColor(rgb_colors.RGB_WHITE)
tprop.SetVerticalJustificationToCentered()
species_legend.SetEntryTextProperty(tprop)
if self.settings.species_legend_border_display:
species_legend.BorderOn()
else:
species_legend.BorderOff()
# Entry legend string to the actor
sphere = vtk.vtkSphereSource()
# Create legends of particle speices
count = 0
for species_id in self._mapped_species_idset:
species_legend.SetEntryColor \
(count, self._pattrs[species_id]['color'])
species_legend.SetEntryString \
(count, self._pattrs[species_id]['name'])
species_legend.SetEntrySymbol(count, sphere.GetOutput())
count += 1
# Create legends of shell spesies
offset = count
count = 0
for kind, name in domain_kind_constants.DOMAIN_KIND_NAME.items():
species_legend.SetEntryColor \
(offset + count, self._get_domain_color(kind))
species_legend.SetEntrySymbol \
(offset + count, sphere.GetOutput())
species_legend.SetEntryString(offset + count, name)
count += 1
return species_legend
def get_default_text_prop(self):
"""
Sets up and returns the default text properties for text display
"""
# set up the default text properties for nice text
font_size = 10
text_prop = vtkTextProperty()
text_prop.SetFontSize(font_size)
text_prop.SetFontFamilyToArial()
text_prop.BoldOff()
text_prop.ItalicOff()
text_prop.ShadowOff()
return text_prop
def addaxeswithlabels(length=(1,1,1),labelx="x",labely="y",labelz="z"):
axes=vtk.vtkAxesActor()
#axes.SetShaftTypeToCylinder()
axes.SetXAxisLabelText(labelx)
axes.SetYAxisLabelText(labely)
axes.SetZAxisLabelText(labelz)
axes.SetTotalLength(length)
tprop = vtk.vtkTextProperty()
tprop.ItalicOn()
tprop.ShadowOn()
tprop.SetFontFamilyToTimes()
axes.GetXAxisCaptionActor2D().SetCaptionTextProperty(tprop)
tprop2 = vtk.vtkTextProperty()
tprop2.ShallowCopy(tprop)
axes.GetYAxisCaptionActor2D().SetCaptionTextProperty(tprop2)
tprop3 = vtk.vtkTextProperty()
tprop3.ShallowCopy(tprop)
axes.GetZAxisCaptionActor2D().SetCaptionTextProperty(tprop3)
return axes
def __create_axes(self):
axes = vtk.vtkCubeAxesActor2D()
axes.SetBounds(numpy.array([0.0, 1.0, 0.0, 1.0, 0.0, 1.0]) * self.settings.scaling)
axes.SetRanges(0.0, self.__world_size, 0.0, self.__world_size, 0.0, self.__world_size)
axes.SetLabelFormat("%g")
axes.SetFontFactor(1.5)
tprop = vtk.vtkTextProperty()
tprop.SetColor(self.settings.axis_annotation_color)
tprop.ShadowOn()
axes.SetAxisTitleTextProperty(tprop)
axes.SetAxisLabelTextProperty(tprop)
axes.UseRangesOn()
axes.SetCornerOffset(0.0)
return axes
def ShowLabel(self): self.tprop = vtk.vtkTextProperty() size = self.GetSize() #self.text_label.ScaledTextOn() self.text_label.SetPosition(10, size[1] - 12) self.text_label.SetInput(self.label_t) self.tprop.SetFontSize(12) self.tprop.SetFontFamilyToArial() self.tprop.SetJustificationToLeft() #self.tprop.BoldOn() #self.tprop.ItalicOn() self.tprop.ShadowOn() self.tprop.SetColor(0.9, 0.8, 0.8) self.text_label.SetTextProperty(self.tprop) self.AddActor2D(self.text_label)
def neuron3d(neuron_graph,
label_nodes=[],
labels=[],
priorities=[],
nodecolor=nodecolor_4cp,
background=(0, 0, 0),
lines=False,
stereo=False,
axes=True,
fullscreen=True):
"""axes: If true, show axis with scale bar info
"""
renderer, actor = nrngraph2vtk(neuron_graph,
label_nodes=label_nodes,
labels=labels,
priorities=priorities,
nodecolor=nodecolor,
background=background,
lines=lines)
if axes: # show axis with scale bar info
_ax = vtk.vtkCubeAxesActor2D()
_ax.SetLabelFormat('%3.0f')
_ax.SetNumberOfLabels(0)
_ax.SetYAxisVisibility(False)
_ax.SetZAxisVisibility(False)
_ax.SetBounds(0, 200, -600, -400, 0, 200)
_ax.SetXLabel('')
_ax.SetXOrigin(0)
_ax.SetYOrigin(-600)
_ax.SetZOrigin(0)
color = (1.0 - background[0], 1.0 - background[1], 1.0 - background[2])
tprop = vtk.vtkTextProperty()
tprop.SetColor(color)
_ax.SetAxisLabelTextProperty(tprop)
_ax.GetProperty().SetColor(*color)
_ax.SetFlyModeToClosestTriad()
_ax.SetCamera(renderer.GetActiveCamera())
renderer.AddActor(_ax)
renderer.ResetCamera()
win = vtk.vtkRenderWindow()
win.AddRenderer(renderer)
if fullscreen:
win.FullScreenOn()
if stereo:
win.GetStereoCapableWindow()
win.StereoCapableWindowOn()
win.SetStereoRender(1)
win.SetStereoTypeToCrystalEyes()
win.SetFullScreen(1)
#win.SetStereoTypeToRedBlue()
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(win)
win.Render()
# exporter = vtk.vtkX3DExporter()
# exporter.SetFileName('ggn.x3d')
# exporter.SetRenderWindow(win)
# exporter.Write()
interactor.Initialize()
interactor.Start()
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 main():
colors = vtk.vtkNamedColors()
planes = list()
titles = list()
# Using frustum planes.
titles.append('Using frustum planes')
camera = vtk.vtkCamera()
planesArray = [0] * 24
camera.GetFrustumPlanes(1, planesArray)
planes.append(vtk.vtkPlanes())
planes[0].SetFrustumPlanes(planesArray)
# Using bounds.
titles.append('Using bounds')
sphereSource = vtk.vtkSphereSource()
sphereSource.Update()
bounds = [0] * 6
sphereSource.GetOutput().GetBounds(bounds)
planes.append(vtk.vtkPlanes())
planes[1].SetBounds(bounds)
# At this point we have the planes created by both of the methods above.
# You can do whatever you want with them.
# For visualisation we will produce an n-sided convex hull
# and visualise it.
# Create a common text property.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(16)
textProperty.SetJustificationToCentered()
renWin = vtk.vtkRenderWindow()
renWin.SetSize(600, 600)
renWin.SetWindowName('Planes')
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
hulls = list()
pds = list()
mappers = list()
actors = list()
renderers = list()
textMappers = list()
textActors = list()
for i in range(0, len(planes)):
hulls.append(vtk.vtkHull())
hulls[i].SetPlanes(planes[i])
pds.append(vtk.vtkPolyData())
# To generate the convex hull we supply a vtkPolyData object and a bounding box.
# We define the bounding box to be where we expect the resulting polyhedron to lie.
# Make it a generous fit as it is only used to create the initial
# polygons that are eventually clipped.
hulls[i].GenerateHull(pds[i], -200, 200, -200, 200, -200, 200)
mappers.append(vtk.vtkPolyDataMapper())
mappers[i].SetInputData(pds[i])
actors.append(vtk.vtkActor())
actors[i].SetMapper(mappers[i])
actors[i].GetProperty().SetColor(colors.GetColor3d('Moccasin'))
actors[i].GetProperty().SetSpecular(0.8)
actors[i].GetProperty().SetSpecularPower(30)
renderers.append(vtk.vtkRenderer())
renderers[i].AddActor(actors[i])
textMappers.append(vtk.vtkTextMapper())
textMappers[i].SetInput(titles[i])
textMappers[i].SetTextProperty(textProperty)
textActors.append(vtk.vtkActor2D())
textActors[i].SetMapper(textMappers[i])
textActors[i].SetPosition(100, 10)
renderers[i].AddViewProp(textActors[i])
renWin.AddRenderer(renderers[i])
# Setup the viewports
xGridDimensions = 2
yGridDimensions = 1
rendererSize = 300
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('DarkSlateGray'))
ren.SetViewport(viewport)
renWin.AddRenderer(ren)
continue
renderers[index].SetViewport(viewport)
renderers[index].SetBackground(colors.GetColor3d('DarkSlateGray'))
renderers[index].ResetCamera()
renderers[index].GetActiveCamera().Azimuth(30)
renderers[index].GetActiveCamera().Elevation(-30)
renderers[index].ResetCameraClippingRange()
iRen.Initialize()
renWin.Render()
iRen.Start()
def __init__(self, widget=None):
"""
Nueva visuaización de corte
@param widget: el widget donde se muestra la visualizición, si es None se crea uno nuevo
"""
if widget is None:
widget = SliceVisualizationWidget()
super(SliceVisualization, self).__init__(widget)
self._image = None #imagen que se muesta en la visualización
self._view = CanonicalSliceView(
) #esta es la vista de esta visualización
self._ui = self._widget.ui #interfaz del widget
ui = self._ui
#conexión de señales de Qt
ui.sliceSelector.valueChanged.connect(self._setSliceNumLabel)
ui.sliceNum.editingFinished.connect(self._setSliceNumSlider)
#cambiar el evento 'resize' del widget de esta visualización para agregarle el reseteo de la cámara
widget.resizeEvent = self._widget_resized
#propiedad para definir el color de las líneas
self._lines_color_prop = vtk.vtkProperty()
self._lines_color_prop.SetColor(1, 1, 0) #amarillo por defecto
#líneas que muestran un pick point
#línea vertical
self._vLine = vtk.vtkLineSource()
vLineMapper = vtk.vtkPolyDataMapper()
vLineMapper.SetInput(self._vLine.GetOutput())
self._vLineActor = vtk.vtkActor() #actor de la línea vertical
self._vLineActor.SetMapper(vLineMapper)
self._vLineActor.SetProperty(
self._lines_color_prop) #esta línea se verá de color rojo
self._vLineActor.VisibilityOff(
) #por defecto esta línea no se muestra
#línea horizontal
self._hLine = vtk.vtkLineSource()
hLineMapper = vtk.vtkPolyDataMapper()
hLineMapper.SetInput(self._hLine.GetOutput())
self._hLineActor = vtk.vtkActor() #actor de la línea horizontal
self._hLineActor.SetMapper(hLineMapper)
self._hLineActor.SetProperty(
self._lines_color_prop) #esta línea se verá de color rojo
self._hLineActor.VisibilityOff(
) #por defecto esta línea no se muestra
#posición seleccionada
self._selected_position = (0, 0, 0) #valor por defecto
self._selected_value = 0 #valor del punto seleccionado
self._picked_position = (0, 0, 0)
#texto a mostrar en el widget
self._textActor = vtk.vtkTextActor()
self._text_color_prop = vtk.vtkTextProperty(
) #propiedad que maneja el color del texto
self._text_color_prop.SetColor(1, 1, 0) #azul por defecto
self._textActor.SetTextProperty(
self._text_color_prop) #el texto se verá amarillo
self._textActor.VisibilityOff() #por defecto el texto no se ve
axises = ["X", "Y", "Z"] #letras de los ejes
#conexión de las señales de Qt relativas a los botones de cambio de ejes verticales
#self._signalMapper = QSignalMapper(self._widget)
#self._signalMapper.connect(self._signalMapper, SIGNAL("mapped(QString)"), self._setVerticalAxis)
self._ui.XButton.clicked.connect(self._setXVerticalAxis)
self._ui.YButton.clicked.connect(self._setYVerticalAxis)
self._ui.ZButton.clicked.connect(self._setZVerticalAxis)
#for button, axis in zip(self._getButtons()[:3], axises):
# button.clicked.connect(self._signalMapper.map)
# self._signalMapper.setMapping(button, axis)
#conexión de las señales de Qt relativas a los botones de cambio de ejes horizontales
#self._signalMapper_2 = QSignalMapper(self._widget)
#self._signalMapper_2.connect(self._signalMapper_2, SIGNAL("mapped(QString)"), self._setHorizontalAxis)
self._ui.XButton_2.clicked.connect(self._setXHorizontalAxis)
self._ui.YButton_2.clicked.connect(self._setYHorizontalAxis)
self._ui.ZButton_2.clicked.connect(self._setZHorizontalAxis)
#for button, axis in zip(self._getButtons()[3:], axises):
# button.clicked.connect(self._signalMapper_2.map)
# self._signalMapper_2.setMapping(button, axis)
#estados de la inversión de los ejes
self._HInvert = False #por defecto no se invierte
self._VInvert = False #por defecto no se invierte
ui.invert.stateChanged.connect(self._setVInvert)
ui.invert_2.stateChanged.connect(self._setHInvert)
self._horizontalAxis = "X" #eje representado horizontalmente
self._verticalAxis = "Y" #eje representado verticalmente
#selector usado en esta visalización
self._picker = vtk.vtkPointPicker(
) #de tipo vtkPointPicker para seleccionar puntos
#para observar el evento de selección con prioridad 9
self._picker.AddObserver("EndPickEvent", self._onPickEvent, 9)
self._iren = ui.visualization #el Interactor es el que esta en la interfaz del widget
self._init_interactor() #incializar la visualización
#agregar los actores de las líneas
self._render.AddActor(self._vLineActor)
self._render.AddActor(self._hLineActor)
#agregar el actor del texto
self._render.AddActor(self._textActor)
#fijar el selector del interactor
self._iren.SetPicker(self._picker)
#el estilo del interactor es de tipo imagen
self._iren.SetInteractorStyle(vtk.vtkInteractorStyleImage())
#observar el vento de click iz\quiero para lanzar el evento de selección
self._iren.AddObserver("LeftButtonPressEvent", self._raisePickEvent)
#quitar los observadores de eventos de teclado.
#para eliminar los siguientes observadores indeseados:
# - pick event con p
# - cambiar el estilo del interactor con j o t
# -y otros pesaitos como w,e,f,s etc.
# (ver cometarios de QVTKRenderWindowInteractor para más información)
self._iren.RemoveObservers("KeyPressEvent")
self._iren.RemoveObservers("CharEvent")
def place_cursor(self):
# Find current position of the text actor
x, y = self.left, self.top
# Use to adjust all window-space numbers
w, h = self.interactor.GetRenderWindow().GetSize()
# Translate distance from top to distance from bottom
y = h - y
# Prep a text property for getting measurements
prop = vtk.vtkTextProperty()
prop.ShallowCopy(self.actor.GetTextProperty())
# Store for rotating the cursor's coords
angle = prop.GetOrientation()
# Reset so we get accurate dimensions
prop.SetOrientation(0)
rows = self.text.split("\n")
dpi = self.interactor.GetRenderWindow().GetDPI()
width, height = text_dimensions(self.text, prop, dpi)
line_height = float(height) / len(rows)
column_adjustment, _ = text_dimensions(rows[self.row][:self.column],
prop, dpi)
x += column_adjustment
row_width, _ = text_dimensions(rows[self.row], prop, dpi)
# Adjust for blank space caused by justifications
halign = prop.GetJustificationAsString()
if halign == "Centered":
x += (width - row_width) / 2.
elif halign == "Right":
x += (width - row_width) + 1 # Adjust for some margin issues
elif halign == "Left":
x -= 3 # Adjust for some margin issues
# Manual adjustments for justification artefacts
valign = prop.GetVerticalJustificationAsString()
if valign == "Top":
y += 2
elif valign == "Centered":
pass
elif valign == "Bottom":
y -= 2
# Get to the current row
y -= line_height * self.row
# Rotate both points to the orientation as the text
y1 = y
y2 = y - line_height
x1 = x
x2 = x
x1, x2 = x1 - self.x, x2 - self.x
y1, y2 = y1 - self.y, y2 - self.y
x1, y1 = rotate((x1, y1), angle)
x2, y2 = rotate((x2, y2), angle)
x1 += self.x
x2 += self.x
y1 += self.y
y2 += self.y
self.cursor.point_1 = (x1, y1)
self.cursor.point_2 = (x2, y2)
isoSurface = vtk.vtkContourFilter()
isoSurface.SetInputConnection(reader.GetOutputPort())
# valor inicial
val = 0.5
isoSurface.SetValue(0, val)
#
surfaceMapper = vtk.vtkPolyDataMapper()
surfaceMapper.SetLookupTable(paleta)
surfaceMapper.SetInputConnection(isoSurface.GetOutputPort())
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(surfaceMapper)
# probabilidade
textActor = vtk.vtkTextActor()
# propriedades do texto da probabilidade
prop_texto = vtk.vtkTextProperty()
prop_texto.SetFontSize(40)
textActor.SetTextProperty(prop_texto)
pos_texto = textActor.GetPositionCoordinate()
pos_texto.SetCoordinateSystemToNormalizedViewport()
pos_texto.SetValue(0.01, 0.9)
prop_texto.SetColor(paleta.GetColor(val))
textActor.SetInput("%.2f" % (val))
# renderer and render window
ren = vtk.vtkRenderer()
ren.SetBackground(.8, .8, .8)
renWin = vtk.vtkRenderWindow()
renWin.SetSize(400, 400)
renWin.AddRenderer(ren)
#
# All Plot3D scalar functions
#
# Create the RenderWindow, Renderer and both Actors
#
renWin = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
scalarLabels = "Density Pressure Temperature Enthalpy Internal_Energy Kinetic_Energy Velocity_Magnitude Stagnation_Energy Entropy Swirl"
scalarFunctions = "100 110 120 130 140 144 153 163 170 184"
camera = vtk.vtkCamera()
light = vtk.vtkLight()
math = vtk.vtkMath()
# All text actors will share the same text prop
textProp = vtk.vtkTextProperty()
textProp.SetFontSize(10)
textProp.SetFontFamilyToArial()
textProp.SetColor(0, 0, 0)
i = 0
for scalarFunction in scalarFunctions.split():
locals()[get_variable_name("pl3d", scalarFunction,
"")] = vtk.vtkMultiBlockPLOT3DReader()
locals()[get_variable_name("pl3d", scalarFunction,
"")].SetXYZFileName("" + str(VTK_DATA_ROOT) +
"/Data/bluntfinxyz.bin")
locals()[get_variable_name("pl3d", scalarFunction,
"")].SetQFileName("" + str(VTK_DATA_ROOT) +
"/Data/bluntfinq.bin")
locals()[get_variable_name(
"pl3d", scalarFunction, "")].SetScalarFunctionNumber(
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.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.
# You can use vtkRandom instead of the python random methods.
inputPoints = vtk.vtkPoints()
random.seed(8775070)
for i in range(10):
x = random.uniform(0.0, 1.0)
y = random.uniform(0.0, 1.0)
z = random.uniform(0.0, 1.0)
inputPoints.InsertNextPoint(x, y, z)
parametricObjects[-1].SetPoints(inputPoints)
# There are only 15 objects.
#parametricObjects.append(vtk.??)
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].ResetCameraClippingRange()
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
def render(Data1, Data2, point):
ren = vtk.vtkRenderer()
ren.SetBackground(.1, .2, .5)
ren2dimg1 = vtk.vtkRenderer()
ren2dimg2 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.AddRenderer(ren2dimg1)
renWin.AddRenderer(ren2dimg2)
renWin.SetSize(1536, 1024)
# Create a render window
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
pts = vtk.vtkPoints()
[img1_position, img2_position, epi_point1,
epi_point2] = epigeometry_points(pts, point, Data1, Data2)
colors = vtk.vtkUnsignedCharArray()
colors.SetNumberOfComponents(3)
colors.SetName("Colors")
lines = vtk.vtkCellArray()
add_3dline(lines, pts, 0, 1, colors, 'r')
add_3dline(lines, pts, 2, 3, colors, 'g')
add_3dline(lines, pts, 1, 4, colors, 'w')
add_3dline(lines, pts, 3, 5, colors, 'w')
add_3dline(lines, pts, 3, 6, colors, 'w')
add_3dline(lines, pts, 5, 6, colors, 'w')
linesPolyData = vtk.vtkPolyData()
linesPolyData.SetPoints(pts)
linesPolyData.SetLines(lines)
linesPolyData.GetCellData().SetScalars(colors)
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(linesPolyData)
else:
mapper.SetInputData(linesPolyData)
lineactor = vtk.vtkActor()
lineactor.SetMapper(mapper)
img1 = Data1.img.copy()
img2 = Data2.img.copy()
cv2.circle(img1, (point[0], point[1]), 10, (255, 0, 0), -1)
cv2.line(img2, (int(epi_point1[0]), int(epi_point1[1])),
(int(epi_point2[0]), int(epi_point2[1])), (255, 0, 0), 5)
cv2.putText(
img1,
str(int(np.rad2deg(Data1.PA))) + ', ' + str(int(np.rad2deg(Data1.SA))),
(10, 100), 1, 4, (255, 255, 255), 2, cv2.LINE_AA)
cv2.putText(
img2,
str(int(np.rad2deg(Data2.PA))) + ', ' + str(int(np.rad2deg(Data2.SA))),
(10, 100), 1, 4, (255, 255, 255), 2, cv2.LINE_AA)
reader1 = vtkImageImportFromArray()
reader1.SetArray(img1)
reader1.Update()
fliper1 = vtk.vtkImageFlip()
fliper1.SetFilteredAxis(1)
fliper1.SetInputConnection(reader1.GetOutputPort())
fliper1.Update()
reader2 = vtkImageImportFromArray()
reader2.SetArray(img2)
reader2.Update()
fliper2 = vtk.vtkImageFlip()
fliper2.SetFilteredAxis(1)
fliper2.SetInputConnection(reader2.GetOutputPort())
fliper2.Update()
# transform1 = vtk.vtkTransform()
# transform1.Translate(img1_position)
# transform1.RotateY(np.rad2deg(Data1.PA))
# transform1.RotateX(-np.rad2deg(Data1.SA))
# transform1.Scale(img1.shape[0]*Data1.PS[0],img1.shape[1]*Data1.PS[1],1)
# transform2 = vtk.vtkTransform()
# transform2.Translate(img2_position)
# transform2.RotateY(np.rad2deg(Data2.PA))
# transform2.RotateZ(-np.rad2deg(Data2.SA))
# transform2.Scale(img2.shape[0]*Data2.PS[0],img2.shape[1]*Data2.PS[1],1)
planeA_actor = createQuad(img1)
planeA_actor.SetPosition(img1_position)
planeA_actor.SetScale(Data1.PS[0], Data1.PS[1], 1)
planeA_actor.RotateY(np.rad2deg(Data1.PA))
planeA_actor.RotateX(-np.rad2deg(Data1.SA))
# planeA_actor.SetUserTransform(transform1)
planeB_actor = createQuad(img2)
planeB_actor.SetPosition(img2_position)
planeB_actor.SetScale(Data2.PS[0], Data2.PS[1], 1)
planeB_actor.RotateY(np.rad2deg(Data2.PA))
planeB_actor.RotateZ(-np.rad2deg(Data2.SA))
# planeB_actor.SetUserTransform(transform2)
axes = vtk.vtkAxesActor()
transform = vtk.vtkTransform()
transform.Scale(100, 100, 100)
axes.SetUserTransform(transform)
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(25)
textProperty.SetJustificationToCentered()
textMapper = vtk.vtkTextMapper()
textActor = vtk.vtkActor2D()
textMapper.SetInput('Epipolar Geometry')
textMapper.SetTextProperty(textProperty)
textActor.SetMapper(textMapper)
textActor.SetPosition(512, 950)
ren.AddActor(lineactor)
ren.AddActor(planeA_actor)
ren.AddActor(planeB_actor)
ren.AddActor(axes)
ren.AddViewProp(textActor)
ren.SetViewport([0.0, 0.0, 2 / 3, 1.0])
mapper2d1 = vtk.vtkImageMapper()
mapper2d1.SetInputConnection(fliper1.GetOutputPort())
mapper2d1.SetColorWindow(255)
mapper2d1.SetColorLevel(127.5)
actor2d1 = vtk.vtkActor2D()
actor2d1.SetMapper(mapper2d1)
ren2dimg1.AddActor2D(actor2d1)
ren2dimg1.SetViewport([2 / 3, 0.5, 1.0, 1.0])
mapper2d2 = vtk.vtkImageMapper()
mapper2d2.SetInputConnection(fliper2.GetOutputPort())
mapper2d2.SetColorWindow(255)
mapper2d2.SetColorLevel(127.5)
actor2d2 = vtk.vtkActor2D()
actor2d2.SetMapper(mapper2d2)
ren2dimg2.AddActor2D(actor2d2)
ren2dimg2.SetViewport([2 / 3, 0.0, 1.0, 0.5])
iren.Initialize()
renWin.Render()
iren.Start()
def text(
self,
txt,
pos=(0, 0, 0),
s=1,
c=None,
alpha=1,
bg=None,
font="Gula",
dpi=500,
justify="bottom-left",
):
"""Build an image from a string."""
if c is None: # automatic black or white
if settings.plotter_instance and settings.plotter_instance.renderer:
c = (0.9, 0.9, 0.9)
if np.sum(settings.plotter_instance.renderer.GetBackground()
) > 1.5:
c = (0.1, 0.1, 0.1)
else:
c = (0.3, 0.3, 0.3)
r = vtk.vtkTextRenderer()
img = vtk.vtkImageData()
tp = vtk.vtkTextProperty()
tp.BoldOff()
tp.SetColor(colors.getColor(c))
tp.SetJustificationToLeft()
if "top" in justify:
tp.SetVerticalJustificationToTop()
if "bottom" in justify:
tp.SetVerticalJustificationToBottom()
if "cent" in justify:
tp.SetVerticalJustificationToCentered()
tp.SetJustificationToCentered()
if "left" in justify:
tp.SetJustificationToLeft()
if "right" in justify:
tp.SetJustificationToRight()
if font.lower() == "courier": tp.SetFontFamilyToCourier()
elif font.lower() == "times": tp.SetFontFamilyToTimes()
elif font.lower() == "arial": tp.SetFontFamilyToArial()
else:
tp.SetFontFamily(vtk.VTK_FONT_FILE)
import os
if font in settings.fonts:
tp.SetFontFile(settings.fonts_path + font + '.ttf')
elif os.path.exists(font):
tp.SetFontFile(font)
else:
colors.printc("\sad Font",
font,
"not found in",
settings.fonts_path,
c="r")
colors.printc("\pin Available fonts are:",
settings.fonts,
c="m")
return None
if bg:
bgcol = colors.getColor(bg)
tp.SetBackgroundColor(bgcol)
tp.SetBackgroundOpacity(alpha * 0.5)
tp.SetFrameColor(bgcol)
tp.FrameOn()
#GetConstrainedFontSize (const vtkUnicodeString &str,
# vtkTextProperty *tprop, int targetWidth, int targetHeight, int dpi)
fs = r.GetConstrainedFontSize(txt, tp, 900, 1000, dpi)
tp.SetFontSize(fs)
r.RenderString(tp, txt, img, [1, 1], dpi)
# RenderString (vtkTextProperty *tprop, const vtkStdString &str,
# vtkImageData *data, int textDims[2], int dpi, int backend=Default)
self.SetInputData(img)
self.GetMapper().Modified()
self.SetPosition(pos)
x0, x1 = self.xbounds()
if x1 != x0:
sc = s / (x1 - x0)
self.SetScale(sc, sc, sc)
return self
def load_vtk_legacy_file(self, file):
"""
Loads the vtk mesh and displays the scalar data in a color map.
Allows further postprocessing to be done, such as grayscale and contour plots.
"""
if hasattr(self, "mesh_actor"):
self.ren.RemoveActor(self.mesh_actor)
self.ren.RemoveActor(self.sbActor)
if file is None:
file, _ = get_file("*.vtk")
self.ui.statLabel.setText("Reading %s for mesh . . ." % file)
mesh_source = vtk.vtkUnstructuredGridReader()
mesh_source.SetFileName(file)
# read scalar to vtk
mesh_source.SetScalarsName("S33")
mesh_source.Update()
mesh_reader_output = mesh_source.GetOutput()
# bounds for axis
bounds = mesh_reader_output.GetBounds()
# show element edges
edges = vtk.vtkExtractEdges()
edges.SetInputConnection(mesh_source.GetOutputPort())
edges.Update()
# lookup table and scalar range for a vtk file
mesh_lookup_table = vtk.vtkLookupTable()
# make scalar red = max; blue = min
self.ui.statLabel.setText("Building lookup table . . .")
self.draw_color_range(mesh_lookup_table)
mesh_lookup_table.Build()
scalar_range = mesh_reader_output.GetScalarRange()
# mesh data set
self.mesh_mapper = vtk.vtkDataSetMapper()
self.mesh_mapper.SetInputData(mesh_reader_output)
self.mesh_mapper.SetScalarRange(scalar_range)
self.mesh_mapper.SetLookupTable(mesh_lookup_table)
#define actors
self.mesh_actor = vtk.vtkActor()
# self.sbActor = vtk.vtkScalarBarActor()
# #the scalar bar widget is associated with the qt interactor box
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(self.iren)
# scalar_bar_widget.SetCurrentRenderer(self.ren.GetRenderer())
# scalar_bar_widget.SetDefaultRenderer(self.ren.GetRenderer())
scalar_bar_widget.SetEnabled(True)
scalar_bar_widget.RepositionableOn()
scalar_bar_widget.On()
# define scalar bar actor
self.sbActor = scalar_bar_widget.GetScalarBarActor()
# self.sbActor.SetOrientationToVertical()
self.sbActor.SetLookupTable(mesh_lookup_table)
self.sbActor.SetTitle("S33")
scalarBarRep = scalar_bar_widget.GetRepresentation()
scalarBarRep.GetPositionCoordinate().SetValue(0.01, 0.01)
scalarBarRep.GetPosition2Coordinate().SetValue(0.09, 0.9)
#attempt to change scalebar properties [ineffective]
propT = vtk.vtkTextProperty()
propL = vtk.vtkTextProperty()
propT.SetFontFamilyToArial()
# propT.ItalicOff()
propT.BoldOn()
propL.BoldOff()
propL.SetFontSize(1)
propT.SetFontSize(2)
self.sbActor.SetTitleTextProperty(propT)
self.sbActor.SetLabelTextProperty(propL)
self.sbActor.GetLabelTextProperty().SetFontSize(7)
self.sbActor.GetTitleTextProperty().SetFontSize(7)
self.sbActor.SetLabelFormat("%.1f")
#define the mesh actor properties
self.mesh_actor.SetMapper(self.mesh_mapper)
self.mesh_actor.GetProperty().SetLineWidth(1)
self.mesh_actor.GetProperty().EdgeVisibilityOn()
#display the actors
self.ren.AddActor(self.mesh_actor)
self.ren.AddActor(self.sbActor)
#get boundary of mesh
self.limits = mesh_reader_output.GetBounds()
self.ui.vtkWidget.setFocus()
self.AddAxis(self.limits, 1)
xyview_post(self.ren, self.ren.GetActiveCamera(), self.cp,
self.fp) #sorts out the camera issue
self.ui.vtkWidget.update()
self.ui.statLabel.setText("Loaded results. Idle.")
QtWidgets.QApplication.processEvents()
def _plotInternal(self):
"""Overrides baseclass implementation."""
numLevels = len(self._contourLevels)
cot = vtk.vtkContourFilter()
if self._useCellScalars:
cot.SetInputConnection(self._vtkPolyDataFilter.GetOutputPort())
else:
cot.SetInputData(self._vtkDataSet)
cot.SetNumberOfContours(numLevels)
if self._contourLevels[0] == 1.e20:
self._contourLevels[0] = -1.e20
for i in range(numLevels):
cot.SetValue(i, self._contourLevels[i])
cot.SetValue(numLevels, self._contourLevels[-1])
# TODO remove update
cot.Update()
mappers = []
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(len(self._contourColors))
cmap = vcs.elements["colormap"][self._context.canvas.getcolormapname()]
for i, col in enumerate(self._contourColors):
r, g, b = cmap.index[col]
lut.SetTableValue(i, r / 100., g / 100., b / 100.)
# Setup isoline labels
if self._gm.label:
# Setup label mapping array:
tpropMap = vtk.vtkDoubleArray()
tpropMap.SetNumberOfComponents(1)
tpropMap.SetNumberOfTuples(numLevels)
for i, val in enumerate(self._contourLevels):
tpropMap.SetTuple(i, [
val,
])
# Prep text properties:
tprops = vtk.vtkTextPropertyCollection()
if self._gm.text or self._gm.textcolors:
# Text objects:
if self._gm.text:
texts = self._gm.text
while len(texts) < numLevels:
texts.append(texts[-1])
else:
texts = [None] * len(self._gm.textcolors)
# Custom colors:
if self._gm.textcolors:
colorOverrides = self._gm.textcolors
while len(colorOverrides) < numLevels:
colorOverrides.append(colorOverrides[-1])
else:
colorOverrides = [None] * len(self._gm.text)
for tc, colorOverride in zip(texts, colorOverrides):
if vcs.queries.istextcombined(tc):
tt, to = tuple(tc.name.split(":::"))
elif tc is None:
tt = "default"
to = "default"
elif vcs.queries.istexttable(tc):
tt = tc.name
to = "default"
elif vcs.queries.istextorientation(tc):
to = tc.name
tt = "default"
if colorOverride is not None:
tt = vcs.createtexttable(None, tt)
tt.color = colorOverride
tt = tt.name
tprop = vtk.vtkTextProperty()
vcs2vtk.prepTextProperty(tprop,
self._context.renWin.GetSize(),
to, tt)
tprops.AddItem(tprop)
if colorOverride is not None:
del (vcs.elements["texttable"][tt])
else: # No text properties specified. Use the default:
tprop = vtk.vtkTextProperty()
vcs2vtk.prepTextProperty(tprop, self._context.renWin.GetSize())
tprops.AddItem(tprop)
self._resultDict["vtk_backend_contours_labels_text_properties"] = \
tprops
mapper = vtk.vtkLabeledContourMapper()
mapper.SetTextProperties(tprops)
mapper.SetTextPropertyMapping(tpropMap)
mapper.SetLabelVisibility(1)
pdMapper = mapper.GetPolyDataMapper()
self._resultDict["vtk_backend_labeled_luts"] = [[
lut, [self._contourLevels[0], self._contourLevels[-1], False]
]]
else: # No isoline labels:
mapper = vtk.vtkPolyDataMapper()
pdMapper = mapper
self._resultDict["vtk_backend_luts"] = [[
lut, [self._contourLevels[0], self._contourLevels[-1], False]
]]
pdMapper.SetLookupTable(lut)
pdMapper.SetScalarRange(self._contourLevels[0],
self._contourLevels[-1])
pdMapper.SetScalarModeToUsePointData()
stripper = vtk.vtkStripper()
stripper.SetInputConnection(cot.GetOutputPort())
mapper.SetInputConnection(stripper.GetOutputPort())
# TODO remove update, make pipeline
stripper.Update()
mappers.append(mapper)
self._resultDict["vtk_backend_contours"] = [
cot,
]
if self._maskedDataMapper is not None:
mappers.insert(0, self._maskedDataMapper)
x1, x2, y1, y2 = vcs.utils.getworldcoordinates(self._gm,
self._data1.getAxis(-1),
self._data1.getAxis(-2))
# And now we need actors to actually render this thing
actors = []
for mapper in mappers:
act = vtk.vtkActor()
act.SetMapper(mapper)
if self._vtkGeoTransform is None:
# If using geofilter on wireframed does not get wrppaed not sure
# why so sticking to many mappers
act = vcs2vtk.doWrap(act, [x1, x2, y1, y2],
self._dataWrapModulo)
# TODO See comment in boxfill.
if mapper is self._maskedDataMapper:
actors.append([act, self._maskedDataMapper, [x1, x2, y1, y2]])
else:
actors.append([act, [x1, x2, y1, y2]])
# create a new renderer for this mapper
# (we need one for each mapper because of cmaera flips)
ren = self._context.fitToViewport(
act, [
self._template.data.x1, self._template.data.x2,
self._template.data.y1, self._template.data.y2
],
wc=[x1, x2, y1, y2],
geo=self._vtkGeoTransform,
priority=self._template.data.priority)
self._resultDict["vtk_backend_actors"] = actors
t = self._originalData1.getTime()
if self._originalData1.ndim > 2:
z = self._originalData1.getAxis(-3)
else:
z = None
self._resultDict.update(
self._context.renderTemplate(self._template, self._data1, self._gm,
t, z))
if self._context.canvas._continents is None:
self._useContinents = False
if self._useContinents:
projection = vcs.elements["projection"][self._gm.projection]
self._context.plotContinents(x1, x2, y1, y2, projection,
self._dataWrapModulo, self._template)
def addT2transvisualize(self, T2images, image_pos_pat, image_ori_pat, T2dims, T2spacing, interact):
'''Added to build second reference frame and display T2 overlayed into T1 reference frame'''
# Proceed to build reference frame for display objects based on DICOM coords
[transformed_T2image, transform_cube] = self.dicomTransform(T2images, image_pos_pat, image_ori_pat)
self.T2origin = list(transformed_T2image.GetOrigin())
print "T2 Extent"
self.T2extent = list(transformed_T2image.GetExtent())
print self.T2extent
alignR = int(raw_input('\nAlign right? Yes:1 or align with T1w: !=1 : '))
if alignR:
zf1 = self.T1spacing[2]*self.T1extent[5] + self.T1origin[2]
self.T2origin[2] = zf1 - T2spacing[2]*self.T2extent[5] # this is z-span
else:
self.T2origin[2] = self.T1origin[2]
# Change info origin
transformedInfo_T2image = vtk.vtkImageChangeInformation()
transformedInfo_T2image.SetInputData( transformed_T2image )
transformedInfo_T2image.SetOutputOrigin(self.T2origin)
transformedInfo_T2image.Update()
self.transformed_T2image = transformedInfo_T2image.GetOutput()
# Set up ortogonal planes
self.xImagePlaneWidget.SetInputData( self.transformed_T2image )
self.xImagePlaneWidget.SetSliceIndex(0)
self.yImagePlaneWidget.SetInputData( self.transformed_T2image )
self.yImagePlaneWidget.SetSliceIndex(0)
self.zImagePlaneWidget.SetInputData( self.transformed_T2image )
self.zImagePlaneWidget.SetSliceIndex(0)
# Create a text property for both cube axes
tprop = vtk.vtkTextProperty()
tprop.SetColor(0.5, 0.5, 0)
tprop.ShadowOff()
# Update the reneder window to receive new image !Important*****
self.renderer1.Modified()
self.renWin1.Modified()
# Create a vtkCubeAxesActor2D. Use the outer edges of the bounding box to
# draw the axes. Add the actor to the renderer.
axesT2 = vtk.vtkCubeAxesActor2D()
axesT2.SetInputData(self.transformed_T2image)
axesT2.SetCamera(self.renderer1.GetActiveCamera())
axesT2.SetLabelFormat("%6.4g")
axesT2.SetFlyModeToOuterEdges()
axesT2.SetFontFactor(1.2)
axesT2.SetAxisTitleTextProperty(tprop)
axesT2.SetAxisLabelTextProperty(tprop)
self.renderer1.AddViewProp(axesT2)
### Update T2Images
t_T2images = vtk.vtkImageChangeInformation()
t_T2images.SetInputData( T2images )
t_T2images.SetOutputOrigin(self.T2origin)
t_T2images.Update()
############
if(interact==True):
interactor = self.renWin1.GetInteractor()
interactor.Start()
return
def __init__(self):
self.data = {
"atom_types": DavTKAtomTypes(),
"colormaps": {},
"cell_box": {
"color": [1.0, 1.0, 1.0],
"opacity": 1.0,
"line_width": 2.0,
"prop": None
},
"background_color": [0.0, 0.0, 0.0],
"picked": {
"color": [1.0, 1.0, 0.0],
"opacity": 1.0,
"prop": None
},
"frame_label": {
"color": [1.0, 1.0, 1.0],
"fontsize": 36,
"prop": None,
"string": "${config_n}",
"show": True
},
"atom_label": {
"color": [1.0, 1.0, 1.0],
"fontsize": 24,
"prop": None,
"string": "$${ID}",
"show": False
},
"frame_step": 1,
"legend": {
'show': False,
'position': np.array([-10, -10]),
'spacing': 1.0,
'sphere_scale': 1.0
},
'atom_type_field': 'Z'
}
self.parsers = {}
self.parser_atom_type_field = ThrowingArgumentParser(
prog="atom_type_field",
description="ASE at.arrays field to use for atom type")
self.parser_atom_type_field.add_argument(
"field",
type=str,
help=
"name of field ('Z' for atomic numbers, 'species' for chemical symbols",
default='Z')
self.parsers["atom_type_field"] = (
self.parse_atom_type_field,
self.parser_atom_type_field.format_usage(),
self.parser_atom_type_field.format_help(),
self.write_atom_type_field)
self.parser_print_settings = ThrowingArgumentParser(
prog="print_settings", description="print settings")
self.parser_print_settings.add_argument("-keyword_regexp", type=str)
self.parsers["print_settings"] = (
self.parse_print_settings,
self.parser_print_settings.format_usage(),
self.parser_print_settings.format_help(), None)
self.parser_legend = ThrowingArgumentParser(
prog="legend", description="control legend, toggle by default")
group = self.parser_legend.add_mutually_exclusive_group()
group.add_argument("-on", action='store_true', help="enable legend")
group.add_argument("-off", action='store_true', help="disable legend")
group = self.parser_legend.add_mutually_exclusive_group()
group.add_argument(
"-position",
type=int,
nargs=2,
help="position relative to bottom left corner of display" +
" (negative values relative to top right)",
default=None)
group.add_argument("-offset",
type=int,
nargs=2,
help="offset relative to current position",
default=None)
self.parser_legend.add_argument(
"-spacing",
type=float,
help="multiplier for spacing between rows",
default=None)
self.parser_legend.add_argument(
"-sphere_scale",
action='store',
type=float,
help="scaling factor for sphere radius",
default=None)
self.parsers["legend"] = (self.parse_legend,
self.parser_legend.format_usage(),
self.parser_legend.format_help(),
self.write_legend)
self.parser_step = ThrowingArgumentParser(
prog="step",
description="number of frames to skip in +/- and prev/next")
self.parser_step.add_argument("n",
type=int,
help="number of frames to step")
self.parsers["step"] = (self.parse_step,
self.parser_step.format_usage(),
self.parser_step.format_help(),
self.write_step)
self.parser_colormap = ThrowingArgumentParser(
prog="colormap",
description="repeated sequence of groups of 4 numbers: V R G B ..."
)
self.parser_colormap.add_argument("name", type=str)
self.parser_colormap.add_argument("-P",
dest="colormap",
nargs=4,
action='append',
type=float,
metavar=('V', 'R', 'G', 'B'))
self.parsers["colormap"] = (self.parse_colormap,
self.parser_colormap.format_usage(),
self.parser_colormap.format_help(),
self.write_colormap)
self.parser_atom_type = ThrowingArgumentParser(prog="atom_type")
self.parser_atom_type.add_argument("name", type=str)
group = self.parser_atom_type.add_mutually_exclusive_group()
group.add_argument("-color",
"-c",
nargs=3,
type=float,
default=None,
metavar=("R", "G", "B"))
group.add_argument("-colormap",
nargs=2,
type=str,
default=None,
metavar=("COLORMAP", "FIELD"))
group = self.parser_atom_type.add_mutually_exclusive_group()
group.add_argument("-radius", "-rad", "-r", type=float, default=None)
group.add_argument("-radius_field",
type=str,
nargs=2,
metavar=("RADIUS_FIELD", "FACTOR"),
default=None)
self.parser_atom_type.add_argument("-bonding_radius",
type=float,
default=None)
add_material_args_to_parser(self.parser_atom_type)
self.parsers["atom_type"] = (self.parse_atom_type,
self.parser_atom_type.format_usage(),
self.parser_atom_type.format_help(),
self.write_atom_type)
self.parser_cell_box = ThrowingArgumentParser(prog="cell_box")
self.parser_cell_box.add_argument("-color",
nargs=3,
type=float,
metavar=['R', 'G', 'B'],
default=None)
self.parser_cell_box.add_argument("-opacity", type=float, default=None)
self.parser_cell_box.add_argument("-width", type=float, default=None)
self.parsers["cell_box"] = (self.parse_cell_box,
self.parser_cell_box.format_usage(),
self.parser_cell_box.format_help(),
self.write_cell_box)
self.parser_picked = ThrowingArgumentParser(prog="picked")
self.parser_picked.add_argument("-color",
nargs=3,
type=float,
metavar=['R', 'G', 'B'])
self.parsers["picked"] = (self.parse_picked,
self.parser_picked.format_usage(),
self.parser_picked.format_help(),
self.write_picked)
self.parser_background_color = ThrowingArgumentParser(
prog="background_color")
self.parser_background_color.add_argument("-color",
nargs=3,
type=float,
metavar=['R', 'G', 'B'])
self.parsers["background_color"] = (
self.parse_background_color,
self.parser_background_color.format_usage(),
self.parser_background_color.format_help(),
self.write_background_color)
self.parser_frame_label = ThrowingArgumentParser(prog="frame_label")
self.parser_frame_label.add_argument(
"-string",
"-s",
type=str,
nargs='+',
help=
"string, evaluating $( EXPRESSION ) and substituting ${STRING} with fields in atoms.info (or 'config_n'), or _NONE_",
default=None)
self.parser_frame_label.add_argument("-color",
"-c",
nargs=3,
type=float,
default=None,
metavar=("R", "G", "B"))
self.parser_frame_label.add_argument("-fontsize",
type=int,
default=None)
group = self.parser_frame_label.add_mutually_exclusive_group()
group.add_argument("-on", action='store_true')
group.add_argument("-off", action='store_true')
self.parsers["frame_label"] = (self.parse_frame_label,
self.parser_frame_label.format_usage(),
self.parser_frame_label.format_help(),
self.write_frame_label)
self.parser_atom_label = ThrowingArgumentParser(prog="atom_label")
self.parser_atom_label.add_argument(
"-string",
type=str,
help=
"string to use for label, evaluating $( EXPRESSION ) and substituting $${STRING} with fields in atoms.arrays "
+
"(or 'ID' for number of atom, 'Z' for atomic number, 'species' for chemical symbol), "
+ "or '_NONE_'",
default=None)
self.parser_atom_label.add_argument("-color",
"-c",
nargs=3,
type=float,
default=None,
metavar=("R", "G", "B"))
self.parser_atom_label.add_argument("-fontsize",
type=int,
default=None)
group = self.parser_atom_label.add_mutually_exclusive_group()
group.add_argument("-on", action='store_true')
group.add_argument("-off", action='store_true')
self.parsers["atom_label"] = (self.parse_atom_label,
self.parser_atom_label.format_usage(),
self.parser_atom_label.format_help(),
self.write_atom_label)
# properties
# 3D Actor properties
for f in ["cell_box", "picked"]:
prop = vtk.vtkProperty()
prop.SetColor(self.data[f]["color"])
prop.SetOpacity(self.data[f]["opacity"])
if "line_width" in self.data[f]:
prop.SetLineWidth(self.data[f]["line_width"])
self.data[f]["prop"] = prop
# make picked very flat
self.data["picked"]["prop"].SetAmbient(0.6)
self.data["picked"]["prop"].SetDiffuse(0.4)
# text properties
for f in ["frame_label", "atom_label"]:
prop = vtk.vtkTextProperty()
self.data[f]["prop"] = prop
prop.SetOpacity(1.0)
prop.SetColor(self.data[f]["color"])
prop.SetFontSize(self.data[f]["fontsize"])
def SetUp(self):
'''
Set up cursor3D
'''
def OnClosing():
self.root.quit()
def AddSphere(ren):
objSource = vtk.vtkSphereSource()
objMapper = vtk.vtkPolyDataMapper()
objMapper.SetInputConnection(objSource.GetOutputPort())
objActor = vtk.vtkActor()
objActor.SetMapper(objMapper)
objActor.GetProperty().SetRepresentationToWireframe()
ren.AddActor(objActor)
def AddOneTextActor(baseTextProp):
name = "ia"
self.textActors[name] = vtk.vtkTextActor3D()
# This adjustment is needed to reduce the difference
# between the Tcl and Python versions.
self.textActors[name].SetOrigin(0, -0.127878, 0)
tprop = self.textActors[name].GetTextProperty()
tprop.ShallowCopy(baseTextProp)
tprop.SetColor(1, 0, 0)
# Add many text actors.
def AddManyTextActors(baseTextProp):
lut = vtk.vtkColorTransferFunction()
lut.SetColorSpaceToHSV()
lut.AddRGBPoint(0.0, 0.0, 1.0, 1.0)
lut.AddRGBPoint(1.0, 1.0, 1.0, 1.0)
for i in range(0, 10):
name = "ia" + str(i)
self.textActors[name] = vtk.vtkTextActor3D()
self.textActors[name].SetOrientation(0, i * 36, 0)
#self.textActors[name].SetPosition(math.cos(i * 0.0314), 0, 0)
# This adjustment is needed to reduce the diffierence
# between the Tcl and Python versions.
self.textActors[name].SetOrigin(0, -0.127878, 0)
tprop = self.textActors[name].GetTextProperty()
tprop.ShallowCopy(baseTextProp)
value = i / 10.0
tprop.SetColor(lut.GetColor(value))
del lut
# Update all text actors
def UpdateTextActors(event):
orientation = self.scaleOrientation.get()
fontSize = self.scaleFontSize.get()
scale = self.scaleScale.get() / 10000.0
text = self.entryText.get("1.0", 'end+1c')
opacity = self.scaleOpacity.get()
for actor in self.textActors.values():
actor.SetScale(scale)
actor.SetInput(text)
tprop = actor.GetTextProperty()
tprop.SetFontSize(fontSize)
tprop.SetOrientation(orientation)
tprop.SetOpacity(opacity)
self.renWin.Render()
ren = vtk.vtkRenderer()
ren.SetBackground(0.1, 0.2, 0.4)
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(ren)
#self.renWin.SetSize(600, 600)
self.root = tkinter.Tk()
self.root.title("TestTextActor3D.py")
# Define what to do when the user explicitly closes a window.
self.root.protocol("WM_DELETE_WINDOW", OnClosing)
# The Tk render widget.
self.tkrw = vtkTkRenderWidget(self.root,
width=450,
height=450,
rw=self.renWin)
self.tkrw.BindTkRenderWidget()
#self.renWin.GetInteractor().GetInteractorStyle().SetCurrentStyleToTrackballCamera()
self.tkrw.pack(side=LEFT, fill=BOTH, expand=YES)
# Base text property
baseTextProp = vtk.vtkTextProperty()
baseTextProp.SetFontSize(48)
baseTextProp.ShadowOn()
baseTextProp.SetColor(1.0, 0.0, 0.0)
baseTextProp.SetFontFamilyToArial()
baseScale = 0.0025
baseText = "This is a test"
# The text actors
self.textActors = dict()
scaleLength = 200
controls = tkinter.Frame(self.root, relief=GROOVE, bd=2)
controls.pack(padx=2,
pady=2,
anchor=N + W,
side=LEFT,
fill=BOTH,
expand=NO)
# Add control of text.
self.entryText = tkinter.Text(controls, height=1, width=25)
self.entryText.insert(INSERT, baseText)
self.entryText.pack(padx=4, pady=4, side=TOP, fill=X, expand=NO)
self.entryText.bind('<Return>', UpdateTextActors)
self.entryText.bind('<FocusOut>', UpdateTextActors)
# Add control of orientation.
self.scaleOrientation = tkinter.Scale(controls,
from_=0,
to=360,
res=1,
length=scaleLength,
orient=HORIZONTAL,
label="Text orientation:",
command=UpdateTextActors)
self.scaleOrientation.set(baseTextProp.GetOrientation())
self.scaleOrientation.pack(side=TOP, fill=X, expand=NO)
# Add control of font size.
self.scaleFontSize = tkinter.Scale(controls,
from_=5,
to=150,
res=1,
length=scaleLength,
orient=HORIZONTAL,
label="Font Size:",
command=UpdateTextActors)
self.scaleFontSize.set(baseTextProp.GetFontSize())
self.scaleFontSize.pack(side=TOP, fill=X, expand=NO)
# Add control of scale.
self.scaleScale = tkinter.Scale(controls,
from_=0,
to=100,
res=1,
length=scaleLength,
orient=HORIZONTAL,
label="Actor scale:",
command=UpdateTextActors)
self.scaleScale.set(baseScale * 10000.0)
self.scaleScale.pack(side=TOP, fill=X, expand=NO)
# Add control of scale.
self.scaleOpacity = tkinter.Scale(controls,
from_=0,
to=1.0,
res=0.01,
length=scaleLength,
orient=HORIZONTAL,
label="Text opacity:",
command=UpdateTextActors)
self.scaleOpacity.set(baseTextProp.GetOpacity())
self.scaleOpacity.pack(side=TOP, fill=X, expand=NO)
# Create and add all the text actors.
if False:
AddSphere(ren)
AddOneTextActor(baseTextProp)
ren.ResetCamera()
else:
AddManyTextActors(baseTextProp)
ren.ResetCamera()
ren.GetActiveCamera().Elevation(30.0)
ren.GetActiveCamera().Dolly(0.40)
UpdateTextActors(0)
for actor in self.textActors.values():
ren.AddActor(actor)
light.SetColor(1, 1, 1)
light.SetFocalPoint(cam1.GetFocalPoint())
light.SetPosition(cam1.GetPosition())
ren.AddLight(light)
print cam1
# axes a la paraview
axes = vtk.vtkAxesActor()
axes.SetShaftTypeToCylinder()
axes.SetXAxisLabelText("x")
axes.SetYAxisLabelText("y")
axes.SetZAxisLabelText("z")
axes.SetTotalLength(1, 1, 1)
tprop = vtk.vtkTextProperty()
tprop.ItalicOn()
# tprop.ShadowOn()
# tprop.SetFontFamilyToTimes()
axes.GetXAxisCaptionActor2D().SetCaptionTextProperty(tprop)
tprop2 = vtk.vtkTextProperty() # inutile
tprop2.ShallowCopy(tprop) # inutile
axes.GetYAxisCaptionActor2D().SetCaptionTextProperty(tprop2)
tprop3 = vtk.vtkTextProperty() # inutile
tprop3.ShallowCopy(tprop) # inutile
axes.GetZAxisCaptionActor2D().SetCaptionTextProperty(tprop3)
marker = vtk.vtkOrientationMarkerWidget()
#marker.SetOutlineColor(0.93, 0.57, 0.13)
marker.SetOrientationMarker(axes)
marker.SetViewport(0.85, 0.8, 1.1, 1.1)
def text_dimensions(text, index, winsize):
prop = vtkTextProperty()
vcs.vcs2vtk.prepTextProperty(prop, winsize, text, text, vcs.getcolormap())
return vcs.vtk_ui.text.text_dimensions(text.string[index], prop)
def set_initial_display(self):
if self.renwininter is None:
self.renwininter = MEQ_QVTKRenderWindowInteractor(self.winsplitter)
self.renwininter.setWhatsThis(rendering_control_instructions)
self.renwin = self.renwininter.GetRenderWindow()
self.inter = self.renwin.GetInteractor()
self.winsplitter.insertWidget(0, self.renwininter)
self.winsplitter.addWidget(self.v_box_controls)
self.winsplitter.setSizes([500, 100])
self.renwininter.show()
# Paul Kemper suggested the following:
camstyle = vtk.vtkInteractorStyleTrackballCamera()
self.renwininter.SetInteractorStyle(camstyle)
self.extents = self.image_array.GetDataExtent()
self.spacing = self.image_array.GetDataSpacing()
self.origin = self.image_array.GetDataOrigin()
# An outline is shown for context.
if self.warped_surface:
self.index_selector.initWarpContextmenu()
sx, sy, sz = self.image_array.GetDataSpacing()
xMin, xMax, yMin, yMax, zMin, zMax = self.image_array.GetDataExtent(
)
xMin = sx * xMin
xMax = sx * xMax
yMin = sy * yMin
yMax = sy * yMax
self.scale_factor = 0.5 * (
(xMax - xMin) +
(yMax - yMin)) / (self.data_max - self.data_min)
zMin = self.data_min * self.scale_factor
zMax = self.data_max * self.scale_factor
self.outline = vtk.vtkOutlineSource()
self.outline.SetBounds(xMin, xMax, yMin, yMax, zMin, zMax)
else:
self.index_selector.init3DContextmenu()
self.outline = vtk.vtkOutlineFilter()
self.outline.SetInput(self.image_array.GetOutput())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInput(self.outline.GetOutput())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
# create blue to red color table
self.lut = vtk.vtkLookupTable()
self.lut.SetHueRange(0.6667, 0.0)
self.lut.SetNumberOfColors(256)
self.lut.Build()
# here is where the 2-D image gets warped
if self.warped_surface:
geometry = vtk.vtkImageDataGeometryFilter()
geometry.SetInput(self.image_array.GetOutput())
self.warp = vtk.vtkWarpScalar()
self.warp.SetInput(geometry.GetOutput())
self.warp.SetScaleFactor(self.scale_factor)
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInput(self.warp.GetPolyDataOutput())
self.mapper.SetScalarRange(self.data_min, self.data_max)
self.mapper.SetLookupTable(self.lut)
self.mapper.ImmediateModeRenderingOff()
warp_actor = vtk.vtkActor()
# warp_actor.SetScale(2,1,1)
warp_actor.SetMapper(self.mapper)
min_range = 0.5 * self.scale_factor
max_range = 2.0 * self.scale_factor
self.index_selector.set_emit(False)
self.index_selector.setMaxValue(max_range, False)
self.index_selector.setMinValue(min_range)
self.index_selector.setTickInterval((max_range - min_range) / 10)
self.index_selector.setRange(max_range, False)
self.index_selector.setValue(self.scale_factor)
self.index_selector.setLabel('display gain')
self.index_selector.hideNDControllerOption()
self.index_selector.reset_scale_toggle()
self.index_selector.set_emit(True)
else:
# set up ImagePlaneWidgets ...
# The shared picker enables us to use 3 planes at one time
# and gets the picking order right
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
# get locations for initial slices
xMin, xMax, yMin, yMax, zMin, zMax = self.extents
x_index = (xMax - xMin) / 2
y_index = (yMax - yMin) / 2
z_index = (zMax - zMin) / 2
# The 3 image plane widgets are used to probe the dataset.
self.planeWidgetX = vtk.vtkImagePlaneWidget()
self.planeWidgetX.DisplayTextOn()
self.planeWidgetX.SetInput(self.image_array.GetOutput())
self.planeWidgetX.SetPlaneOrientationToXAxes()
self.planeWidgetX.SetSliceIndex(x_index)
self.planeWidgetX.SetPicker(picker)
self.planeWidgetX.SetKeyPressActivationValue("x")
self.planeWidgetX.SetLookupTable(self.lut)
self.planeWidgetX.TextureInterpolateOff()
self.planeWidgetX.SetResliceInterpolate(0)
self.planeWidgetY = vtk.vtkImagePlaneWidget()
self.planeWidgetY.DisplayTextOn()
self.planeWidgetY.SetInput(self.image_array.GetOutput())
self.planeWidgetY.SetPlaneOrientationToYAxes()
self.planeWidgetY.SetSliceIndex(y_index)
self.planeWidgetY.SetPicker(picker)
self.planeWidgetY.SetKeyPressActivationValue("y")
self.planeWidgetY.SetLookupTable(
self.planeWidgetX.GetLookupTable())
self.planeWidgetY.TextureInterpolateOff()
self.planeWidgetY.SetResliceInterpolate(0)
self.planeWidgetZ = vtk.vtkImagePlaneWidget()
self.planeWidgetZ.DisplayTextOn()
self.planeWidgetZ.SetInput(self.image_array.GetOutput())
self.planeWidgetZ.SetPlaneOrientationToZAxes()
self.planeWidgetZ.SetSliceIndex(z_index)
self.planeWidgetZ.SetPicker(picker)
self.planeWidgetZ.SetKeyPressActivationValue("z")
self.planeWidgetZ.SetLookupTable(
self.planeWidgetX.GetLookupTable())
self.planeWidgetZ.TextureInterpolateOff()
self.planeWidgetZ.SetResliceInterpolate(0)
self.current_widget = self.planeWidgetZ
self.mode_widget = self.planeWidgetZ
self.index_selector.set_emit(False)
self.index_selector.setMinValue(zMin)
self.index_selector.setMaxValue(zMax, False)
self.index_selector.setTickInterval((zMax - zMin) / 10)
self.index_selector.setRange(zMax, False)
self.index_selector.setValue(z_index)
self.index_selector.setLabel('Z axis')
self.index_selector.reset_scale_toggle()
self.index_selector.set_emit(True)
# create scalar bar for display of intensity range
self.scalar_bar = vtk.vtkScalarBarActor()
self.scalar_bar.SetLookupTable(self.lut)
self.scalar_bar.SetOrientationToVertical()
self.scalar_bar.SetWidth(0.1)
self.scalar_bar.SetHeight(0.8)
self.scalar_bar.SetTitle("Intensity")
self.scalar_bar.GetPositionCoordinate(
).SetCoordinateSystemToNormalizedViewport()
self.scalar_bar.GetPositionCoordinate().SetValue(0.01, 0.1)
# Create the RenderWindow and Renderer
self.ren = vtk.vtkRenderer()
self.renwin.AddRenderer(self.ren)
# Add the outline actor to the renderer, set the background color and size
if self.warped_surface:
self.ren.AddActor(warp_actor)
self.ren.AddActor(outlineActor)
self.ren.SetBackground(0.1, 0.1, 0.2)
self.ren.AddActor2D(self.scalar_bar)
# Create a text property for cube axes
tprop = vtk.vtkTextProperty()
tprop.SetColor(1, 1, 1)
tprop.ShadowOn()
# Create a vtkCubeAxesActor2D. Use the outer edges of the bounding box to
# draw the axes. Add the actor to the renderer.
self.axes = vtk.vtkCubeAxesActor2D()
if self.warped_surface:
if zMin < 0.0 and zMax > 0.0:
zLoc = 0.0
else:
zLoc = zMin
self.axes.SetBounds(xMin, xMax, yMin, yMax, zLoc, zLoc)
self.axes.SetZLabel(" ")
else:
self.axes.SetInput(self.image_array.GetOutput())
self.axes.SetZLabel("Z")
self.axes.SetCamera(self.ren.GetActiveCamera())
self.axes.SetLabelFormat("%6.4g")
self.axes.SetFlyModeToOuterEdges()
self.axes.SetFontFactor(0.8)
self.axes.SetAxisTitleTextProperty(tprop)
self.axes.SetAxisLabelTextProperty(tprop)
self.axes.SetXLabel("X")
self.axes.SetYLabel("Y")
self.ren.AddProp(self.axes)
# Set the interactor for the widgets
if not self.warped_surface:
self.planeWidgetX.SetInteractor(self.inter)
self.planeWidgetX.On()
self.planeWidgetY.SetInteractor(self.inter)
self.planeWidgetY.On()
self.planeWidgetZ.SetInteractor(self.inter)
self.planeWidgetZ.On()
self.initialize_camera()
def __init__(self, interactor, marker, index, display, configurator):
self.interactor = interactor
self.marker = marker
self.index = index
self.configurator = configurator
actors = display.backend["vtk_backend_marker_actors"][index]
self.glyph, self.glyph_source, self.polydata, self.actor, self.geo = actors
self.display = display
self.handles = []
for ind, x in enumerate(marker.x[index]):
y = marker.y[index][ind]
h = vtk_ui.Handle(self.interactor, (x, y),
dragged=self.adjust,
color=(0, 0, 0),
normalize=True)
h.show()
self.handles.append(h)
self.toolbar = vtk_ui.toolbar.Toolbar(self.interactor,
"Marker Options")
self.toolbar.show()
self.toolbar.add_button(["Change Color"], action=self.change_color)
self.toolbar.add_slider_button(marker.size[index],
1,
300,
"Marker Size",
update=self.set_size)
self.type_bar = self.toolbar.add_toolbar("Marker Type",
open_label="Change")
shapes = marker_shapes()
shapes.insert(0, "Select Shape")
self.shape_button = self.type_bar.add_button(shapes,
action=self.change_shape)
wmos = wmo_shapes()
wmos.insert(0, "Select WMO Marker")
self.wmo_button = self.type_bar.add_button(wmos,
action=self.change_wmo)
if self.marker.type[self.index] in shapes:
self.shape_button.set_state(
shapes.index(self.marker.type[self.index]))
else:
self.wmo_button.set_state(wmos.index(self.marker.type[self.index]))
# Used to store the color picker when it's active
self.picker = None
prop = vtk.vtkTextProperty()
prop.SetBackgroundColor(.87, .79, .55)
prop.SetBackgroundOpacity(1)
prop.SetColor(0, 0, 0)
self.tooltip = vtk_ui.Label(
self.interactor,
"%s + Click to place new markers." %
("Cmd" if sys.platform == "darwin" else "Ctrl"),
textproperty=prop)
self.tooltip.left = 0
self.tooltip.top = self.interactor.GetRenderWindow().GetSize(
)[1] - self.tooltip.get_dimensions()[1]
self.tooltip.show()
super(MarkerEditor, self).__init__()
self.register()
def main():
cellName = get_program_parameters()
# Store the cell class names in a dictionary.
cellMap = dict()
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_LINE)] = vtk.VTK_LINE
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_QUADRATIC_EDGE)] = vtk.VTK_QUADRATIC_EDGE
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_CUBIC_LINE)] = vtk.VTK_CUBIC_LINE
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_TRIANGLE)] = vtk.VTK_TRIANGLE
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_QUADRATIC_TRIANGLE)] = vtk.VTK_QUADRATIC_TRIANGLE
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_QUAD)] = vtk.VTK_QUAD
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_QUADRATIC_QUAD)] = vtk.VTK_QUADRATIC_QUAD
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_TETRA)] = vtk.VTK_TETRA
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_HEXAHEDRON)] = vtk.VTK_HEXAHEDRON
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_WEDGE)] = vtk.VTK_WEDGE
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_PYRAMID)] = vtk.VTK_PYRAMID
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_QUADRATIC_WEDGE)] = vtk.VTK_QUADRATIC_WEDGE
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_QUADRATIC_PYRAMID)] = vtk.VTK_QUADRATIC_PYRAMID
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_QUADRATIC_HEXAHEDRON)] = vtk.VTK_QUADRATIC_HEXAHEDRON
cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId(
vtk.VTK_QUADRATIC_TETRA)] = vtk.VTK_QUADRATIC_TETRA
if cellName not in cellMap:
print('Cell type ', cellName, ' is not supported.')
return
source = vtk.vtkCellTypeSource()
source.SetCellType(cellMap[cellName])
source.Update()
print('Cell: ', cellName)
originalPoints = source.GetOutput().GetPoints()
points = vtk.vtkPoints()
points.SetNumberOfPoints(source.GetOutput().GetNumberOfPoints())
rng = vtk.vtkMinimalStandardRandomSequence()
rng.SetSeed(5070) # for testing
for i in range(0, points.GetNumberOfPoints()):
perturbation = [0.0] * 3
for j in range(0, 3):
rng.Next()
perturbation[j] = rng.GetRangeValue(-0.1, 0.1)
currentPoint = [0.0] * 3
originalPoints.GetPoint(i, currentPoint)
points.SetPoint(i, currentPoint[0] + perturbation[0],
currentPoint[1] + perturbation[1],
currentPoint[2] + perturbation[2])
source.GetOutput().SetPoints(points)
numCells = source.GetOutput().GetNumberOfCells()
print('Number of cells: ', numCells)
idArray = vtk.vtkIntArray()
idArray.SetNumberOfTuples(numCells)
for i in range(0, numCells):
idArray.InsertTuple1(i, i + 1)
idArray.SetName('Ids')
source.GetOutput().GetCellData().AddArray(idArray)
source.GetOutput().GetCellData().SetActiveScalars('Ids')
shrink = vtk.vtkShrinkFilter()
shrink.SetInputConnection(source.GetOutputPort())
shrink.SetShrinkFactor(.8)
tessellate = vtk.vtkTessellatorFilter()
tessellate.SetInputConnection(shrink.GetOutputPort())
tessellate.SetMaximumNumberOfSubdivisions(3)
# Create a lookup table to map cell data to colors.
lut = vtk.vtkLookupTable()
colorSeries = vtk.vtkColorSeries()
seriesEnum = colorSeries.BREWER_QUALITATIVE_SET3
colorSeries.SetColorScheme(seriesEnum)
colorSeries.BuildLookupTable(lut, colorSeries.ORDINAL)
# Fill in a few known colors, the rest will be generated if needed.
colors = vtk.vtkNamedColors()
# Create a mapper and actor.
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(source.GetOutputPort())
mapper.SetInputConnection(shrink.GetOutputPort())
mapper.SetScalarRange(0, numCells + 1)
mapper.SetLookupTable(lut)
mapper.SetScalarModeToUseCellData()
mapper.SetResolveCoincidentTopologyToPolygonOffset()
if (source.GetCellType() == vtk.VTK_QUADRATIC_PYRAMID
or source.GetCellType() == vtk.VTK_QUADRATIC_WEDGE):
mapper.SetInputConnection(shrink.GetOutputPort())
else:
mapper.SetInputConnection(tessellate.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().EdgeVisibilityOn()
# actor.GetProperty().SetLineWidth(3)
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(20)
textProperty.SetJustificationToCentered()
textProperty.SetColor(colors.GetColor3d('Lamp_Black'))
textMapper = vtk.vtkTextMapper()
textMapper.SetInput(cellName)
textMapper.SetTextProperty(textProperty)
textActor = vtk.vtkActor2D()
textActor.SetMapper(textMapper)
textActor.SetPosition(320, 20)
# Create a renderer, render window, and interactor.
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetWindowName('CellTypeSource')
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
# Add the actors to the scene.
renderer.AddViewProp(textActor)
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d('Silver'))
renderer.ResetCamera()
renderer.GetActiveCamera().Azimuth(30)
renderer.GetActiveCamera().Elevation(30)
renderer.ResetCameraClippingRange()
# Render and interact.
renderWindow.SetSize(640, 480)
renderWindow.Render()
renderWindowInteractor.Start()
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 CreateMarker(self):
# Create a composite orientation marker using
# vtkAnnotatedCubeActor and vtkAxesActor.
#
cube = vtkAnnotatedCubeActor()
cube.SetXPlusFaceText("R")
cube.SetXMinusFaceText("L")
cube.SetYPlusFaceText("A")
cube.SetYMinusFaceText("P")
cube.SetZPlusFaceText("I")
cube.SetZMinusFaceText("S")
cube.SetXFaceTextRotation(0)
cube.SetYFaceTextRotation(0)
cube.SetZFaceTextRotation(-90)
cube.SetFaceTextScale(0.65)
prop = cube.GetCubeProperty()
prop.SetColor(0.5, 1, 1)
prop = cube.GetTextEdgesProperty()
prop.SetLineWidth(1)
prop.SetDiffuse(0)
prop.SetAmbient(1)
prop.SetColor(0.18, 0.28, 0.23)
for axis, colour in (('X', (0, 0, 1)), ('Y', (0, 1, 0)), ('Z', (1, 0,
0))):
for orient in ('Plus', 'Minus'):
prop = getattr(cube, 'Get' + axis + orient + 'FaceProperty')()
prop.SetColor(*colour)
prop.SetInterpolationToFlat()
continue
continue
axes = vtkAxesActor()
axes.SetShaftTypeToCylinder()
axes.SetXAxisLabelText("x")
axes.SetYAxisLabelText("y")
axes.SetZAxisLabelText("z")
axes.SetTotalLength(1.5, 1.5, 1.5)
tpropx = vtkTextProperty()
tpropx.ItalicOn()
tpropx.ShadowOn()
tpropx.SetFontFamilyToTimes()
axes.GetXAxisCaptionActor2D().SetCaptionTextProperty(tpropx)
tpropy = vtkTextProperty()
tpropy.ShallowCopy(tpropx)
axes.GetYAxisCaptionActor2D().SetCaptionTextProperty(tpropy)
tpropz = vtkTextProperty()
tpropz.ShallowCopy(tpropx)
axes.GetZAxisCaptionActor2D().SetCaptionTextProperty(tpropz)
# Combine the two actors into one with vtkPropAssembly ...
#
assembly = vtkPropAssembly()
assembly.AddPart(axes)
assembly.AddPart(cube)
# Add the composite marker to the widget. The widget
# should be kept in non-interactive mode and the aspect
# ratio of the render window taken into account explicitly,
# since the widget currently does not take this into
# account in a multi-renderer environment.
#
marker = vtkOrientationMarkerWidget()
marker.SetOutlineColor(0.93, 0.57, 0.13)
marker.SetOrientationMarker(assembly)
marker.SetViewport(0.0, 0.0, 0.15, 0.3)
self.OrientationMarker = marker
return
def __init__(self, parent=None, dcm_dir='', view_plane='Transverse'):
"""
建立DICOM VTK 畫布
:param dcm_dir: 影像路徑
:param view_plane: 切面:預設'Transverse',可選'Coronal','Sagittal'
"""
QtWidgets.QMainWindow.__init__(self, parent)
self.frame = QtWidgets.QFrame()
self.vl = QtWidgets.QVBoxLayout()
self.vtkWidget = QVTKRenderWindowInteractor(self)
self.vl.addWidget(self.vtkWidget)
if dcm_dir != '':
self.dcm_series_path = Path(dcm_dir).expanduser()
# set up VTK dicom reader
self.dcmReader = vtkDICOMImageReader()
self.dcmReader.SetDataByteOrderToLittleEndian()
self.dcmReader.SetDirectoryName(str(self.dcm_series_path))
self.dcmRescaleSlope = self.dcmReader.GetRescaleSlope()
self.dcmRescaleOffset = self.dcmReader.GetRescaleOffset()
self.dcmReader.Update()
# '------default with WW & WL-----'
self.ww = 3500 # WW
self.wl = 600 # WL
# '----------viewer---------'
self.dcmViewer = vtk.vtkImageViewer2()
self.dcmViewer.SetInputConnection(self.dcmReader.GetOutputPort())
self.dcmViewer.SetColorLevel(500)
self.dcmViewer.SetColorWindow(3500)
self.dcmViewer.SetSize(600, 600)
self.dcmViewer.UpdateDisplayExtent()
# #!下面那一行確保不會多渲染出一個視窗物件! ##
self.dcmViewer.SetRenderWindow(
self.vtkWidget.GetRenderWindow()) # #!這一行確保不會多渲染出一個視窗物件! # #
# #!上面那一行確保不會多渲染出一個視窗物件! ##
# 下面三個方法可渲染不同人體不同的切面
self.viewPlane = view_plane
if self.viewPlane == 'Coronal':
self.dcmViewer.SetSliceOrientationToXZ() # 冠狀面 (Coronal plane)
elif self.viewPlane == 'Sagittal':
self.dcmViewer.SetSliceOrientationToYZ() # 縱切面 (Sagittal plane)
else:
self.dcmViewer.SetSliceOrientationToXY(
) # Default: 橫狀面 (Transverse plane)
# '----------TextOverLay---------'
# slice status message
self.sliceTextProp = vtk.vtkTextProperty()
self.sliceTextProp.SetFontFamilyToCourier()
self.sliceTextProp.SetFontSize(60)
self.sliceTextProp.SetVerticalJustificationToBottom()
self.sliceTextProp.SetJustificationToLeft()
# '---------set up Text Overlay mapper----------'
self.sliceTextMapper = vtk.vtkTextMapper()
self.current_slice = self.dcmViewer.GetSlice()
print('cur_slice = ', self.current_slice, ' viewer.GetSliceMax() = ',
self.dcmViewer.GetSliceMax())
msg = (
' %d / %d ' %
(self.dcmViewer.GetSlice() + 1, self.dcmViewer.GetSliceMax() + 1))
self.sliceTextMapper.SetInput(msg)
# '---------set up Text Overlay Actor----------'
self.sliceTextActor = vtk.vtkActor2D()
self.sliceTextActor.SetMapper(self.sliceTextMapper)
self.sliceTextActor.SetPosition(15, 10)
# ########--Get RENDERER--############
self.renderer = self.dcmViewer.GetRenderer()
self.renderer.AddActor2D(self.sliceTextActor)
# ########--Set Up RENDER Window--############
self.renderWindow = self.vtkWidget.GetRenderWindow()
self.renderWindow.AddRenderer(self.renderer)
self.vtkWidget.GetRenderWindow().AddRenderer(self.renderer)
# '--------- Interactor ----------'
self.inter = self.renderWindow.GetInteractor()
# ----!Stay in 2D View!-----
self.inter.SetInteractorStyle(
vtkInteractionStyle.vtkInteractorStyleImage())
# '----------add keyboard observer---------'
self.vtkWidget.AddObserver(vtk.vtkCommand.KeyPressEvent,
self.keyboard_callback_func)
self.cam = self.renderer.GetActiveCamera()
if self.viewPlane == 'Coronal':
# self.cam.SetFocalPoint(0, 0, 0) # 设焦点
# self.cam.SetPosition(0, 0, -1) # Camera in Z so it display XY planes. # 设观察对象位
self.cam.SetViewUp(
0, 0, -1
) # Up direction is the X not the y. #(0,0,-1) for Coronal plane
# self.cam.ComputeViewPlaneNormal() # 自动
self.renderer.ResetCamera()
self.frame.setLayout(self.vl)
self.setCentralWidget(self.frame)
self.show()
self.inter.Initialize()
def __init__(self, is_horizontal=False):
"""creates the scalar bar"""
self.scalar_bar = vtk.vtkScalarBarActor()
self.color_function = vtk.vtkColorTransferFunction()
self.color_function.SetNanColor(0., 0., 0.)
self.is_shown = True
self.is_horizontal = False
#self.color_function.SetNanColor(0., 0., 0.)
#self.color_function.SetColorSpaceToLab()
#self.color_function.SetColorSpaceToRGB()
#self.scalar_bar.SetDragable(True)
#self.scalar_bar.SetPickable(True)
# blue - low
# red - high
drange = [10., 20.]
self.color_function.SetColorSpaceToHSV()
self.color_function.HSVWrapOff()
self.color_function.SetRange(*drange)
self.color_function.AddRGBPoint(drange[0], 0.0, 0.0, 1.0)
self.color_function.AddRGBPoint(drange[1], 1.0, 0.0, 0.0)
self.scalar_bar.SetTitle("Title1")
self.scalar_bar.SetLookupTable(self.color_function)
#self.scalar_bar.SetNanColor(0., 0., 0.) # RGB color - black
#self.scalar_bar.SetNanColor(1., 1., 1., 0.) # RGBA color - white
# old
#self.scalar_bar.SetHeight(0.9)
#self.scalar_bar.SetWidth(0.20) # the width is set first
#self.scalar_bar.SetPosition(0.77, 0.1)
if is_horizontal:
# put the scalar bar at the top
self.scalar_bar.SetOrientationToHorizontal()
width = 0.95
height = 0.15
x = (1 - width) / 2.
y = 1 - 0.02 - height
else:
# put the scalar bar at the right side
self.scalar_bar.SetOrientationToVertical()
width = 0.2
height = 0.9
x = 1 - 0.01 - width
y = (1 - height) / 2.
self.scalar_bar.SetPosition(x, y)
# the width is set first
# after the width is set, this is adjusted
self.scalar_bar.SetHeight(height)
self.scalar_bar.SetWidth(width)
self.scalar_bar.SetPosition(x, y)
prop_title = vtk.vtkTextProperty()
prop_title.SetFontFamilyToArial()
#prop_title.ItalicOff()
prop_title.BoldOn()
prop_title.ShadowOn()
prop_label = vtk.vtkTextProperty()
prop_label.BoldOff()
prop_label.ShadowOn()
#self.scalar_bar.SetTitleTextProperty(prop_title)
#self.scalar_bar.SetLabelTextProperty(prop_label)
self.scalar_bar.SetLabelFormat("%i")
# allows 0-1 to be nice number when ranging values (gotta pick something)
self.scalar_bar.SetNumberOfLabels(11)
self.scalar_bar.SetMaximumNumberOfColors(11)
#self.scalar_bar.VisibilityOff() # first load -> scalar bar off
#self.scalar_bar.ShadowOn()
#self.scalar_bar.RepositionableOn()
self.scalar_bar.VisibilityOff()
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# This example demonstrates the use of multiline 2D text using
# vtkTextMappers. It shows several justifications as well as single-line
# and multiple-line text inputs.
#
# First we include the VTK Tcl packages which will make available
# all of the vtk commands to Tcl
#
font_size = 14
# Create the text mappers and the associated Actor2Ds.
# The font and text properties (except justification) are the same for each
# 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)")
def visualize(self, images, image_pos_pat, image_ori_pat, sub, postS, interact=True):
'''Display and render volumes, reference frames, actors and widgets'''
if(sub):
#subtract volumes based on indicated postS
# define image based on subtraction of postS -preS
image = self.subImage(images, postS)
else:
image = images[postS]
# Proceed to build reference frame for display objects based on DICOM coords
[self.transformed_image, transform_cube] = self.dicomTransform(image, image_pos_pat, image_ori_pat)
# get info from image before visualization
self.dims = self.transformed_image.GetDimensions()
print "Image Dimensions"
print self.dims
self.T1spacing = self.transformed_image.GetSpacing()
print "Image Spacing"
print self.T1spacing
self.T1origin = self.transformed_image.GetOrigin()
print "Image Origin"
print self.T1origin
self.T1extent = list(self.transformed_image.GetExtent())
print "Image Extent"
print self.T1extent
# Set up ortogonal planes
self.xImagePlaneWidget.SetInputData( self.transformed_image )
self.xImagePlaneWidget.SetPlaneOrientationToXAxes()
self.xImagePlaneWidget.SetSliceIndex(0)
self.yImagePlaneWidget.SetInputData( self.transformed_image )
self.yImagePlaneWidget.SetPlaneOrientationToYAxes()
self.yImagePlaneWidget.SetSliceIndex(0)
self.zImagePlaneWidget.SetInputData( self.transformed_image )
self.zImagePlaneWidget.SetPlaneOrientationToZAxes()
self.zImagePlaneWidget.SetSliceIndex(0)
self.xImagePlaneWidget.On()
self.yImagePlaneWidget.On()
self.zImagePlaneWidget.On()
# set up cube actor with Orientation(A-P, S-I, L-R) using transform_cube
# Set up to ALS (+X=A, +Y=S, +Z=L) source:
cube = vtk.vtkAnnotatedCubeActor()
cube.SetXPlusFaceText( "L" );
cube.SetXMinusFaceText( "R" );
cube.SetYPlusFaceText( "A" );
cube.SetYMinusFaceText( "P" );
cube.SetZPlusFaceText( "S" );
cube.SetZMinusFaceText( "I" );
cube.SetFaceTextScale( 0.5 );
cube.GetAssembly().SetUserTransform( transform_cube );
# Set UP the axes
axes2 = vtk.vtkAxesActor()
axes2.SetShaftTypeToCylinder();
#axes2.SetUserTransform( transform_cube );
axes2.SetTotalLength( 1.5, 1.5, 1.5 );
axes2.SetCylinderRadius( 0.500 * axes2.GetCylinderRadius() );
axes2.SetConeRadius( 1.025 * axes2.GetConeRadius() );
axes2.SetSphereRadius( 1.500 * axes2.GetSphereRadius() );
tprop2 = axes2.GetXAxisCaptionActor2D()
tprop2.GetCaptionTextProperty();
assembly = vtk.vtkPropAssembly();
assembly.AddPart( axes2 );
assembly.AddPart( cube );
widget = vtk.vtkOrientationMarkerWidget();
widget.SetOutlineColor( 0.9300, 0.5700, 0.1300 );
widget.SetOrientationMarker( assembly );
widget.SetInteractor( self.iren1 );
widget.SetViewport( 0.0, 0.0, 0.4, 0.4 );
widget.SetEnabled( 1 );
widget.InteractiveOff();
# Create a text property for both cube axes
tprop = vtk.vtkTextProperty()
tprop.SetColor(1, 1, 1)
tprop.ShadowOff()
# Create a vtkCubeAxesActor2D. Use the outer edges of the bounding box to
# draw the axes. Add the actor to the renderer.
axes = vtk.vtkCubeAxesActor2D()
axes.SetInputData(self.transformed_image)
axes.SetCamera(self.renderer1.GetActiveCamera())
axes.SetLabelFormat("%6.4g")
axes.SetFlyModeToOuterEdges()
axes.SetFontFactor(1.2)
axes.SetAxisTitleTextProperty(tprop)
axes.SetAxisLabelTextProperty(tprop)
self.renderer1.AddViewProp(axes)
############
# bounds and initialize camera
bounds = self.transformed_image.GetBounds()
self.renderer1.ResetCamera(bounds)
self.renderer1.ResetCameraClippingRange()
self.camera.SetViewUp(0.0,-1.0,0.0)
self.camera.Azimuth(315)
# Initizalize
self.renWin1.Modified()
self.renWin1.Render()
self.renderer1.Render()
if(interact==True):
interactor = self.renWin1.GetInteractor()
interactor.Start()
return
def main():
argc = len(sys.argv)
# Verify input arguments
if argc != 2:
print "Usage: ", sys.argv[0], " FolderName"
return sys.exit(1)
folder = sys.argv[1]
# Read all the DICOM files in the specified directory.
reader = vtk.vtkDICOMImageReader()
reader.SetDirectoryName(folder)
reader.Update()
# Visualize
imageViewer = vtk.vtkImageViewer2()
imageViewer.SetInputConnection(reader.GetOutputPort())
# slice status message
sliceTextProp = vtk.vtkTextProperty()
sliceTextProp.SetFontFamilyToCourier()
sliceTextProp.SetFontSize(20)
sliceTextProp.SetVerticalJustificationToBottom()
sliceTextProp.SetJustificationToLeft()
sliceTextMapper = vtk.vtkTextMapper()
msg = "Slice {} out of {}".format(imageViewer.GetSliceMin() + 1, \
imageViewer.GetSliceMax() + 1)
sliceTextMapper.SetInput(msg)
sliceTextMapper.SetTextProperty(sliceTextProp)
sliceTextActor = vtk.vtkActor2D()
sliceTextActor.SetMapper(sliceTextMapper)
sliceTextActor.SetPosition(15, 10)
# usage hint message
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)
interactor = vtk.vtkInteractorStyleImage()
#interactor.SetImageViewer(imageViewer)
#interactor.SetStatusMapper(sliceTextMapper)
#imageViewer.SetupInteractor(renWin)
#renderWindowInteractor.SetInteractorStyle(myInteractorStyle)
# add slice status message and usage hint message to the renderer
imageViewer.GetRenderer().AddActor2D(sliceTextActor)
imageViewer.GetRenderer().AddActor2D(usageTextActor)
def main():
font_size = 24
# Create the text mappers and the associated Actor2Ds.
# The font and text properties (except justification) are the same for
# each 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()
multiLineTextProp.SetLineSpacing(0.8)
colors = vtk.vtkNamedColors()
# 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(colors.GetColor3d("Tomato"))
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()
tprop.SetColor(colors.GetColor3d("DarkGreen"))
singleLineTextActorC = vtk.vtkActor2D()
singleLineTextActorC.SetMapper(singleLineTextC)
singleLineTextActorC.GetPositionCoordinate(
).SetCoordinateSystemToNormalizedDisplay()
singleLineTextActorC.GetPositionCoordinate().SetValue(0.05, 0.75)
# The text is on a single line and top-justified.
singleLineTextT = vtk.vtkTextMapper()
singleLineTextT.SetInput("Single line (top)")
tprop = singleLineTextT.GetTextProperty()
tprop.ShallowCopy(singleLineTextProp)
tprop.SetVerticalJustificationToTop()
tprop.SetColor(colors.GetColor3d("Peacock"))
singleLineTextActorT = vtk.vtkActor2D()
singleLineTextActorT.SetMapper(singleLineTextT)
singleLineTextActorT.GetPositionCoordinate(
).SetCoordinateSystemToNormalizedDisplay()
singleLineTextActorT.GetPositionCoordinate().SetValue(0.05, 0.65)
# The text is on multiple lines and left- and top-justified.
textMapperL = vtk.vtkTextMapper()
textMapperL.SetInput("This is\nmulti-line\ntext output\n(left-top)")
tprop = textMapperL.GetTextProperty()
tprop.ShallowCopy(multiLineTextProp)
tprop.SetJustificationToLeft()
tprop.SetVerticalJustificationToTop()
tprop.SetColor(colors.GetColor3d("Tomato"))
textActorL = vtk.vtkActor2D()
textActorL.SetMapper(textMapperL)
textActorL.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay()
textActorL.GetPositionCoordinate().SetValue(0.05, 0.5)
# The text is on multiple lines and center-justified (both horizontal and vertical).
textMapperC = vtk.vtkTextMapper()
textMapperC.SetInput("This is\nmulti-line\ntext output\n(centered)")
tprop = textMapperC.GetTextProperty()
tprop.ShallowCopy(multiLineTextProp)
tprop.SetJustificationToCentered()
tprop.SetVerticalJustificationToCentered()
tprop.SetColor(colors.GetColor3d("DarkGreen"))
textActorC = vtk.vtkActor2D()
textActorC.SetMapper(textMapperC)
textActorC.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay()
textActorC.GetPositionCoordinate().SetValue(0.5, 0.5)
# The text is on multiple lines and right- and bottom-justified.
textMapperR = vtk.vtkTextMapper()
textMapperR.SetInput("This is\nmulti-line\ntext output\n(right-bottom)")
tprop = textMapperR.GetTextProperty()
tprop.ShallowCopy(multiLineTextProp)
tprop.SetJustificationToRight()
tprop.SetVerticalJustificationToBottom()
tprop.SetColor(colors.GetColor3d("Peacock"))
textActorR = vtk.vtkActor2D()
textActorR.SetMapper(textMapperR)
textActorR.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay()
textActorR.GetPositionCoordinate().SetValue(0.95, 0.5)
# Draw the grid to demonstrate the placement of the text.
# Set up the necessary points.
Pts = vtk.vtkPoints()
Pts.InsertNextPoint(0.05, 0.0, 0.0)
Pts.InsertNextPoint(0.05, 1.0, 0.0)
Pts.InsertNextPoint(0.5, 0.0, 0.0)
Pts.InsertNextPoint(0.5, 1.0, 0.0)
Pts.InsertNextPoint(0.95, 0.0, 0.0)
Pts.InsertNextPoint(0.95, 1.0, 0.0)
Pts.InsertNextPoint(0.0, 0.5, 0.0)
Pts.InsertNextPoint(1.0, 0.5, 0.0)
Pts.InsertNextPoint(0.00, 0.85, 0.0)
Pts.InsertNextPoint(0.50, 0.85, 0.0)
Pts.InsertNextPoint(0.00, 0.75, 0.0)
Pts.InsertNextPoint(0.50, 0.75, 0.0)
Pts.InsertNextPoint(0.00, 0.65, 0.0)
Pts.InsertNextPoint(0.50, 0.65, 0.0)
# Set up the lines that use these points.
Lines = vtk.vtkCellArray()
Lines.InsertNextCell(2)
Lines.InsertCellPoint(0)
Lines.InsertCellPoint(1)
Lines.InsertNextCell(2)
Lines.InsertCellPoint(2)
Lines.InsertCellPoint(3)
Lines.InsertNextCell(2)
Lines.InsertCellPoint(4)
Lines.InsertCellPoint(5)
Lines.InsertNextCell(2)
Lines.InsertCellPoint(6)
Lines.InsertCellPoint(7)
Lines.InsertNextCell(2)
Lines.InsertCellPoint(8)
Lines.InsertCellPoint(9)
Lines.InsertNextCell(2)
Lines.InsertCellPoint(10)
Lines.InsertCellPoint(11)
Lines.InsertNextCell(2)
Lines.InsertCellPoint(12)
Lines.InsertCellPoint(13)
# Create a grid that uses these points and lines.
Grid = vtk.vtkPolyData()
Grid.SetPoints(Pts)
Grid.SetLines(Lines)
# Set up the coordinate system.
normCoords = vtk.vtkCoordinate()
normCoords.SetCoordinateSystemToNormalizedViewport()
# Set up the mapper and actor (2D) for the grid.
mapper = vtk.vtkPolyDataMapper2D()
mapper.SetInputData(Grid)
mapper.SetTransformCoordinate(normCoords)
gridActor = vtk.vtkActor2D()
gridActor.SetMapper(mapper)
gridActor.GetProperty().SetColor(colors.GetColor3d("DimGray"))
# Create the Renderer, RenderWindow, and RenderWindowInteractor
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
# Add the actors to the renderer set the background and size zoom in closer to the image render
renderer.AddActor2D(textActorL)
renderer.AddActor2D(textActorC)
renderer.AddActor2D(textActorR)
renderer.AddActor2D(singleLineTextActorB)
renderer.AddActor2D(singleLineTextActorC)
renderer.AddActor2D(singleLineTextActorT)
renderer.AddActor2D(gridActor)
renderer.SetBackground(colors.GetColor3d("Silver"))
renderWindow.SetSize(640, 480)
renderer.GetActiveCamera().Zoom(1.5)
# Enable user interface interactor
interactor.Initialize()
renderWindow.Render()
interactor.Start()
def main():
colors = vtk.vtkNamedColors()
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(10)
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("White"))
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(100, 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()
rendererSize = 200
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("SlateGray"))
renderers[index].ResetCamera()
renderers[index].GetActiveCamera().Azimuth(30)
renderers[index].GetActiveCamera().Elevation(30)
renderers[index].GetActiveCamera().Zoom(0.9)
renderers[index].ResetCameraClippingRange()
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
def _plotInternal(self):
"""Overrides baseclass implementation."""
tmpLevels = []
tmpColors = []
tmpLineWidths = []
tmpLineTypes = []
linewidth = self._gm.linewidths
self.extendAttribute(linewidth, default=1.0)
linetype = self._gm.linetypes
self.extendAttribute(linetype, default='solid')
plotting_dataset_bounds = self.getPlottingBounds()
x1, x2, y1, y2 = plotting_dataset_bounds
for i, lv_tmp in enumerate(self._contourLevels):
if i == 0:
W = linewidth[i]
S = linetype[i]
C = [self._contourColors[i]]
if lv_tmp == 1.e20:
L = [-1.e20]
else:
L = [lv_tmp]
else:
if W == linewidth[i] and S == linetype[i]:
# Ok same style and width, lets keep going
L.append(lv_tmp)
C.append(self._contourColors[i])
else:
tmpLevels.append(L)
tmpColors.append(C)
tmpLineWidths.append(W)
tmpLineTypes.append(S)
L = [lv_tmp]
C = [self._contourColors[i]]
W = linewidth[i]
S = linetype[i]
tmpLevels.append(L)
tmpColors.append(C)
tmpLineWidths.append(W)
tmpLineTypes.append(S)
cots = []
textprops = []
luts = []
actors = []
mappers = []
if self._gm.label and (self._gm.text or self._gm.textcolors):
# Text objects:
if self._gm.text:
texts = self._gm.text
while len(texts) < len(self._contourLevels):
texts.append(texts[-1])
else:
texts = [None] * len(self._contourLevels)
# Custom colors:
if self._gm.textcolors:
colorOverrides = self._gm.textcolors
while len(colorOverrides) < len(self._contourLevels):
colorOverrides.append(colorOverrides[-1])
else:
colorOverrides = [None] * len(self._gm.text)
# Custom background colors and opacities:
backgroundColors = self._gm.labelbackgroundcolors
if backgroundColors:
while len(backgroundColors) < len(self._contourLevels):
backgroundColors.append(backgroundColors[-1])
backgroundOpacities = self._gm.labelbackgroundopacities
if backgroundOpacities:
while len(backgroundOpacities) < len(self._contourLevels):
backgroundOpacities.append(backgroundOpacities[-1])
countLevels = 0
vp = self._resultDict.get('ratio_autot_viewport', [
self._template.data.x1, self._template.data.x2,
self._template.data.y1, self._template.data.y2
])
dataset_renderer = None
xScale, yScale = (1, 1)
for i, l in enumerate(tmpLevels):
numLevels = len(l)
cot = vtk.vtkContourFilter()
if self._hasCellData:
cot.SetInputConnection(self._vtkPolyDataFilter.GetOutputPort())
else:
cot.SetInputData(self._vtkDataSet)
cot.SetNumberOfContours(numLevels)
for n in range(numLevels):
cot.SetValue(n, l[n])
# TODO remove update
cot.Update()
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(len(tmpColors[i]))
cmap = self.getColorMap()
for n, col in enumerate(tmpColors[i]):
r, g, b, a = self.getColorIndexOrRGBA(cmap, col)
lut.SetTableValue(n, r / 100., g / 100., b / 100., a / 100.)
# Setup isoline labels
if self._gm.label:
# Setup label mapping array:
tpropMap = vtk.vtkDoubleArray()
tpropMap.SetNumberOfComponents(1)
tpropMap.SetNumberOfTuples(numLevels)
for n, val in enumerate(l):
tpropMap.SetTuple(n, [val])
# Prep text properties:
tprops = vtk.vtkTextPropertyCollection()
if self._gm.text or self._gm.textcolors:
ttexts = texts[countLevels:(countLevels + len(l))]
for idx, tc in enumerate(ttexts):
if vcs.queries.istextcombined(tc):
tt, to = tuple(tc.name.split(":::"))
elif tc is None:
tt = "default"
to = "default"
elif vcs.queries.istexttable(tc):
tt = tc.name
to = "default"
elif vcs.queries.istextorientation(tc):
to = tc.name
tt = "default"
elif isinstance(tc, str):
sp = tc.split(":::")
if len(sp) == 2:
tt = sp[0]
to = sp[1]
else: # Hum don't know what do do with this
if sp[0] in vcs.listelements("textcombined"):
tc = vcs.gettextcombined(tc)
tt, to = tuple(tc.name.split(":::"))
elif sp[0] in vcs.listelements(
"textorientation"):
to = sp[0]
tt = "default"
elif sp[0] in vcs.listelements("texttable"):
tt = sp[0]
to = "default"
colorOverride = colorOverrides[countLevels + idx]
if colorOverride is not None:
tt = vcs.createtexttable(None, tt)
tt.color = colorOverride
tt = tt.name
if backgroundColors is not None:
texttbl = vcs.gettexttable(tt)
texttbl.backgroundcolor = backgroundColors[
countLevels + idx]
if backgroundOpacities is not None:
texttbl = vcs.gettexttable(tt)
texttbl.backgroundopacity = backgroundOpacities[
countLevels + idx]
tprop = vtk.vtkTextProperty()
vcs2vtk.prepTextProperty(
tprop,
self._context().renWin.GetSize(),
to,
tt,
cmap=cmap)
tprops.AddItem(tprop)
if colorOverride is not None:
del (vcs.elements["texttable"][tt])
else: # No text properties specified. Use the default:
tprop = vtk.vtkTextProperty()
vcs2vtk.prepTextProperty(tprop,
self._context().renWin.GetSize(),
cmap=cmap)
tprops.AddItem(tprop)
textprops.append(tprops)
mapper = vtk.vtkLabeledContourMapper()
mapper.SetTextProperties(tprops)
mapper.SetTextPropertyMapping(tpropMap)
mapper.SetLabelVisibility(1)
mapper.SetSkipDistance(self._gm.labelskipdistance)
pdMapper = mapper.GetPolyDataMapper()
luts.append([lut, [l[0], l[-1], False]])
else: # No isoline labels:
mapper = vtk.vtkPolyDataMapper()
pdMapper = mapper
luts.append([lut, [l[0], l[-1], False]])
pdMapper.SetLookupTable(lut)
pdMapper.SetScalarRange(l[0], l[-1])
pdMapper.SetScalarModeToUsePointData()
stripper = vtk.vtkStripper()
stripper.SetInputConnection(cot.GetOutputPort())
mapper.SetInputConnection(stripper.GetOutputPort())
# TODO remove update, make pipeline
stripper.Update()
mappers.append(mapper)
cots.append(cot)
# Create actor to add to scene
act = vtk.vtkActor()
act.SetMapper(mapper)
# Set line properties here
p = act.GetProperty()
p.SetLineWidth(tmpLineWidths[i])
vcs2vtk.stippleLine(p, tmpLineTypes[i])
actors.append([act, plotting_dataset_bounds])
# create a new renderer for this mapper
# (we need one for each mapper because of cmaera flips)
dataset_renderer, xScale, yScale = self._context().fitToViewport(
act,
vp,
wc=plotting_dataset_bounds,
geoBounds=self._vtkDataSetBoundsNoMask,
geo=self._vtkGeoTransform,
priority=self._template.data.priority,
create_renderer=(dataset_renderer is None))
countLevels += len(l)
if len(textprops) > 0:
self._resultDict["vtk_backend_contours_labels_text_properties"] = \
textprops
if len(luts) > 0:
if self._gm.label:
self._resultDict["vtk_backend_labeled_luts"] = luts
else:
self._resultDict["vtk_backend_luts"] = luts
if len(cots) > 0:
self._resultDict["vtk_backend_contours"] = cots
if self._maskedDataMapper is not None:
mappers.insert(0, self._maskedDataMapper)
act = vtk.vtkActor()
act.SetMapper(self._maskedDataMapper)
actors.append(
[act, self._maskedDataMapper, plotting_dataset_bounds])
# create a new renderer for this mapper
# (we need one for each mapper because of cmaera flips)
self._context().fitToViewport(
act,
vp,
wc=plotting_dataset_bounds,
geoBounds=self._vtkDataSetBoundsNoMask,
geo=self._vtkGeoTransform,
priority=self._template.data.priority,
create_renderer=True)
self._resultDict["vtk_backend_actors"] = actors
t = self._originalData1.getTime()
if self._originalData1.ndim > 2:
z = self._originalData1.getAxis(-3)
else:
z = None
kwargs = {
"vtk_backend_grid": self._vtkDataSet,
"dataset_bounds": self._vtkDataSetBounds,
"plotting_dataset_bounds": plotting_dataset_bounds,
"vtk_dataset_bounds_no_mask": self._vtkDataSetBoundsNoMask,
"vtk_backend_geo": self._vtkGeoTransform
}
if ("ratio_autot_viewport" in self._resultDict):
kwargs["ratio_autot_viewport"] = vp
self._resultDict.update(self._context().renderTemplate(
self._template, self._data1, self._gm, t, z, **kwargs))
if self._context().canvas._continents is None:
self._useContinents = False
if self._useContinents:
projection = vcs.elements["projection"][self._gm.projection]
continents_renderer, xScale, yScale = self._context(
).plotContinents(plotting_dataset_bounds, projection,
self._dataWrapModulo, vp,
self._template.data.priority, **kwargs)
