def createSliderWidget( self, index ):
sliderRep = vtk.vtkSliderRepresentation2D()
sliderRep.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
sliderRep.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
prop = sliderRep.GetSliderProperty()
prop.SetColor( 1.0, 0.0, 0.0 )
prop.SetOpacity( 0.5 )
sprop = sliderRep.GetSelectedProperty()
sprop.SetOpacity( 0.8 )
tprop = sliderRep.GetTubeProperty()
tprop.SetColor( 0.5, 0.5, 0.5 )
tprop.SetOpacity( 0.5 )
cprop = sliderRep.GetCapProperty()
cprop.SetColor( 0.0, 0.0, 1.0 )
cprop.SetOpacity( 0.5 )
# sliderRep.PlaceWidget( bounds )
sliderRep.SetSliderLength(0.05)
sliderRep.SetSliderWidth(0.02)
sliderRep.SetTubeWidth(0.01)
sliderRep.SetEndCapLength(0.02)
sliderRep.SetEndCapWidth(0.02)
sliderRep.SetTitleHeight( 0.02 )
sliderWidget = vtk.vtkSliderWidget()
sliderWidget.SetInteractor(self.interactor)
sliderWidget.SetRepresentation( sliderRep )
sliderWidget.SetAnimationModeToAnimate()
sliderWidget.EnabledOn()
sliderWidget.AddObserver("StartInteractionEvent", self.processStartInteractionEvent )
sliderWidget.AddObserver("EndInteractionEvent", self.processEndInteractionEvent )
sliderWidget.AddObserver("InteractionEvent", self.processInteractionEvent )
sliderWidget.KeyPressActivationOff()
return sliderWidget
def CreateSlider(renWinInteractor, plane, y):
#build a slide bar
slideBar = vtk.vtkSliderRepresentation2D()
slideBar.SetMinimumValue(3.0)
slideBar.SetMaximumValue(20.0)
slideBar.SetTitleText("sphere")
slideBar.GetSliderProperty().SetColor(1, 0, 0)
slideBar.GetTitleProperty().SetColor(1, 0, 0)
slideBar.GetLabelProperty().SetColor(1, 0, 0)
slideBar.GetSelectedProperty().SetColor(1, 0, 0)
slideBar.GetTubeProperty().SetColor(0, 1, 0)
slideBar.GetCapProperty().SetColor(1, 1, 0)
slideBar.GetPoint1Coordinate().SetCoordinateSystemToDisplay()
slideBar.GetPoint1Coordinate().SetValue(40, 40 + y)
slideBar.GetPoint2Coordinate().SetCoordinateSystemToDisplay()
slideBar.GetPoint2Coordinate().SetValue(200, 40 + y)
sliderWidget = vtk.vtkSliderWidget()
sliderWidget.SetInteractor(renWinInteractor)
sliderWidget.SetRepresentation(slideBar)
sliderWidget.EnabledOn()
def myCallback(obj, event):
print obj.__class__.__name__, " called"
value = int(obj.GetRepresentation().GetValue())
plane.SetSliceIndex(value)
sliderWidget.AddObserver("InteractionEvent", myCallback)
def createSliderWidget( self, index ):
sliderRep = vtk.vtkSliderRepresentation2D()
sliderRep.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
sliderRep.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
prop = sliderRep.GetSliderProperty()
prop.SetColor( 1.0, 0.0, 0.0 )
prop.SetOpacity( 0.5 )
sprop = sliderRep.GetSelectedProperty()
sprop.SetOpacity( 0.8 )
tprop = sliderRep.GetTubeProperty()
tprop.SetColor( 0.5, 0.5, 0.5 )
tprop.SetOpacity( 0.5 )
cprop = sliderRep.GetCapProperty()
cprop.SetColor( 0.0, 0.0, 1.0 )
cprop.SetOpacity( 0.5 )
# sliderRep.PlaceWidget( bounds )
sliderRep.SetSliderLength(0.05)
sliderRep.SetSliderWidth(0.02)
sliderRep.SetTubeWidth(0.01)
sliderRep.SetEndCapLength(0.02)
sliderRep.SetEndCapWidth(0.02)
sliderRep.SetTitleHeight( 0.02 )
sliderWidget = vtk.vtkSliderWidget()
sliderWidget.SetInteractor(self.interactor)
sliderWidget.SetRepresentation( sliderRep )
sliderWidget.SetAnimationModeToAnimate()
sliderWidget.EnabledOn()
sliderWidget.AddObserver("StartInteractionEvent", self.processStartInteractionEvent )
sliderWidget.AddObserver("EndInteractionEvent", self.processEndInteractionEvent )
sliderWidget.AddObserver("InteractionEvent", self.processInteractionEvent )
sliderWidget.KeyPressActivationOff()
return sliderWidget
def make_slider(title, observer, interactor,
startvalue, minvalue, maxvalue, cx1, cy1, cx2, cy2):
slider_repres = vtk.vtkSliderRepresentation2D()
slider_repres.SetMinimumValue(minvalue - (maxvalue - minvalue) / 100)
slider_repres.SetMaximumValue(maxvalue + (maxvalue - minvalue) / 100)
slider_repres.SetValue(startvalue)
slider_repres.SetTitleText(title)
slider_repres.GetPoint1Coordinate().\
SetCoordinateSystemToNormalizedDisplay()
slider_repres.GetPoint1Coordinate().SetValue(cx1, cy1)
slider_repres.GetPoint2Coordinate().\
SetCoordinateSystemToNormalizedDisplay()
slider_repres.GetPoint2Coordinate().SetValue(cx2, cy2)
slider_repres.SetSliderLength(0.02)
slider_repres.SetSliderWidth(0.03)
slider_repres.SetEndCapLength(0.01)
slider_repres.SetEndCapWidth(0.03)
slider_repres.SetTubeWidth(0.005)
slider_repres.SetLabelFormat('%f')
slider_repres.SetTitleHeight(0.02)
slider_repres.SetLabelHeight(0.02)
slider_widget = vtk.vtkSliderWidget()
slider_widget.SetInteractor(interactor)
slider_widget.SetRepresentation(slider_repres)
slider_widget.KeyPressActivationOff()
slider_widget.SetAnimationModeToAnimate()
slider_widget.SetEnabled(True)
slider_widget.AddObserver('InteractionEvent', observer)
return slider_widget, slider_repres
def __set_up_slider(self):
# slider gui
self.slider_rep = vtk.vtkSliderRepresentation2D()
self.slider_rep.SetMinimumValue(self.slider_min)
self.slider_rep.SetMaximumValue(self.slider_max)
self.slider_rep.SetValue((self.slider_max - self.slider_min) / 2.0)
self.slider_rep.SetTitleText(self.axes_name[self.axis] +
" - right click to switch axis")
self.slider_rep.GetSliderProperty().SetColor(1, 1, 0.1)
self.slider_rep.GetSelectedProperty().SetColor(0, 1, 0)
self.slider_rep.GetCapProperty().SetColor(0, 0.2, 0.5)
self.slider_rep.GetTubeProperty().SetColor(0, 0.1, 0.4)
self.slider_rep.GetPoint1Coordinate().SetCoordinateSystemToDisplay()
self.slider_rep.GetPoint1Coordinate().SetValue(60, 450)
self.slider_rep.GetPoint2Coordinate().SetCoordinateSystemToDisplay()
self.slider_rep.GetPoint2Coordinate().SetValue(260, 450)
# handling slider event
self.slider_wid = vtk.vtkSliderWidget()
self.slider_wid.SetInteractor(self.iren)
self.slider_wid.SetRepresentation(self.slider_rep)
self.slider_wid.EnabledOn()
self.slider_wid.AddObserver(vtk.vtkCommand.InteractionEvent,
self.slider_call_back)
def __init__(self, project, parent):
super().__init__()
self.parent = parent
self.project = project
self.rendererEntity = RendererEntity(self.project, self)
self.rendererElement = RendererElement(self.project, self)
self.rendererPoint = RendererPoint(self.project, self)
self.rendererAnalysis = RendererPostProcessing(self.project, self)
self.slider2d = vtk.vtkSliderRepresentation2D()
self.sliderScale = 1
self.sliderEnable = False
self.currentFrequencyIndice = -1
self.needResetCamera = True
#Set initial plot & config
self.SetInteractorStyle(self.rendererEntity.getStyle())
self.GetRenderWindow().AddRenderer(self.rendererEntity.getRenderer())
self.rendererEntity.resetCamera()
self.update()
self._createAxes()
self.Initialize() #VTK Initialize - Don't remove this function
def slider(renderer, maximum, x, y, renderWindowInteractor, title):
sliderRep = vtk.vtkSliderRepresentation2D()
sliderRep.SetRenderer(renderer)
sliderRep.SetMinimumValue(0)
sliderRep.SetMaximumValue(maximum)
if title == 'point size':
sliderRep.SetValue(0.05)
elif title == 'record':
sliderRep.SetValue(1)
elif title == 'person':
sliderRep.SetValue(max_person)
sliderRep.SetTitleText(title)
sliderRep.GetPoint1Coordinate().SetCoordinateSystemToDisplay()
sliderRep.GetPoint1Coordinate().SetValue(x, y)
sliderRep.GetPoint2Coordinate().SetCoordinateSystemToDisplay()
sliderRep.GetPoint2Coordinate().SetValue(x + 400, y)
sliderRep.BuildRepresentation()
sliderWidget = vtk.vtkSliderWidget()
sliderWidget.SetInteractor(renderWindowInteractor)
sliderWidget.SetRepresentation(sliderRep)
sliderWidget.SetAnimationModeToAnimate()
sliderWidget.EnabledOn()
return sliderRep, sliderWidget
def add_widgets(self):
# axes
axes = vtk.vtkAxesActor()
self.marker_widget = vtk.vtkOrientationMarkerWidget()
self.marker_widget.SetInteractor(self.iren)
self.marker_widget.SetOrientationMarker(axes)
self.marker_widget.SetViewport(0.0, 0.0, 0.25, 0.25)
# scalar bar
self.scalarbar_actor = vtk.vtkScalarBarActor()
self.scalarbar_actor.SetLookupTable(self.lut)
self.scalarbar_widget = vtk.vtkScalarBarWidget()
self.scalarbar_widget.SetInteractor(self.iren)
self.scalarbar_widget.SetScalarBarActor(self.scalarbar_actor)
# contour slider
self.slider_rep = vtk.vtkSliderRepresentation2D()
self.slider_rep.SetTitleText("contour")
self.slider_rep.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedViewport()
self.slider_rep.GetPoint1Coordinate().SetValue(0.65, 0.1)
self.slider_rep.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedViewport()
self.slider_rep.GetPoint2Coordinate().SetValue(0.95, 0.1)
self.slider_widget = vtk.vtkSliderWidget()
self.slider_widget.SetInteractor(self.iren)
self.slider_widget.SetRepresentation(self.slider_rep)
self.slider_widget.SetAnimationModeToAnimate()
self.slider_widget.AddObserver(vtk.vtkCommand.InteractionEvent,
self.update_contour)
def MakeWidget(widget, tessellate, textMapper, interactor):
# Setup a slider widget for each varying parameter
tubeWidth = 0.008
sliderLength = 0.008
titleHeight = 0.04
labelHeight = 0.04
sliderRepChordError = vtk.vtkSliderRepresentation2D()
sliderRepChordError.SetMinimumValue(0.0)
sliderRepChordError.SetMaximumValue(0.07)
sliderRepChordError.SetValue(tessellate.GetChordError())
sliderRepChordError.SetTitleText('Chord error')
sliderRepChordError.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
sliderRepChordError.GetPoint1Coordinate().SetValue(0.1, 0.1)
sliderRepChordError.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
sliderRepChordError.GetPoint2Coordinate().SetValue(0.9, 0.1)
sliderRepChordError.SetTubeWidth(tubeWidth)
sliderRepChordError.SetSliderLength(sliderLength)
sliderRepChordError.SetTitleHeight(titleHeight)
sliderRepChordError.SetLabelHeight(labelHeight)
widget.SetInteractor(interactor)
widget.SetRepresentation(sliderRepChordError)
widget.SetAnimationModeToAnimate()
widget.EnabledOn()
widget.AddObserver(vtk.vtkCommand.InteractionEvent,
SliderCallbackChordError(tessellate, textMapper))
def generate_slide_bar():
# Slidebar colors
red_r = 224/255
red_g = 69/255
red_b = 85/255
green_r = 70/255
green_g = 224/255
green_b = 105/255
white = 242/255
# Create Slidebar
slide_bar = vtk.vtkSliderRepresentation2D()
# Set range and title.
slide_bar.SetMinimumValue(-100.0)
slide_bar.SetMaximumValue(100.0)
slide_bar.SetValue(0)
slide_bar.SetTitleText("Scalar Value")
# Set colors.
slide_bar.GetSliderProperty().SetColor(red_r, red_g, red_b)
slide_bar.GetTitleProperty().SetColor(white, white, white)
slide_bar.GetLabelProperty().SetColor(red_r, red_g, red_b)
slide_bar.GetSelectedProperty().SetColor(green_r, green_g, green_b)
slide_bar.GetTubeProperty().SetColor(white, white, white)
slide_bar.GetCapProperty().SetColor(red_r, red_g, red_b)
# Set coordinates.
slide_bar.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
slide_bar.GetPoint1Coordinate().SetValue(0.78, 0.1)
slide_bar.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
slide_bar.GetPoint2Coordinate().SetValue(0.98 , 0.1)
return slide_bar
def make_slider(title, observer, interactor, startvalue, minvalue,
maxvalue, cx1, cy1, cx2, cy2):
slider_repres = vtk.vtkSliderRepresentation2D()
slider_repres.SetMinimumValue(minvalue -
(maxvalue - minvalue) / 100)
slider_repres.SetMaximumValue(maxvalue +
(maxvalue - minvalue) / 100)
slider_repres.SetValue(startvalue)
slider_repres.SetTitleText(title)
slider_repres.GetPoint1Coordinate().\
SetCoordinateSystemToNormalizedDisplay()
slider_repres.GetPoint1Coordinate().SetValue(cx1, cy1)
slider_repres.GetPoint2Coordinate().\
SetCoordinateSystemToNormalizedDisplay()
slider_repres.GetPoint2Coordinate().SetValue(cx2, cy2)
slider_repres.SetSliderLength(0.02)
slider_repres.SetSliderWidth(0.03)
slider_repres.SetEndCapLength(0.01)
slider_repres.SetEndCapWidth(0.03)
slider_repres.SetTubeWidth(0.005)
slider_repres.SetLabelFormat('%f')
slider_repres.SetTitleHeight(0.02)
slider_repres.SetLabelHeight(0.02)
slider_widget = vtk.vtkSliderWidget()
slider_widget.SetInteractor(interactor)
slider_widget.SetRepresentation(slider_repres)
slider_widget.KeyPressActivationOff()
slider_widget.SetAnimationModeToAnimate()
slider_widget.SetEnabled(True)
slider_widget.AddObserver('InteractionEvent', observer)
return slider_widget, slider_repres
def CreateSlider(renWinInteractor,plane,y):
#build a slide bar
slideBar = vtk.vtkSliderRepresentation2D()
slideBar.SetMinimumValue(3.0)
slideBar.SetMaximumValue(20.0)
slideBar.SetTitleText("sphere")
slideBar.GetSliderProperty().SetColor(1,0,0)
slideBar.GetTitleProperty().SetColor(1,0,0)
slideBar.GetLabelProperty().SetColor(1,0,0)
slideBar.GetSelectedProperty().SetColor(1,0,0)
slideBar.GetTubeProperty().SetColor(0,1,0)
slideBar.GetCapProperty().SetColor(1,1,0)
slideBar.GetPoint1Coordinate().SetCoordinateSystemToDisplay()
slideBar.GetPoint1Coordinate().SetValue(40 ,40+y)
slideBar.GetPoint2Coordinate().SetCoordinateSystemToDisplay()
slideBar.GetPoint2Coordinate().SetValue(200,40+y)
sliderWidget = vtk.vtkSliderWidget()
sliderWidget.SetInteractor(renWinInteractor)
sliderWidget.SetRepresentation(slideBar)
sliderWidget.EnabledOn()
def myCallback(obj,event):
print obj.__class__.__name__," called"
value = int (obj.GetRepresentation().GetValue())
plane.SetSliceIndex(value)
sliderWidget.AddObserver("InteractionEvent",myCallback)
def init(nodesFile, elemsFile, initVsolFile):
rendBG = (0.51765, 0.50588, 0.54118)
tableSize = 256
renWinWidth = 1200
renWinHeight = 1000
# Load mesh information
polyData = Load(nodesFile, elemsFile)
# Get voltage solution data
scalarInformation = None #GetVoltageSoln(initVsolFile + '.npy')
# Set scalars
polyData.GetPointData().SetScalars(scalarInformation)
# Setup lookup table
lookupTable = SetColourMap(tableSize)
# Update mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(polyData)
mapper.SetLookupTable(lookupTable)
# Setup slider components
sliderRep = vtk.vtkSliderRepresentation2D()
sliderRep = SetupSliderRep()
# Setup property stuff
property = vtk.vtkProperty()
property.EdgeVisibilityOn()
property.SetEdgeColor(0, 0, 0)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.SetProperty(property)
ren = vtk.vtkRenderer()
ren.SetBackground(rendBG) # Modify background colour to grey
renWin = vtk.vtkRenderWindow()
renWin.SetSize(renWinWidth, renWinHeight)
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.GetInteractorStyle().SetCurrentStyleToTrackballCamera()
# Setup slider behaviours + enable display + interaction
sliderWidget = vtk.vtkSliderWidget()
sliderWidget.SetInteractor(iren)
sliderCallback = vtkSliderCallback()
sliderCallback.mesh = polyData
sliderWidget.AddObserver("InteractionEvent", sliderCallback.execute)
sliderWidget.SetRepresentation(sliderRep)
sliderWidget.EnabledOn()
ren.AddActor(actor)
ren.ResetCamera()
renWin.Render()
iren.Start()
def __init__(self, interactor, value=0, min_val=0, max_val=1, point1=(
0, .1), point2=(1, .1), end=None, update=None, title=""):
sliderWidget = vtk.vtkSliderWidget()
sliderWidget.SetRepresentation(vtk.vtkSliderRepresentation2D())
super(Slider, self).__init__(interactor, sliderWidget)
self.end_callback = end
self.update_callback = update
self.x1, self.y1 = point1
self.x2, self.y2 = point2
self.repr.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
self.repr.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
prop = self.repr.GetSliderProperty()
prop.SetColor(1.0, 0.0, 0.0)
prop.SetOpacity(0.5)
sprop = self.repr.GetSelectedProperty()
sprop.SetOpacity(0.8)
tprop = self.repr.GetTubeProperty()
tprop.SetColor(0.5, 0.5, 0.5)
tprop.SetOpacity(0.5)
cprop = self.repr.GetCapProperty()
cprop.SetColor(0.0, 0.0, 1.0)
cprop.SetOpacity(0.5)
self.repr.SetMinimumValue(float(min_val))
self.repr.SetMaximumValue(float(max_val))
if callable(value):
self.set_value(value())
self.value_func = value
else:
self.repr.SetValue(float(value))
self.value_func = None
self.repr.SetSliderLength(0.05)
self.repr.SetSliderWidth(0.02)
self.repr.SetTubeWidth(0.01)
self.repr.SetEndCapLength(0.02)
self.repr.SetEndCapWidth(0.02)
self.repr.SetTitleHeight(0.02)
self.repr.SetTitleText(title)
sliderWidget.SetAnimationModeToJump()
sliderWidget.AddObserver("EndInteractionEvent", self.end_slide)
sliderWidget.AddObserver("InteractionEvent", self.slide_value)
sliderWidget.KeyPressActivationOff()
self.place()
def __init__(self, interactor, value=0, min_val=0, max_val=1, point1=(
0, .1), point2=(1, .1), end=None, update=None, title=""):
sliderWidget = vtk.vtkSliderWidget()
sliderWidget.SetRepresentation(vtk.vtkSliderRepresentation2D())
super(Slider, self).__init__(interactor, sliderWidget)
self.end_callback = end
self.update_callback = update
self.x1, self.y1 = point1
self.x2, self.y2 = point2
self.repr.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
self.repr.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
prop = self.repr.GetSliderProperty()
prop.SetColor(1.0, 0.0, 0.0)
prop.SetOpacity(0.5)
sprop = self.repr.GetSelectedProperty()
sprop.SetOpacity(0.8)
tprop = self.repr.GetTubeProperty()
tprop.SetColor(0.5, 0.5, 0.5)
tprop.SetOpacity(0.5)
cprop = self.repr.GetCapProperty()
cprop.SetColor(0.0, 0.0, 1.0)
cprop.SetOpacity(0.5)
self.repr.SetMinimumValue(float(min_val))
self.repr.SetMaximumValue(float(max_val))
if callable(value):
self.set_value(value())
self.value_func = value
else:
self.repr.SetValue(float(value))
self.value_func = None
self.repr.SetSliderLength(0.05)
self.repr.SetSliderWidth(0.02)
self.repr.SetTubeWidth(0.01)
self.repr.SetEndCapLength(0.02)
self.repr.SetEndCapWidth(0.02)
self.repr.SetTitleHeight(0.02)
self.repr.SetTitleText(title)
sliderWidget.SetAnimationModeToJump()
sliderWidget.AddObserver("EndInteractionEvent", self.end_slide)
sliderWidget.AddObserver("InteractionEvent", self.slide_value)
sliderWidget.KeyPressActivationOff()
self.place()
def _createSlider(self):
width, height = self.getSize()
self.sliderTitleProperty = vtk.vtkTextProperty()
self._titleActor = vtk.vtkTextActor()
self._renderer.RemoveActor2D(self._titleActor)
self.sliderTitleProperty.SetFontSize(15)
self.sliderTitleProperty.SetColor(self.opv.font_color)
# self.sliderTitleProperty.BoldOn()
self.sliderTitleProperty.SetFontFamilyAsString('Arial')
self.sliderTitleProperty.SetVerticalJustificationToTop()
self.sliderTitleProperty.SetJustificationToLeft()
self._titleActor.SetInput('Animation phase controller [deg]')
self._titleActor.SetTextProperty(self.sliderTitleProperty)
self._titleActor.SetDisplayPosition(20, height - 190)
self._renderer.AddActor2D(self._titleActor)
self.slider = vtk.vtkSliderWidget()
self.sldRep = vtk.vtkSliderRepresentation2D()
self.sldRep.SetMinimumValue(0)
self.sldRep.SetMaximumValue(360)
self.sldRep.SetValue(0)
self.sliderLabelProperty = self.sldRep.GetLabelProperty()
self.sliderLabelProperty.SetColor(self.opv.font_color)
self.sliderLabelProperty.ShadowOff()
# self.sliderLabelProperty.SetFontSize(10)
self.sldRep.GetSelectedProperty().SetColor(1, 0, 0)
self.sldRep.GetTubeProperty().SetColor(0.5, 0.5, 0.5)
self.sldRep.GetCapProperty().SetColor(0.8, 0.8, 0.8)
self.sldRep.SetSliderLength(0.01)
self.sldRep.SetSliderWidth(0.03)
self.sldRep.SetTubeWidth(0.02)
self.sldRep.SetEndCapWidth(0.02)
self.sldRep.SetEndCapLength(0.005)
# self.sldRep.SetTitleHeight(0.010)
self.sldRep.SetLabelHeight(0.018)
self.sldRep.GetPoint1Coordinate().SetCoordinateSystemToDisplay()
self.sldRep.GetPoint2Coordinate().SetCoordinateSystemToDisplay()
self.sldRep.GetPoint1Coordinate().SetValue(20, height - 165)
self.sldRep.GetPoint2Coordinate().SetValue(220, height - 165)
self.slider.SetInteractor(self.opv)
self.slider.SetRepresentation(self.sldRep)
self.slider.AddObserver(vtk.vtkCommand.EndInteractionEvent,
self._sliderCallback)
def __init__(self, title_text, value_range, initial_value, position):
slider_rep = vtk.vtkSliderRepresentation2D()
slider_rep.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
slider_rep.GetPoint1Coordinate().SetValue(*position[0])
slider_rep.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
slider_rep.GetPoint2Coordinate().SetValue(*position[1])
slider_rep.SetMinimumValue(value_range[0])
slider_rep.SetMaximumValue(value_range[1])
slider_rep.SetValue(initial_value)
slider_rep.SetTitleText(title_text)
self._slider_rep = slider_rep
def create_color_slider(self,name,left,right,down,up,default_value=0.02):
slider=vtk.vtkSliderRepresentation2D()
slider.SetMinimumValue(down)
slider.SetMaximumValue(up)
slider.SetValue(default_value)
slider.SetTitleText(name)
slider.SetLabelFormat("%5.2f")
slider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
slider.GetPoint1Coordinate().SetValue(left, 0.1)
slider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
slider.GetPoint2Coordinate().SetValue(right, 0.1)
return slider
def createSliderStyle(min, max, value, point1, point2, title, dim):
SliderStyle = vtk.vtkSliderRepresentation2D()
# Set max/min/value and title
SliderStyle.SetMinimumValue(min)
SliderStyle.SetMaximumValue(max)
SliderStyle.SetValue(value)
SliderStyle.SetTitleText(title)
#Set the coordinates of the endings
SliderStyle.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderStyle.GetPoint1Coordinate().SetValue(point1[0], point1[1])
SliderStyle.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderStyle.GetPoint2Coordinate().SetValue(point2[0], point2[1])
#Set the dimensions of the slider
SliderStyle.SetTubeWidth(dim[0])
SliderStyle.SetSliderLength(dim[1])
SliderStyle.SetTitleHeight(dim[2])
SliderStyle.SetLabelHeight(dim[3])
return SliderStyle
def create_slider_rep(self, min=0, max=10, val=0):
slider_rep = vtk.vtkSliderRepresentation2D()
slider_rep.SetMinimumValue(min)
slider_rep.SetMaximumValue(max)
slider_rep.SetValue(val)
slider_rep.GetPoint1Coordinate().SetCoordinateSystemToDisplay()
slider_rep.GetPoint1Coordinate().SetValue(0, 40)
slider_rep.GetPoint2Coordinate().SetCoordinateSystemToDisplay()
slider_rep.GetPoint2Coordinate().SetValue(300, 40)
self.slider_w = vtk.vtkSliderWidget()
self.slider_w.SetInteractor(self.interactor)
self.slider_w.SetRepresentation(slider_rep)
self.slider_w.SetCurrentRenderer(self.ren_list[0])
self.slider_w.SetAnimationModeToAnimate()
self.slider_w.On()
self.slider_w.AddObserver('EndInteractionEvent', self.slideCallback)
def SetupSliderRep():
sliderRep = vtk.vtkSliderRepresentation2D()
initialValue = 0 # Initial value of the slider
# 30 frames saved out from the voltage solution
minValue = 0
maxValue = 29
sliderTitle = "Voltage Solutions" # Slider title
sliderLabelFormat = "%.0f" # Slider bar value label format
x1Coord = 0.2 # Coords of slider position
y1Coord = 0.1
x2Coord = 0.8
y2Coord = y1Coord
# Dimensions of slider components
sliderLength = 0.02
sliderWidth = 0.03
capLength = 0.01
capWidth = sliderWidth
tubeWidth = 0.005
# Slider position
sliderRep.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
sliderRep.GetPoint1Coordinate().SetValue(x1Coord, y1Coord)
sliderRep.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
sliderRep.GetPoint2Coordinate().SetValue(x2Coord, y2Coord)
# Slider information
sliderRep.SetValue(initialValue)
sliderRep.SetMinimumValue(minValue)
sliderRep.SetMaximumValue(maxValue)
sliderRep.SetTitleText(sliderTitle)
sliderRep.SetLabelFormat(sliderLabelFormat)
sliderRep.SetSliderLength(sliderLength)
sliderRep.SetSliderWidth(sliderWidth)
sliderRep.SetEndCapLength(capLength)
sliderRep.SetEndCapWidth(capWidth)
sliderRep.SetTubeWidth(tubeWidth)
return sliderRep
def CreateSliderWidget(self):
self.sliderRep = vtkSliderRepresentation2D()
self.sliderRep.SetMinimumValue(0)
self.sliderRep.SetMaximumValue(50)
self.sliderRep.SetValue(self.planeWidgetZ.GetSliceIndex())
self.sliderRep.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
self.sliderRep.GetPoint1Coordinate().SetValue(0.3, 0.02)
self.sliderRep.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
self.sliderRep.GetPoint2Coordinate().SetValue(0.6, 0.02)
self.sliderWidget = vtk.vtkSliderWidget()
self.sliderWidget.SetAnimationModeToJump()
self.sliderWidget.SetInteractor(self.iren)
self.sliderWidget.SetRepresentation(self.sliderRep)
#self.sliderWidget.SetCurrentRenderer(self.ren)
self.sliderWidget.EnabledOff()
self.sliderWidget.AddObserver('InteractionEvent',
SliderCallback(self.planeWidgetZ))
def generate_min_grad_slide_bar():
# Create Slidebar
slide_bar = vtk.vtkSliderRepresentation2D()
# Set range and title.
slide_bar.SetMinimumValue(min_gradient)
slide_bar.SetMaximumValue(max_gradient)
slide_bar.SetValue(min_gradient)
slide_bar.SetTitleText("Min gradient value")
# Set colors.
slide_bar = set_slide_bar_colors(slide_bar)
# Set coordinates.
slide_bar.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
slide_bar.GetPoint1Coordinate().SetValue(0.78, 0.3)
slide_bar.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
slide_bar.GetPoint2Coordinate().SetValue(0.98, 0.3)
return slide_bar
def CreateSliderWidget(self):
for i in range(2):
self.sliderRep.append(vtkSliderRepresentation2D())
self.sliderRep[i].SetMinimumValue(0)
self.sliderRep[i].SetMaximumValue(50)
self.sliderRep[i].SetValue(self.planeWidgetZ[i].GetSliceIndex())
self.sliderRep[i].GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
self.sliderRep[i].GetPoint1Coordinate().SetValue(0.1, 0.1)
self.sliderRep[i].GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
self.sliderRep[i].GetPoint2Coordinate().SetValue(0.3, 0.1)
self.sliderWidget.append(vtk.vtkSliderWidget())
self.sliderWidget[i].SetAnimationModeToJump()
self.sliderWidget[i].SetInteractor(self.iren)
self.sliderWidget[i].SetRepresentation(self.sliderRep[i])
self.sliderWidget[i].SetCurrentRenderer(self.ren[i])
#self.sliderWidget[i].SetAnimationModeToAnimate()
self.sliderWidget[i].EnabledOff()
self.sliderWidget[i].AddObserver(
'InteractionEvent', SliderCallback(self.planeWidgetZ[i]))
def make_slider_widget(properties, colors, lut, idx):
slider = vtk.vtkSliderRepresentation2D()
slider.SetMinimumValue(properties.value_minimum)
slider.SetMaximumValue(properties.value_maximum)
slider.SetValue(properties.value_initial)
slider.SetTitleText(properties.title)
slider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
slider.GetPoint1Coordinate().SetValue(properties.p1[0], properties.p1[1])
slider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
slider.GetPoint2Coordinate().SetValue(properties.p2[0], properties.p2[1])
slider.SetTubeWidth(properties.tube_width)
slider.SetSliderLength(properties.slider_length)
slider.SetTitleHeight(properties.title_height)
slider.SetLabelHeight(properties.label_height)
# Set the color properties
# Change the color of the bar.
slider.GetTubeProperty().SetColor(colors.GetColor3d(properties.bar_color))
# Change the color of the ends of the bar.
slider.GetCapProperty().SetColor(colors.GetColor3d(properties.bar_ends_color))
# Change the color of the knob that slides.
slider.GetSliderProperty().SetColor(colors.GetColor3d(properties.slider_color))
# Change the color of the knob when the mouse is held on it.
slider.GetSelectedProperty().SetColor(colors.GetColor3d(properties.selected_color))
# Change the color of the text displaying the value.
slider.GetLabelProperty().SetColor(colors.GetColor3d(properties.value_color))
# Change the color of the text indicating what the slider controls
if idx in range(0, 16):
slider.GetTitleProperty().SetColor(lut.GetTableValue(idx)[:3])
slider.GetTitleProperty().ShadowOff()
else:
slider.GetTitleProperty().SetColor(colors.GetColor3d(properties.title_color))
slider_widget = vtk.vtkSliderWidget()
slider_widget.SetRepresentation(slider)
return slider_widget
def MakeSliderWidget(properties):
slider = vtk.vtkSliderRepresentation2D()
slider.SetMinimumValue(properties.minimumValue)
slider.SetMaximumValue(properties.maximumValue)
slider.SetValue(properties.initialValue)
slider.SetTitleText(properties.title)
slider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
slider.GetPoint1Coordinate().SetValue(properties.p1[0], properties.p1[1])
slider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
slider.GetPoint2Coordinate().SetValue(properties.p2[0], properties.p2[1])
slider.SetTubeWidth(properties.tubeWidth)
slider.SetSliderLength(properties.sliderLength)
slider.SetTitleHeight(properties.titleHeight)
slider.SetLabelHeight(properties.labelHeight)
sliderWidget = vtk.vtkSliderWidget()
sliderWidget.SetRepresentation(slider)
return sliderWidget
def generate_z_axis_slide_bar(max, value):
# Create Slidebar
slide_bar = vtk.vtkSliderRepresentation2D()
# Set range and title.
slide_bar.SetMinimumValue(0)
slide_bar.SetMaximumValue(max)
if (value):
slide_bar.SetValue(value)
else:
slide_bar.SetValue(0)
slide_bar.SetTitleText("Z clip")
# Set colors.
slide_bar = set_slide_bar_colors(slide_bar)
# Set coordinates.
slide_bar.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
slide_bar.GetPoint1Coordinate().SetValue(0.02, 0.1)
slide_bar.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
slide_bar.GetPoint2Coordinate().SetValue(0.22, 0.1)
return slide_bar
def __init__(self):
Measurement.__init__(self)
#######################################################################
self.sliderTime = vtk.vtkSliderRepresentation2D()
self.sliderTime.SetTitleText("time")
self.sliderTime.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
self.sliderTime.GetPoint1Coordinate().SetValue(0.2, 0.92)
self.sliderTime.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
self.sliderTime.GetPoint2Coordinate().SetValue(0.95, 0.92)
self.sliderTime.SetSliderWidth(0.03)
self.sliderTime.SetEndCapLength(0.03)
self.sliderTime.SetEndCapWidth(0.03)
self.sliderTime.SetTubeWidth(0.005)
self.sliderWidget = vtk.vtkCenteredSliderWidget()
self.sliderWidget.SetInteractor(self.iren)
self.sliderWidget.SetRepresentation(self.sliderTime)
self.sliderWidget.EnabledOn()
self.sliderWidget.AddObserver("InteractionEvent", self.callbackTime)
def __init__(self, interactive=True):
Control.__init__(self)
self.sliderRange = vtk.vtkSliderRepresentation2D()
#self.sliderRange.SetTitleText("height")
self.sliderRange.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
self.sliderRange.GetPoint1Coordinate().SetValue(0.94, 0.1)
self.sliderRange.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
self.sliderRange.GetPoint2Coordinate().SetValue(0.94, 0.9)
self.sliderRange.SetSliderWidth(0.03)
self.sliderRange.SetEndCapLength(0.03)
self.sliderRange.SetEndCapWidth(0.03)
self.sliderRange.SetTubeWidth(0.005)
self.sliderWidget2 = vtk.vtkCenteredSliderWidget()
self.sliderWidget2.SetInteractor(self.iren)
self.sliderWidget2.SetRepresentation(self.sliderRange)
self.sliderWidget2.EnabledOn()
self.sliderWidget2.AddObserver("InteractionEvent", self.callbackRange)
self.analyseMode = 0
self.analyseList = analyze.FCT_LIST
self.ion = interactive
if self.ion:
plt.ion()
if interactive:
print("-----------------")
print("GpsSatFi Settings")
print("-----------------")
print("m -> switch Mode (PDOP, GDOP, NumSat, ...)")
print("x -> eXecute calculation for given mode")
def __init__(self, args):
## Files reading and settings
self.isovalues = args.isoval
self.cmap = args.cmap
self.clip_x = args.clip[0]
self.clip_y = args.clip[1]
self.clip_z = args.clip[2]
ct_image = vtk.vtkXMLImageDataReader()
ct_image.SetFileName(args.data)
ct_image.Update()
gm_image = vtk.vtkXMLImageDataReader()
gm_image.SetFileName(args.gradmag)
gm_image.Update()
self.ct_contour = vtk.vtkContourFilter()
self.ct_contour.SetInputConnection(ct_image.GetOutputPort())
self.ct_contour.ComputeNormalsOn()
for i in range(len(self.isovalues)):
self.ct_contour.SetValue(i, self.isovalues[i])
color_func = vtk.vtkColorTransferFunction()
color_func.SetColorSpaceToRGB()
for c in self.cmap:
color_func.AddRGBPoint(c[0], c[1], c[2], c[3])
#Cutting planes
self.plane_x = vtk.vtkPlane()
self.plane_x.SetOrigin(self.clip_x, 0, 0)
self.plane_x.SetNormal(1, 0, 0)
self.clipper_x = vtk.vtkClipPolyData()
self.clipper_x.SetClipFunction(self.plane_x)
self.clipper_x.SetInputConnection(self.ct_contour.GetOutputPort())
self.plane_y = vtk.vtkPlane()
self.plane_y.SetOrigin(0, self.clip_y, 0)
self.plane_y.SetNormal(0, 1, 0)
self.clipper_y = vtk.vtkClipPolyData()
self.clipper_y.SetClipFunction(self.plane_y)
self.clipper_y.SetInputConnection(self.clipper_x.GetOutputPort())
self.plane_z = vtk.vtkPlane()
self.plane_z.SetOrigin(0, 0, self.clip_z)
self.plane_z.SetNormal(0, 0, 1)
self.clipper_z = vtk.vtkClipPolyData()
self.clipper_z.SetClipFunction(self.plane_z)
self.clipper_z.SetInputConnection(self.clipper_y.GetOutputPort())
probe_filter = vtk.vtkProbeFilter()
probe_filter.SetSourceConnection(gm_image.GetOutputPort())
probe_filter.SetInputConnection(self.clipper_z.GetOutputPort())
color_mapper = vtk.vtkPolyDataMapper()
color_mapper.SetLookupTable(color_func)
color_mapper.SetInputConnection(probe_filter.GetOutputPort())
color_mapper.SetScalarRange(probe_filter.GetOutput().GetScalarRange())
colorBar = vtk.vtkScalarBarActor()
colorBar.SetLookupTable(color_mapper.GetLookupTable())
colorBar.SetTitle("Gradient")
colorBar.SetNumberOfLabels(5)
colorBar.SetLabelFormat("%4.0f")
colorBar.SetPosition(0.9, 0.1)
colorBar.SetWidth(0.08)
colorBar.SetHeight(0.6)
color_actor = vtk.vtkActor()
#color_actor.GetProperty().SetRepresentationToWireframe()
color_actor.SetMapper(color_mapper)
backFaces = vtk.vtkProperty()
backFaces.SetSpecular(0)
backFaces.SetDiffuse(0)
backFaces.SetAmbient(0)
backFaces.SetAmbientColor(1, 0, 0)
color_actor.SetBackfaceProperty(backFaces)
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
ren.AddActor(color_actor)
ren.AddActor(colorBar)
ren.ResetCamera()
ren.SetBackground(0.2, 0.3, 0.4)
ren.ResetCameraClippingRange()
renWin.SetSize(1200, 600)
clipXSlider = vtk.vtkSliderRepresentation2D()
clipXSlider.SetMinimumValue(0)
clipXSlider.SetMaximumValue(300)
clipXSlider.SetValue(self.clip_x)
clipXSlider.SetTitleText("X")
clipXSlider.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
clipXSlider.GetPoint1Coordinate().SetValue(0.01, 0.3)
clipXSlider.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
clipXSlider.GetPoint2Coordinate().SetValue(0.2, 0.3)
clipXSlider.SetSliderLength(0.02)
clipXSlider.SetSliderWidth(0.03)
clipXSlider.SetEndCapLength(0.01)
clipXSlider.SetEndCapWidth(0.03)
clipXSlider.SetTubeWidth(0.005)
clipXSlider.SetLabelFormat("%1.2lf")
clipXSlider.SetTitleHeight(0.02)
clipXSlider.SetLabelHeight(0.02)
SliderWidget2 = vtk.vtkSliderWidget()
SliderWidget2.SetInteractor(iren)
SliderWidget2.SetRepresentation(clipXSlider)
SliderWidget2.KeyPressActivationOff()
SliderWidget2.SetAnimationModeToAnimate()
SliderWidget2.SetEnabled(True)
SliderWidget2.AddObserver("EndInteractionEvent",
self.clipXSliderHandler)
clipYSlider = vtk.vtkSliderRepresentation2D()
clipYSlider.SetMinimumValue(0)
clipYSlider.SetMaximumValue(300)
clipYSlider.SetValue(self.clip_y)
clipYSlider.SetTitleText("Y")
clipYSlider.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
clipYSlider.GetPoint1Coordinate().SetValue(0.01, 0.2)
clipYSlider.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
clipYSlider.GetPoint2Coordinate().SetValue(0.2, 0.2)
clipYSlider.SetSliderLength(0.02)
clipYSlider.SetSliderWidth(0.03)
clipYSlider.SetEndCapLength(0.01)
clipYSlider.SetEndCapWidth(0.03)
clipYSlider.SetTubeWidth(0.005)
clipYSlider.SetLabelFormat("%1.2lf")
clipYSlider.SetTitleHeight(0.02)
clipYSlider.SetLabelHeight(0.02)
SliderWidget3 = vtk.vtkSliderWidget()
SliderWidget3.SetInteractor(iren)
SliderWidget3.SetRepresentation(clipYSlider)
SliderWidget3.KeyPressActivationOff()
SliderWidget3.SetAnimationModeToAnimate()
SliderWidget3.SetEnabled(True)
SliderWidget3.AddObserver("EndInteractionEvent",
self.clipYSliderHandler)
clipZSlider = vtk.vtkSliderRepresentation2D()
clipZSlider.SetMinimumValue(0)
clipZSlider.SetMaximumValue(300)
clipZSlider.SetValue(self.clip_z)
clipZSlider.SetTitleText("Z")
clipZSlider.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
clipZSlider.GetPoint1Coordinate().SetValue(0.01, 0.1)
clipZSlider.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
clipZSlider.GetPoint2Coordinate().SetValue(0.2, 0.1)
clipZSlider.SetSliderLength(0.02)
clipZSlider.SetSliderWidth(0.03)
clipZSlider.SetEndCapLength(0.01)
clipZSlider.SetEndCapWidth(0.03)
clipZSlider.SetTubeWidth(0.005)
clipZSlider.SetLabelFormat("%1.2lf")
clipZSlider.SetTitleHeight(0.02)
clipZSlider.SetLabelHeight(0.02)
SliderWidget4 = vtk.vtkSliderWidget()
SliderWidget4.SetInteractor(iren)
SliderWidget4.SetRepresentation(clipZSlider)
SliderWidget4.KeyPressActivationOff()
SliderWidget4.SetAnimationModeToAnimate()
SliderWidget4.SetEnabled(True)
SliderWidget4.AddObserver("EndInteractionEvent",
self.clipZSliderHandler)
# Render
iren.Initialize()
renWin.SetSize(1200, 800)
renWin.SetWindowName(
"Project 3b: Isocontours - Pedro Acevedo & Randy Consuegra")
renWin.Render()
iren.Start()
def plot_fermisurface(data, equivalences, ebands, mu, nworkers=1):
"""Launch an interactive VTK representation of the Fermi surface.
Make sure to check the module-level variable "available" before calling
this function.
Args:
data: a DFTData object
equivalences: list of k-point equivalence classes
ebands: eband: (nbands, nkpoints) array with the band energies
mu: initial value of the energy at which the surface will be plotted,
with respect to data.fermi. This can later be changed by the user
using an interactive slider.
nworkers: number of worker processes to use for the band reconstruction
Returns:
None.
"""
lattvec = data.get_lattvec()
rlattvec = 2. * np.pi * la.inv(lattvec).T
# Obtain the first Brillouin zone as the Voronoi polyhedron of Gamma
points = []
for ijk0 in itertools.product(range(5), repeat=3):
ijk = [i if i <= 2 else i - 5 for i in ijk0]
points.append(rlattvec @ np.array(ijk))
voronoi = scipy.spatial.Voronoi(points)
region_index = voronoi.point_region[0]
vertex_indices = voronoi.regions[region_index]
vertices = voronoi.vertices[vertex_indices, :]
# Compute a center and an outward-pointing normal for each of the facets
# of the BZ
facets = []
for ridge in voronoi.ridge_vertices:
if all(i in vertex_indices for i in ridge):
facets.append(ridge)
centers = []
normals = []
for f in facets:
corners = np.array([voronoi.vertices[i, :] for i in f])
center = corners.mean(axis=0)
v1 = corners[0, :]
for i in range(1, corners.shape[0]):
v2 = corners[i, :]
prod = np.cross(v1 - center, v2 - center)
if not np.allclose(prod, 0.):
break
if np.dot(center, prod) < 0.:
prod = -prod
centers.append(center)
normals.append(prod)
# Get the extent of the regular grid in reciprocal space
hdims = np.max(np.abs(np.vstack(equivalences)), axis=0)
dims = 2 * hdims + 1
class PointPickerInteractorStyle(vtk.vtkInteractorStyleTrackballCamera):
"""Custom interaction style enabling the user to pick points on
the screen.
"""
def __init__(self, parent=None):
"""Simple constructor that adds an observer to the middle mouse
button press.
"""
self.AddObserver("MiddleButtonPressEvent", self.pick_point)
def pick_point(self, obj, event):
"""Get the coordinates of the point selected with the middle mouse
button, find the nearest data point, and print its direct
coordinates.
"""
interactor = self.GetInteractor()
picker = interactor.GetPicker()
pos = interactor.GetEventPosition()
picker.Pick(
pos[0], pos[1], 0,
interactor.GetRenderWindow().GetRenderers().GetFirstRenderer())
picked = np.array(picker.GetPickPosition())
# Move the sphere to the new coordinates and make it visible
sphere.SetCenter(*picked.tolist())
sphere_actor.VisibilityOn()
picked = la.solve(rlattvec, picked)
print("Point picked:", picked)
self.OnMiddleButtonDown()
# Create the VTK representation of the grid
sgrid = vtk.vtkStructuredGrid()
sgrid.SetDimensions(*dims)
spoints = vtk.vtkPoints()
for ijk0 in itertools.product(*(range(0, d) for d in dims)):
ijk = [
ijk0[i] if ijk0[i] <= hdims[i] else ijk0[i] - dims[i]
for i in range(len(dims))
]
abc = np.array(ijk, dtype=np.float64) / np.array(dims)
xyz = rlattvec @ abc
spoints.InsertNextPoint(*xyz.tolist())
sgrid.SetPoints(spoints)
# Find the shortest distance between points to compute a good
# radius for the selector sphere later.
dmin = np.infty
for i in range(3):
abc = np.zeros(3)
abc[i] = 1. / dims[i]
xyz = rlattvec @ abc
dmin = min(dmin, la.norm(xyz))
ebands -= data.fermi
emax = ebands.max(axis=1)
emin = ebands.min(axis=1)
# Remove all points outside the BZ
for i, ijk0 in enumerate(itertools.product(*(range(0, d) for d in dims))):
ijk = [
ijk0[j] if ijk0[j] <= hdims[j] else ijk0[j] - dims[j]
for j in range(len(dims))
]
abc = np.array(ijk, dtype=np.float64) / np.array(dims)
xyz = rlattvec @ abc
for c, n in zip(centers, normals):
if np.dot(xyz - c, n) > 0.:
ebands[:, i] = np.nan
break
# Create a 2D chemical potential slider
slider = vtk.vtkSliderRepresentation2D()
slider.SetMinimumValue(emin.min())
slider.SetMaximumValue(emax.max())
slider.SetValue(mu)
slider.SetTitleText("Chemical potential")
slider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
slider.GetPoint1Coordinate().SetValue(0.1, 0.9)
slider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
slider.GetPoint2Coordinate().SetValue(0.9, 0.9)
slider.GetTubeProperty().SetColor(*colors.hex2color("#2e3436"))
slider.GetSliderProperty().SetColor(*colors.hex2color("#a40000"))
slider.GetCapProperty().SetColor(*colors.hex2color("#babdb6"))
slider.GetSelectedProperty().SetColor(*colors.hex2color("#a40000"))
slider.GetTitleProperty().SetColor(*colors.hex2color("#2e3436"))
# Find all the isosurfaces with energy equal to the threshold
allcontours = []
with TimerContext() as timer:
fermiactors = []
for band in ebands:
sgridp = vtk.vtkStructuredGrid()
sgridp.DeepCopy(sgrid)
# Feed the energies to VTK
scalar = vtk.vtkFloatArray()
for i in band:
scalar.InsertNextValue(i)
sgridp.GetPointData().SetScalars(scalar)
# Estimate the isosurfaces
contours = vtk.vtkMarchingContourFilter()
contours.SetInputData(sgridp)
contours.UseScalarTreeOn()
contours.SetValue(0, mu)
contours.ComputeNormalsOff()
contours.ComputeGradientsOff()
allcontours.append(contours)
# Use vtkStrippers to plot the surfaces faster
stripper = vtk.vtkStripper()
stripper.SetInputConnection(contours.GetOutputPort())
# Compute the normals to the surfaces to obtain better lighting
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(stripper.GetOutputPort())
normals.ComputeCellNormalsOn()
normals.ComputePointNormalsOn()
# Create a mapper and an actor for the surfaces
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(normals.GetOutputPort())
mapper.ScalarVisibilityOff()
fermiactors.append(vtk.vtkActor())
fermiactors[-1].SetMapper(mapper)
fermiactors[-1].GetProperty().SetColor(*colors.hex2color(
"#a40000"))
deltat = timer.get_deltat()
info("building the surfaces took {:.3g} s".format(deltat))
# Represent the BZ as a polyhedron in VTK
points = vtk.vtkPoints()
for v in voronoi.vertices:
points.InsertNextPoint(*v)
fids = vtk.vtkIdList()
fids.InsertNextId(len(facets))
for f in facets:
fids.InsertNextId(len(f))
for i in f:
fids.InsertNextId(i)
fgrid = vtk.vtkUnstructuredGrid()
fgrid.SetPoints(points)
fgrid.InsertNextCell(vtk.VTK_POLYHEDRON, fids)
# Create an actor and a mapper for the BZ
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(fgrid)
bzactor = vtk.vtkActor()
bzactor.SetMapper(mapper)
bzactor.GetProperty().SetColor(*colors.hex2color("#204a87"))
bzactor.GetProperty().SetOpacity(0.2)
# Create a visual representation of the selected point, and hide
# it for the time being.
sphere = vtk.vtkSphereSource()
sphere.SetRadius(dmin / 2.)
sphere_mapper = vtk.vtkPolyDataMapper()
sphere_mapper.SetInputConnection(sphere.GetOutputPort())
sphere_mapper.ScalarVisibilityOff()
sphere_actor = vtk.vtkActor()
sphere_actor.SetMapper(sphere_mapper)
sphere_actor.GetProperty().SetColor(*colors.hex2color("#f57900"))
sphere_actor.VisibilityOff()
# Create a VTK window and other elements of an interactive scene
renderer = vtk.vtkRenderer()
renderer.AddActor(bzactor)
renderer.AddActor(sphere_actor)
for f in fermiactors:
renderer.AddActor(f)
renderer.ResetCamera()
renderer.GetActiveCamera().Zoom(5.)
renderer.SetBackground(1., 1., 1.)
window = vtk.vtkRenderWindow()
window.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetInteractorStyle(PointPickerInteractorStyle())
interactor.SetRenderWindow(window)
# Add a set of axes
axes = vtk.vtkAxesActor()
assembly = vtk.vtkPropAssembly()
assembly.AddPart(axes)
marker = vtk.vtkOrientationMarkerWidget()
marker.SetOrientationMarker(assembly)
marker.SetInteractor(interactor)
marker.SetEnabled(1)
marker.InteractiveOff()
def callback(obj, ev):
"""Update the isosurface with a new value"""
mu = obj.GetRepresentation().GetValue()
for e, E, c, a in zip(emin, emax, allcontours, fermiactors):
visible = e <= mu and E >= mu
a.SetVisibility(visible)
if visible:
c.SetValue(0, mu)
# Add the slider widget
widget = vtk.vtkSliderWidget()
widget.SetInteractor(interactor)
widget.SetRepresentation(slider)
widget.SetAnimationModeToJump()
widget.EnabledOn()
widget.AddObserver(vtk.vtkCommand.InteractionEvent, callback)
# Launch the visualization
interactor.Initialize()
window.Render()
interactor.Start()
def __init__(self, data_source, input_link):
"""Parallel coordinates view constructor needs a valid DataSource plus
and external annotation link (from the icicle view).
"""
self.ds = data_source
self.input_link = input_link
# Set up callback to listen for changes in IcicleView selections
self.input_link.AddObserver("AnnotationChangedEvent", self.InputSelectionCallback)
# Set up an annotation link for other views to monitor selected image
# This link will be created here, but used back and forth between this detail view
# and the icicle view. It carries the current "scale" selected in both.
self.output_link = vtk.vtkAnnotationLink()
# If you don't set the FieldType explicitly it ends up as UNKNOWN (as of 21 Feb 2010)
# See vtkSelectionNode doc for field and content type enum values
self.output_link.GetCurrentSelection().GetNode(0).SetFieldType(1) # Point
# Here I'm outputting the "scale" of the selection, so I'm not sure it matters
# whether output is index or other content type...
self.output_link.GetCurrentSelection().GetNode(0).SetContentType(4) # 2 = PedigreeIds, 4 = Indices
# Set up callback which will work either internally or triggered by change from icicle view.
self.output_link.AddObserver("AnnotationChangedEvent", self.ScaleSelectionCallback)
# Create a set of empty image stacks for use in empty selections
# but use the dimensions of a "projected image" so scales match
example_image = self.ds.GetProjectedImages([0])
example_image.UpdateInformation()
(xMin, xMax, yMin, yMax, zMin, zMax) = example_image.GetWholeExtent()
(xSpacing, ySpacing, zSpacing) = example_image.GetSpacing()
(x0, y0, z0) = example_image.GetOrigin()
blankR = xMax - xMin + 1
blankC = yMax - yMin + 1
numScales = len(self.ds.ScaleMaxDim) # Note: accessing member variable directly
self.blank_image_list = []
self.blank_image_weights = []
self.numImagesList = []
nDim = 3 # 3-dim for now...
for dd in range(numScales):
images_linear = N.zeros( blankR*blankC*nDim, dtype='float')
intensity = VN.numpy_to_vtk(images_linear, deep=True)
intensity.SetName('PNGImage')
imageData = vtk.vtkImageData()
imageData.SetOrigin(x0, y0, z0)
imageData.SetSpacing(xSpacing, ySpacing, zSpacing)
imageData.SetExtent(xMin,xMax,yMin,yMax,0,nDim-1)
imageData.GetPointData().AddArray(intensity)
imageData.GetPointData().SetActiveScalars('PNGImage')
self.blank_image_list.append(imageData)
self.blank_image_weights.append(0.1*N.ones(nDim, dtype='float'))
self.numImagesList.append(nDim)
for dd in range(len(self.blank_image_list)):
self.blank_image_list[dd].UpdateInformation()
# Create a BrBg7 lookup table
self.lut = self.ds.GetDivergingLUT('BrBg')
self.colorList = []
self.resliceList = []
self.assemblyList = []
self.numScales = len(self.ds.ScaleMaxDim) # Note: accessing member variable
self.expSpread = 0.5
self.renderer = vtk.vtkRenderer()
self.cam = self.renderer.GetActiveCamera()
# renderer.SetBackground(0.15, 0.12, 0.1)
# cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [40,40,40]]
cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [60, 60, 60]]
self.renderer.SetBackground(cc0,cc1,cc2)
self.highlightRect = vtk.vtkOutlineSource()
self.highlightMapper = vtk.vtkPolyDataMapper()
self.highlightMapper.SetInputConnection(self.highlightRect.GetOutputPort(0))
self.highlightActor = vtk.vtkActor()
self.highlightActor.SetMapper(self.highlightMapper)
self.highlightActor.GetProperty().SetColor(1,0.8,0.2)
self.highlightActor.GetProperty().SetLineWidth(3.0)
self.highlightActor.GetProperty().SetOpacity(0.6)
# Setting as if nothing picked even though initialized position & orientation to actor0
self.highlightIndex = -1
self.highlightActor.SetPickable(False)
self.highlightActor.SetVisibility(False)
self.renderer.AddActor(self.highlightActor)
# Create the slider which will control the image positions
self.sliderRep = vtk.vtkSliderRepresentation2D()
self.sliderRep.SetMinimumValue(0)
self.sliderRep.SetMaximumValue(self.numScales-1)
self.sliderRep.SetValue(0)
# For remembering the previous slider setting when switching data sets
self.prevSliderValue = int(self.numScales/2.0)
# And need to keep track of whether to reset view
self.needToResetCamera = True
self.window = vtk.vtkRenderWindow()
self.window.SetSize(600,300)
self.window.AddRenderer(self.renderer)
# Set up the interaction
self.interactorStyle = vtk.vtkInteractorStyleImage()
self.interactor = vtk.vtkRenderWindowInteractor()
self.interactor.SetInteractorStyle(self.interactorStyle)
self.window.SetInteractor(self.interactor)
self.sliderWidget = vtk.vtkSliderWidget()
self.sliderWidget.SetInteractor(self.interactor)
self.sliderWidget.SetRepresentation(self.sliderRep)
self.sliderWidget.SetAnimationModeToAnimate()
self.sliderWidget.EnabledOn()
self.sliderWidget.AddObserver("InteractionEvent", self.sliderCallback)
self.sliderWidget.AddObserver("EndInteractionEvent", self.endSliderCallback)
# Default flow direction Horizontal
# Setting self.maxAngle in SetFlowDirection()
self.FlowDirection = Direction.Vertical
self.SetFlowDirection(self.FlowDirection)
# Set up callback to toggle between inspect modes (manip axes & select data)
# self.interactorStyle.AddObserver("SelectionChangedEvent", self.selectImage)
# Create callbacks for mouse events
self.mouseActions = {}
self.mouseActions["LeftButtonDown"] = 0
self.mouseActions["Picking"] = 0
self.interactorStyle.AddObserver("MouseMoveEvent", self.MouseMoveCallback)
self.interactorStyle.AddObserver("LeftButtonPressEvent", self.LeftButtonPressCallback)
self.interactorStyle.AddObserver("LeftButtonReleaseEvent", self.LeftButtonReleaseCallback)
# Done setting up all of the image stuff, so call selection callback
# to set up view with blank images
# self.input_link.InvokeEvent('AnnotationChangedEvent')
self.InputSelectionCallback(self.input_link,None)
self.cam.ParallelProjectionOn()
def __init__(self, data_source, input_link):
"""Parallel coordinates view constructor needs a valid DataSource plus
and external annotation link (from the icicle view).
"""
self.ds = data_source
self.input_link = input_link
# Set up callback to listen for changes in IcicleView selections
self.input_link.AddObserver("AnnotationChangedEvent", self.InputSelectionCallback)
# Set up an annotation link for other views to monitor selected image
self.output_link = vtk.vtkAnnotationLink()
# If you don't set the FieldType explicitly it ends up as UNKNOWN (as of 21 Feb 2010)
# See vtkSelectionNode doc for field and content type enum values
self.output_link.GetCurrentSelection().GetNode(0).SetFieldType(1) # Point
# The chart seems to force INDEX selection, so I'm using vtkConvertSelection below to get
# out PedigreeIds...
self.output_link.GetCurrentSelection().GetNode(0).SetContentType(2) # 2 = PedigreeIds, 4 = Indices
# Going to manually create output_link selection list, so not setting up callback for it...
if os.path.isfile(os.path.abspath('BlankImage.png')):
blank_file = 'BlankImage.png'
else:
# For use in app bundles
blank_file = os.path.join(sys.path[0],'BlankImage.png')
self.blankImageReader = vtk.vtkPNGReader()
self.blankImageReader.SetFileName(blank_file)
self.blankImageReader.Update()
tmp = self.blankImageReader.GetOutput().GetBounds()
self.flowSpacing = float(tmp[1]-tmp[0])*1.1
# Create a greyscale lookup table
self.lut = self.ds.GetGrayscaleLUT('gray')
self.lut.SetRange(self.blankImageReader.GetOutput().GetPointData().GetArray('PNGImage').GetRange()) # image intensity range
# Map the image through the lookup table
self.color = vtk.vtkImageMapToColors()
self.color.SetLookupTable(self.lut)
self.color.SetInput(self.blankImageReader.GetOutput())
self.resliceList = []
self.actorList = []
self.numImages = 1
# Map between indices of images and their Pedigree ID
self.pedigree_id_dict = {}
blankImageActor = vtk.vtkImageActor()
blankImageActor.SetInput(self.color.GetOutput())
blankImageActor.SetPickable(False)
blankImageActor.SetOpacity(0.1)
self.actorList.append(blankImageActor)
self.expSpread = 0.5
self.maxAngle = 80.0
self.renderer = vtk.vtkRenderer()
self.cam = self.renderer.GetActiveCamera()
# renderer.SetBackground(0.15, 0.12, 0.1)
# cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [68,57,53]]
# self.renderer.SetBackground(cc0,cc1,cc2)
# cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [60,60,60]]
cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [160, 160, 160]]
self.renderer.SetBackground(cc0,cc1,cc2)
self.renderer.AddActor(self.actorList[0])
self.highlightRect = vtk.vtkOutlineSource()
self.highlightRect.SetBounds(self.actorList[0].GetBounds())
self.highlightMapper = vtk.vtkPolyDataMapper()
self.highlightMapper.SetInputConnection(self.highlightRect.GetOutputPort(0))
self.highlightActor = vtk.vtkActor()
self.highlightActor.SetMapper(self.highlightMapper)
self.highlightActor.GetProperty().SetColor(0,0.5,1.0)
self.highlightActor.GetProperty().SetLineWidth(6.0)
self.highlightActor.GetProperty().SetOpacity(0.5)
self.highlightActor.SetOrientation(self.actorList[0].GetOrientation())
tmpPos = self.actorList[0].GetPosition()
usePos = (tmpPos[0],tmpPos[1],tmpPos[2]+0.01)
self.highlightActor.SetPosition(usePos)
# Setting as if nothing picked even though initialized position & orientation to actor0
self.highlightIndex = -1
self.highlightActor.SetPickable(False)
self.highlightActor.SetVisibility(False)
self.renderer.AddActor(self.highlightActor)
# Create the slider which will control the image positions
self.sliderRep = vtk.vtkSliderRepresentation2D()
self.sliderRep.SetMinimumValue(0)
self.sliderRep.SetMaximumValue(self.numImages-1)
self.sliderRep.SetValue(0)
self.window = vtk.vtkRenderWindow()
self.window.SetSize(600,300)
self.window.AddRenderer(self.renderer)
# Set up the interaction
self.interactorStyle = vtk.vtkInteractorStyleImage()
self.interactor = vtk.vtkRenderWindowInteractor()
self.interactor.SetInteractorStyle(self.interactorStyle)
self.window.SetInteractor(self.interactor)
self.sliderWidget = vtk.vtkSliderWidget()
self.sliderWidget.SetInteractor(self.interactor)
self.sliderWidget.SetRepresentation(self.sliderRep)
self.sliderWidget.SetAnimationModeToAnimate()
self.sliderWidget.EnabledOn()
self.sliderWidget.AddObserver("InteractionEvent", self.sliderCallback)
self.sliderWidget.AddObserver("EndInteractionEvent", self.endSliderCallback)
# Default flow direction Horizontal
self.FlowDirection = Direction.Horizontal
self.SetFlowDirection(self.FlowDirection)
# Set up callback to toggle between inspect modes (manip axes & select data)
# self.interactorStyle.AddObserver("SelectionChangedEvent", self.selectImage)
# Create callbacks for mouse events
self.mouseActions = {}
self.mouseActions["LeftButtonDown"] = 0
self.mouseActions["Picking"] = 0
self.interactorStyle.AddObserver("MouseMoveEvent", self.MouseMoveCallback)
self.interactorStyle.AddObserver("LeftButtonPressEvent", self.LeftButtonPressCallback)
self.interactorStyle.AddObserver("LeftButtonReleaseEvent", self.LeftButtonReleaseCallback)
self.cam.ParallelProjectionOn()
self.renderer.ResetCamera(self.actorList[0].GetBounds())
self.cam.Elevation(10)
self.renderer.ResetCameraClippingRange()
def display_and_query(self):
# Convert images to VTK data structures
fixedVTKImage = self.fixedCL.toVTKImage()
movingVTKImage = self.movingCL.toVTKImage()
# Viewing parameters
fixedFrame = self.get_frame(self.fixedCL.clarray.get())
movingFrame = self.get_frame(self.movingCL.clarray.get())
N = self.panelSize
fixedShape = self.fixedCL.shape
XC = [0, 0, 0]
for d in range(3):
XC[d] = fixedShape[d] / 2.0
#
# Create panel of views for fixed and moving image, with likely optimal
# orientations
#
fixedArray = np.zeros((N*3, N*3), np.single)
movingArray = np.zeros((N*3, N*3), np.single)
for r in range(3):
for c in range(3):
V = self.get_slicing_matrix(fixedFrame[:,r], movingFrame[:,c])
A = np.zeros((4,4))
A[0:3,0] = V[:,0]
A[0:3,1] = V[:,1]
A[0:3,2] = V[:,2]
A[0,3] = XC[0]
A[1,3] = XC[1]
A[2,3] = XC[2]
A[3,3] = 1.0
resliceAxes = vtk.vtkMatrix4x4()
resliceAxes.DeepCopy(A.ravel().tolist())
reslicef = vtk.vtkImageReslice()
reslicef.SetInput(fixedVTKImage)
reslicef.SetInformationInput(fixedVTKImage)
reslicef.SetOutputExtent(0, N-1, 0, N-1, 0, 0)
reslicef.SetOutputDimensionality(2)
reslicef.SetResliceAxes(resliceAxes)
reslicef.SetInterpolationModeToLinear()
reslicef.Update()
fixedSlice = vtk.util.numpy_support.vtk_to_numpy(
reslicef.GetOutput().GetPointData().GetScalars() ).reshape(N, N)
fixedSlice = np.transpose(fixedSlice)
fixedArray[r*N:(r+1)*N, c*N:(c+1)*N] = fixedSlice
resliceAxes = vtk.vtkMatrix4x4()
resliceAxes.DeepCopy(A.ravel().tolist())
reslicef = vtk.vtkImageReslice()
reslicef.SetInput(movingVTKImage)
reslicef.SetInformationInput(movingVTKImage)
reslicef.SetOutputExtent(0, N-1, 0, N-1, 0, 0)
reslicef.SetOutputDimensionality(2)
reslicef.SetResliceAxes(resliceAxes)
reslicef.SetInterpolationModeToLinear()
reslicef.Update()
movingSlice = vtk.util.numpy_support.vtk_to_numpy(
reslicef.GetOutput().GetPointData().GetScalars() ).reshape(N, N)
movingSlice = np.transpose(movingSlice)
movingArray[r*N:(r+1)*N, c*N:(c+1)*N] = movingSlice
#
# Display panel of views with blending slider
#
def normalize(arr):
minv = arr.min()
maxv = arr.max()
rangev = maxv - minv
if rangev <= 0.0:
return arr
return (arr - minv) / rangev
fixedArray = normalize(fixedArray)
movingArray = normalize(movingArray)
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetWindowName("Image Alignment Query")
renWin.SetSize(800, 800)
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
dataImporter = vtk.vtkImageImport()
fixedArray_vtkorder = np.asfortranarray(fixedArray)
fixedArray_vtkorder = fixedArray.transpose()
##dataImporter.CopyImportVoidPointer(fixedArray_vtkorder, fixedArray_vtkorder.nbytes)
#dataImporter.CopyImportVoidPointer(fixedArray, fixedArray.nbytes)
displayArray = np.uint8(fixedArray * 255)
dataImporter.CopyImportVoidPointer(displayArray, displayArray.nbytes)
#dataImporter.SetDataScalarTypeToFloat()
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, N*3-1, 0, N*3-1, 0, 0)
dataImporter.SetWholeExtent(0, N*3-1, 0, N*3-1, 0, 0)
dataImporter.Update()
imageActor = vtk.vtkImageActor()
imageActor.SetInput(dataImporter.GetOutput())
imageActor.SetPosition(100.0, 100.0, 0.0)
imageActor.SetZSlice(0)
imageActor.PickableOn()
imageStyle = vtk.vtkInteractorStyleImage()
iren.SetInteractorStyle(imageStyle)
ren.AddActor(imageActor)
def slider_callback(obj, event):
# Get slider value
alpha = obj.GetRepresentation().GetValue()
displayArray = fixedArray * alpha + movingArray * (1.0 - alpha)
#minI = displayArray.min()
#maxI = displayArray.max()
#displayArray = (displayArray - minI) / (maxI - minI) * 255
#displayArray = np.uint8(displayArray)
#displayArray = np.uint8(normalize(displayArray) * 255)
displayArray = np.uint8(displayArray * 255)
dataImporter.CopyImportVoidPointer(displayArray, displayArray.nbytes)
sliderRep = vtk.vtkSliderRepresentation2D()
sliderRep.SetMinimumValue(0.0)
sliderRep.SetMaximumValue(1.0)
sliderRep.SetValue(1.0)
#sliderRep.SetTitleText("Fixed vs moving")
sliderRep.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
sliderRep.GetPoint1Coordinate().SetValue(0.2, 0.1)
sliderRep.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
sliderRep.GetPoint2Coordinate().SetValue(0.8, 0.1)
sliderWidget = vtk.vtkSliderWidget()
sliderWidget.SetInteractor(iren)
sliderWidget.SetRepresentation(sliderRep)
sliderWidget.AddObserver("InteractionEvent", slider_callback)
sliderWidget.EnabledOn()
#ren.InteractiveOff()
renWin.AddRenderer(ren)
picker = vtk.vtkPropPicker()
#picker = vtk.vtkWorldPointPicker()
picker.PickFromListOn()
picker.AddPickList(imageActor)
self.queryRowColumn = (0, 0)
def pick_callback(obj, event):
mousePos = obj.GetEventPosition()
picker.PickProp(mousePos[0], mousePos[1], ren)
p = picker.GetPickPosition()
c = round( (p[0]-100) / (3*N) * 2 )
r = round( (p[1]-100) / (3*N) * 2 )
if r < 0 or r >= 3 or c < 0 or c >= 3:
print "Outside"
return
print "Image row", r, "col", c
self.queryRowColumn = (r, c)
iren.GetRenderWindow().Finalize()
iren.TerminateApp()
iren.SetPicker(picker)
iren.AddObserver("LeftButtonPressEvent", pick_callback)
renWin.Render()
iren.Start()
# Return selection of a view in panel
r, c = self.queryRowColumn
fixedSlice = fixedArray[r*N:(r+1)*N, c*N:(c+1)*N]
movingSlice = movingArray[r*N:(r+1)*N, c*N:(c+1)*N]
return fixedSlice, movingSlice, fixedFrame[:,r], movingFrame[:,c]
def om_display_vtp(f, n = 0):
"""
This function displays a VTK::vtp file generated with OpenMEEG.
Such a file defines a polydata, containing points and triangles of several
meshes which are labelled through a vtkAbstractArray (Strings) associated to
the cells (mesh names).
Results of the forward problem (or a cortical mapping) can be seen thanks to
arrays associated to points and cells (respectively potentials and normals
currents).
"""
welcome = """Welcome\n\n
Switch the button: To either see Potentials (on points) or Currents (on triangles)\n
Move the slider to see all sources (columns of the input matrix)\n
Press 'r': To select points/cells.\n"""
# This callback function does updates the mappers for where n is the slider value
def CleanPickData(object, event):
for i in range(4):
rens[i].RemoveActor(selactor)
if buttonWidget.GetRepresentation().GetState():
PickData(object, event, selactor, 1, view, text_init)
else:
PickData(object, event, selactor, 0, view, text_init)
def SelectSource(object, event): # object will be the slider2D
slidervalue = int(round(object.GetRepresentation().GetValue()))
for i in range(4):
mappers[i].GetInput().GetPointData().SetActiveScalars("Potentials-"+str(slidervalue))
mappers[i].GetInput().GetCellData().SetActiveScalars("Currents-"+str(slidervalue))
renWin.SetWindowName(renWin.GetWindowName()[0:(renWin.GetWindowName().find('-')+1)]+str(slidervalue))
UpdateColorBar(colorBars[i], mappers[i])
# This callback function does updates the Scalar Mode To Use
def SelectMode(object, event):
# object will be the buttonWidget
for i in range(4):
if (object.GetRepresentation().GetState()):
mappers[i].SetScalarModeToUseCellData()
renWin.SetWindowName(renWin.GetWindowName().replace('Potentials','Currents'))
else:
mappers[i].SetScalarModeToUsePointData()
renWin.SetWindowName(renWin.GetWindowName().replace('Currents','Potentials'))
UpdateColorBar(colorBars[i], mappers[i])
# A window with an interactor
renWin = vtk.vtkRenderWindow()
renWin.SetSize(600, 600)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.SetInteractorStyle(vtk.vtkInteractorStyleRubberBandPick())
# A picker (to pick points/cells)
picker = vtk.vtkRenderedAreaPicker()
iren.SetPicker(picker)
# Read the input file
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(f); reader.Update()
poly = reader.GetOutput()
renWin.SetWindowName(f+' Potentials-'+str(n))
# determine the number of sources
nb_sources = 0
for i in range(poly.GetPointData().GetNumberOfArrays()):
if poly.GetPointData().GetGlobalIds('Potentials-'+str(i)):
nb_sources += 1
if n < nb_sources:
poly.GetPointData().SetActiveScalars('Potentials-'+str(n))
poly.GetCellData().SetActiveScalars('Currents-'+str(n))
# Get the mesh names
cell_labels = poly.GetCellData().GetAbstractArray(0)
assert(cell_labels.GetName()=='Names')
s = set(); nb_meshes = 0; cell_ids = list()
for i in range(cell_labels.GetNumberOfValues()):
s.add(cell_labels.GetValue(i))
if len(s)>nb_meshes:
# if a label is added, store the ID for the connectivity filter
cell_ids.append(i)
nb_meshes += 1
# Number of meshes
assert(nb_meshes<=4)
# Multiple viewports: 4
xmins = [0,.5,0,.5]; xmaxs = [0.5,1,0.5,1]; ymins = [0,0,.5,.5]; ymaxs = [0.5,0.5,1,1]
mappers = [vtk.vtkPolyDataMapper() for i in range(4)]
colorBars = [vtk.vtkScalarBarActor() for i in range(4)]
actors = [vtk.vtkActor() for i in range(4)]
rens = [vtk.vtkRenderer() for i in range(4)]
for i in range(4):
rens[i].SetViewport(xmins[i],ymins[i],xmaxs[i],ymaxs[i]);
# Display the meshes
if (i < nb_meshes):
# Create a connectivity filter based on cell seeded region (to display
# only one mesh per viewport)
conn = vtk.vtkPolyDataConnectivityFilter()
conn.SetInput(poly)
conn.SetExtractionModeToCellSeededRegions()
conn.AddSeed(cell_ids[i]); conn.Update()
actor_meshname = vtk.vtkTextActor();
actor_meshname.SetInput(cell_labels.GetValue(cell_ids[i]));
actor_meshname.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport();
actor_meshname.SetPosition(0.5, 0.85); tprop = actor_meshname.GetTextProperty(); tprop.SetFontSize(30)
tprop.SetFontFamilyToArial(); tprop.SetColor(1, 1, 1); tprop.SetJustificationToCentered()
mappers[i].SetInputConnection(conn.GetOutputPort())
mappers[i].SetScalarModeToUsePointData(); mappers[i].Update()
if nb_sources:
rens[i].AddActor2D(colorBars[i])
actors[i].SetMapper(mappers[i])
rens[i].AddActor2D(actor_meshname)
rens[i].AddActor(actors[i])
if (i == 0):
cam = rens[i].GetActiveCamera()
rens[i].ResetCamera()
else:
# Create a plane to cut
plane = vtk.vtkPlane(); plane.SetOrigin(0,0,0); plane.SetNormal(1,0,0);
# Create cutter
extract = vtk.vtkExtractPolyDataGeometry(); extract.SetInput(poly)
extract.SetImplicitFunction(plane); extract.ExtractBoundaryCellsOff()
mappers[i].SetInputConnection(extract.GetOutputPort())
mappers[i].SetScalarModeToUsePointData(); mappers[i].Update()
# Create plane actor
actors[i].SetMapper(mappers[i])
rens[i].AddActor(actors[i])
rens[i].SetActiveCamera(cam)
if nb_sources:
UpdateColorBar(colorBars[i], mappers[i])
renWin.AddRenderer(rens[i])
renWin.Render();
if nb_sources > 1:
# Slider
sliderWidget = vtk.vtkSliderWidget()
slider = vtk.vtkSliderRepresentation2D(); slider.SetMaximumValue(nb_sources-1)
slider.SetValue(n); slider.SetEndCapLength(0.01); slider.SetLabelFormat('%1.0f')
slider.SetSliderWidth(0.05); slider.SetSliderLength(1./nb_sources)
slider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedViewport()
slider.GetPoint1Coordinate().SetValue(.0 ,0.02)
slider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedViewport()
slider.GetPoint2Coordinate().SetValue(1. ,0.02);
sliderWidget.SetInteractor(iren); sliderWidget.SetRepresentation(slider);
sliderWidget.SetAnimationModeToAnimate(); sliderWidget.EnabledOn();
sliderWidget.AddObserver("InteractionEvent", SelectSource);
if not nb_sources == 0:
# The button for choosing Potentials/Currents
buttonWidget = vtk.vtkButtonWidget()
button = vtk.vtkTexturedButtonRepresentation2D(); button.SetNumberOfStates(2)
tex1r = vtk.vtkImageData(); tex2r = vtk.vtkImageData();
prop = vtk.vtkTextProperty(); prop.SetFontSize(24);
prop.SetColor(1,0,0); prop.SetBold(2); prop.SetShadow(2);
str2im = vtk.vtkFreeTypeStringToImage()
str2im.RenderString(prop,'Potentials',tex1r)
str2im.RenderString(prop,'Currents',tex2r)
button.SetButtonTexture(0, tex1r)
button.SetButtonTexture(1, tex2r)
buttonWidget.SetInteractor(iren);
buttonWidget.SetRepresentation(button);
button.SetPlaceFactor(1);
button.PlaceWidget([0., 100, 50, 500, 0, 0]);
buttonWidget.On()
buttonWidget.AddObserver(vtk.vtkCommand.StateChangedEvent,SelectMode);
# Selection
selactor = vtk.vtkActor()
view = vtk.vtkContextView(); view.GetRenderWindow().SetWindowName('Plot')
view.GetRenderWindow().SetPosition(600, 0); view.GetRenderWindow().SetSize(600, 600)
# Welcome text
text_init = vtk.vtkTextActor()
text_init.SetPosition(10, 300)
text_init.SetInput(welcome)
text_init.GetTextProperty().SetColor(1.0, 0.0, 0.0)
view.GetRenderer().AddActor2D(text_init)
view.GetInteractor().Initialize()
iren.AddObserver(vtk.vtkCommand.EndPickEvent,CleanPickData)
iren.Initialize()
iren.Start()
def om_display_vtk(f,d = 0,n = 0):
"""
This function displays a VTK::vtk file generated with OpenMEEG.
Such a file defines a polydata, containing points and triangles of a single
mesh. Most often a EEG helmet mesh and associated leadfield.
"""
welcome = """Welcome\n\n
Move the slider to see all sources (columns of the input matrix)\n
Press 'r': To select points/cells.\n"""
# This callback function does updates the mappers for where n is the slider value
def CleanPickData(object, event):
ren.RemoveActor(selactor)
PickData(object, event, selactor, 0, view, text_init)
def SelectSource(object, event): # object will be the slider2D
slidervalue = int(round(object.GetRepresentation().GetValue()))
mapper.GetInput().GetPointData().SetActiveScalars("Potentials-"+str(slidervalue))
renWin.SetWindowName(renWin.GetWindowName()[0:(renWin.GetWindowName().find('-')+1)]+str(slidervalue))
UpdateColorBar(colorBar, mapper)
# A window with an interactor
renWin = vtk.vtkRenderWindow()
renWin.SetSize(600, 600)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.SetInteractorStyle(vtk.vtkInteractorStyleRubberBandPick())
# A picker (to pick points/cells)
picker = vtk.vtkRenderedAreaPicker()
iren.SetPicker(picker)
# Read the input file
reader = vtk.vtkPolyDataReader()
reader.SetFileName(f); reader.Update()
poly = reader.GetOutput()
renWin.SetWindowName(f+' Potentials-'+str(n))
# determine the number of sources
nb_sources = 0
for i in range(poly.GetPointData().GetNumberOfArrays()):
if poly.GetPointData().GetGlobalIds('Potentials-'+str(i)):
nb_sources += 1
if nb_sources == 0: #the file doesn't provide potentials
if not d.__class__ == int:
assert(d.shape[0] == poly.GetNumberOfPoints())
nb_sources = d.shape[1]
pot = [vtk.vtkDoubleArray() for j in range(d.shape[1])]
for j in range(d.shape[1]):
pot[j].SetName('Potentials-'+str(j))
for i in range(d.shape[0]):
pot[j].InsertNextValue(d[i,j])
poly.GetPointData().AddArray(pot[j])
poly.Update()
if not poly.GetPointData().GetGlobalIds('Indices'):
ind = vtk.vtkUnsignedIntArray()
ind.SetName('Indices')
for i in range(poly.GetNumberOfPoints()):
ind.InsertNextValue(i)
poly.GetPointData().AddArray(ind)
poly.GetPointData().SetActiveScalars('Potentials-'+str(n))
mapper = vtk.vtkPolyDataMapper()
colorBar = vtk.vtkScalarBarActor()
actor = vtk.vtkActor()
ren = vtk.vtkRenderer()
mapper.SetInput(poly)
mapper.SetScalarModeToUsePointData(); mapper.Update()
actor.SetMapper(mapper)
ren.AddActor(actor)
if nb_sources:
ren.AddActor2D(colorBar)
UpdateColorBar(colorBar, mapper)
renWin.AddRenderer(ren)
renWin.Render()
if nb_sources > 1:
# Slider
sliderWidget = vtk.vtkSliderWidget()
slider = vtk.vtkSliderRepresentation2D(); slider.SetMaximumValue(nb_sources-1)
slider.SetValue(n); slider.SetEndCapLength(0.01); slider.SetLabelFormat('%1.0f')
slider.SetSliderWidth(0.05); slider.SetSliderLength(1./nb_sources)
slider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedViewport()
slider.GetPoint1Coordinate().SetValue(.0, 0.02)
slider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedViewport()
slider.GetPoint2Coordinate().SetValue(1., 0.02);
sliderWidget.SetInteractor(iren); sliderWidget.SetRepresentation(slider);
sliderWidget.SetAnimationModeToAnimate(); sliderWidget.EnabledOn();
sliderWidget.AddObserver("InteractionEvent", SelectSource);
# Selection
selactor = vtk.vtkActor()
view = vtk.vtkContextView(); view.GetRenderWindow().SetWindowName('Plot')
view.GetRenderWindow().SetPosition(600, 0); view.GetRenderWindow().SetSize(600, 600)
# Welcome text
text_init = vtk.vtkTextActor()
text_init.SetPosition(10, 300)
text_init.SetInput(welcome)
text_init.GetTextProperty().SetColor(1.0, 0.0, 0.0)
view.GetRenderer().AddActor2D(text_init)
view.GetInteractor().Initialize()
iren.AddObserver(vtk.vtkCommand.EndPickEvent,CleanPickData)
iren.Initialize()
iren.Start()
def __init__(self, data_source, input_link):
"""Parallel coordinates view constructor needs a valid DataSource plus
and external annotation link (from the icicle view).
"""
self.ds = data_source
self.input_link = input_link
# Set up callback to listen for changes in IcicleView selections
self.input_link.AddObserver("AnnotationChangedEvent", self.InputSelectionCallback)
# Set up an annotation link for other views to monitor selected image
self.output_link = vtk.vtkAnnotationLink()
# If you don't set the FieldType explicitly it ends up as UNKNOWN (as of 21 Feb 2010)
# See vtkSelectionNode doc for field and content type enum values
self.output_link.GetCurrentSelection().GetNode(0).SetFieldType(1) # Point
# The chart seems to force INDEX selection, so I'm using vtkConvertSelection below to get
# out PedigreeIds...
self.output_link.GetCurrentSelection().GetNode(0).SetContentType(2) # 2 = PedigreeIds, 4 = Indices
# Going to manually create output_link selection list, so not setting up callback for it...
if os.path.isfile(os.path.abspath('BlankImage.png')):
blank_file = 'BlankImage.png'
else:
# For use in app bundles
blank_file = os.path.join(sys.path[0],'BlankImage.png')
self.blankImageReader = vtk.vtkPNGReader()
self.blankImageReader.SetFileName(blank_file)
self.blankImageReader.Update()
tmp = self.blankImageReader.GetOutput().GetBounds()
self.flowSpacing = float(tmp[1]-tmp[0])*1.1
self.nupSpacing = float(tmp[3]-tmp[2])*1.1
# Create a blue-white-red lookup table
self.lut = vtk.vtkLookupTable()
lutNum = 256
self.lut.SetNumberOfTableValues(lutNum)
ctf = vtk.vtkColorTransferFunction()
ctf.SetColorSpaceToDiverging()
c_blue = N.array([59,76,192],dtype='float')/255.0
# c_gray = [0.8, 0.8, 0.8]
c_red = N.array([180,4,38],dtype='float')/255.0
ctf.AddRGBPoint(0.0, c_blue[0], c_blue[1], c_blue[2]) # blue
# ctf.AddRGBPoint(0.5, c_gray[0], c_gray[1], c_gray[2]) # blue
ctf.AddRGBPoint(1.0, c_red[0], c_red[1], c_red[2]) # red
for ii,ss in enumerate([float(xx)/float(lutNum) for xx in range(lutNum)]):
cc = ctf.GetColor(ss)
self.lut.SetTableValue(ii,cc[0],cc[1],cc[2],1.0)
self.lut.SetRange(-10,10)
# Map the image through the lookup table
self.color = vtk.vtkImageMapToColors()
self.color.SetLookupTable(self.lut)
self.color.SetInput(self.blankImageReader.GetOutput())
self.resliceList = []
self.actorList = []
self.numImages = 1
# Map between indices of images and their Pedigree ID
self.pedigree_id_dict = {}
blankImageActor = vtk.vtkImageActor()
blankImageActor.SetInput(self.color.GetOutput())
blankImageActor.SetPickable(False)
blankImageActor.SetOpacity(0.1)
self.actorList.append(blankImageActor)
self.expSpread = 0.5
self.maxAngle = 80.0
self.renderer = vtk.vtkRenderer()
self.cam = self.renderer.GetActiveCamera()
# renderer.SetBackground(0.15, 0.12, 0.1)
cc = [68,57,53]
cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in cc]
self.renderer.SetBackground(cc0,cc1,cc2)
self.renderer.AddActor(self.actorList[0])
self.highlightRect = vtk.vtkOutlineSource()
self.highlightRect.SetBounds(self.actorList[0].GetBounds())
self.highlightMapper = vtk.vtkPolyDataMapper()
self.highlightMapper.SetInputConnection(self.highlightRect.GetOutputPort(0))
self.highlightActor = vtk.vtkActor()
self.highlightActor.SetMapper(self.highlightMapper)
self.highlightActor.GetProperty().SetColor(1,0.8,0.2)
self.highlightActor.GetProperty().SetLineWidth(3.0)
self.highlightActor.SetOrientation(self.actorList[0].GetOrientation())
tmpPos = self.actorList[0].GetPosition()
usePos = (tmpPos[0],tmpPos[1],tmpPos[2]+0.01)
self.highlightActor.SetPosition(usePos)
# Setting as if nothing picked even though initialized position & orientation to actor0
self.highlightIndex = -1
self.highlightActor.SetPickable(False)
self.highlightActor.SetVisibility(False)
self.renderer.AddActor(self.highlightActor)
# Create the slider which will control the image positions
self.sliderRep = vtk.vtkSliderRepresentation2D()
self.sliderRep.SetMinimumValue(0)
self.sliderRep.SetMaximumValue(self.numImages)
self.sliderRep.SetValue(0)
self.window = vtk.vtkRenderWindow()
self.window.SetSize(600,300)
self.window.AddRenderer(self.renderer)
# Set up the interaction
self.interactorStyle = vtk.vtkInteractorStyleRubberBand3D()
self.interactor = vtk.vtkRenderWindowInteractor()
self.interactor.SetInteractorStyle(self.interactorStyle)
self.window.SetInteractor(self.interactor)
self.sliderWidget = vtk.vtkSliderWidget()
self.sliderWidget.SetInteractor(self.interactor)
self.sliderWidget.SetRepresentation(self.sliderRep)
self.sliderWidget.SetAnimationModeToAnimate()
self.sliderWidget.EnabledOn()
self.sliderWidget.AddObserver("InteractionEvent", self.sliderCallback)
self.sliderWidget.AddObserver("EndInteractionEvent", self.endSliderCallback)
# Default flow direction Horizontal
self.FlowDirection = Direction.Horizontal
self.SetFlowDirection(self.FlowDirection)
# Set up callback to toggle between inspect modes (manip axes & select data)
self.interactorStyle.AddObserver("SelectionChangedEvent", self.selectImage)
# Set up callback to toggle between inspect modes (manip axes & select data)
self.interactor.AddObserver("UserEvent", self.PrintCameraPosition)
self.cam.ParallelProjectionOn()
self.renderer.ResetCamera(self.actorList[0].GetBounds())
self.cam.Elevation(10)
self.renderer.ResetCameraClippingRange()
self.window.Render()
# render window interactor
iren = vtk.vtkRenderWindowInteractor()
iren.SetSize(1500,1500)
iren.SetRenderWindow( renWin )
# add the actors
ren.AddActor( outlineActor )
ren.AddActor( isosurfaceActor )
#==============================================================================
# Interactive Slider representation
#==============================================================================
SliderRepres = vtk.vtkSliderRepresentation2D()
SliderRepres.SetMinimumValue(min)
SliderRepres.SetMaximumValue(max)
SliderRepres.SetValue((min + max) / 2)
SliderRepres.SetTitleText("Interactive Slider")
SliderRepres.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderRepres.GetPoint1Coordinate().SetValue(0.3, 0.05)
SliderRepres.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderRepres.GetPoint2Coordinate().SetValue(0.7, 0.05)
SliderRepres.SetSliderLength(0.02)
SliderRepres.SetSliderWidth(0.03)
SliderRepres.SetEndCapLength(0.01)
SliderRepres.SetEndCapWidth(0.03)
SliderRepres.SetTubeWidth(0.005)
SliderRepres.SetTitleHeight(0.02)
def main(argv):
if os.name == 'nt':
VTK_DATA_ROOT = "c:/VTK82/build_Release/ExternalData/Testing/"
else:
VTK_DATA_ROOT = "/home/jmh/"
if 1:
v16 = vtk.vtkMetaImageReader()
v16.SetFileName("/home/jmh/github/fis/data/Abdomen/CT-Abdomen.mhd")
v16.Update()
elif 0:
fname = os.path.join(VTK_DATA_ROOT, "Data/headsq/quarter")
v16 = vtk.vtkVolume16Reader()
v16.SetDataDimensions(64, 64)
v16.SetDataByteOrderToLittleEndian()
v16.SetImageRange(1, 93)
v16.SetDataSpacing(3.2, 3.2, 1.5)
v16.SetFilePrefix(fname)
v16.ReleaseDataFlagOn()
v16.SetDataMask(0x7fff)
v16.Update()
else:
v16 = vtk.vtkMetaImageReader()
v16.SetFileName("c:/github/fis/data/Abdomen/CT-Abdomen.mhd")
v16.Update()
rng = v16.GetOutput().GetScalarRange()
shifter = vtk.vtkImageShiftScale()
shifter.SetShift(-1.0*rng[0])
shifter.SetScale(255.0/(rng[1]-rng[0]))
shifter.SetOutputScalarTypeToUnsignedChar()
shifter.SetInputConnection(v16.GetOutputPort())
shifter.ReleaseDataFlagOff()
shifter.Update()
ImageViewer = vtk.vtkImageViewer2()
ImageViewer.SetInputData(shifter.GetOutput())
ImageViewer.SetColorLevel(127)
ImageViewer.SetColorWindow(255)
iren = vtk.vtkRenderWindowInteractor()
ImageViewer.SetupInteractor(iren)
ImageViewer.Render()
ImageViewer.GetRenderer().ResetCamera()
ImageViewer.Render()
dims = v16.GetOutput().GetDimensions()
global minArea
spacing = v16.GetOutput().GetSpacing()
minArea = ( spacing[0] * spacing[1] ) / 0.1
# Slider screen representation
SliderRepres = vtk.vtkSliderRepresentation2D()
_min = ImageViewer.GetSliceMin()
_max = ImageViewer.GetSliceMax()
SliderRepres.SetMinimumValue(_min)
SliderRepres.SetMaximumValue(_max)
SliderRepres.SetValue(int((_min + _max) / 2))
SliderRepres.SetTitleText("Slice")
SliderRepres.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderRepres.GetPoint1Coordinate().SetValue(0.3, 0.05)
SliderRepres.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderRepres.GetPoint2Coordinate().SetValue(0.7, 0.05)
SliderRepres.SetSliderLength(0.02)
SliderRepres.SetSliderWidth(0.03)
SliderRepres.SetEndCapLength(0.01)
SliderRepres.SetEndCapWidth(0.03)
SliderRepres.SetTubeWidth(0.005)
SliderRepres.SetLabelFormat("%3.0lf")
SliderRepres.SetTitleHeight(0.02)
SliderRepres.SetLabelHeight(0.02)
# Slider widget
SliderWidget = vtk.vtkSliderWidget()
SliderWidget.SetInteractor(iren)
SliderWidget.SetRepresentation(SliderRepres)
SliderWidget.KeyPressActivationOff()
SliderWidget.SetAnimationModeToAnimate()
SliderWidget.SetEnabled(True)
SliderCb = vtkSliderCallback()
SliderCb.SetImageViewer(ImageViewer)
SliderWidget.AddObserver(vtk.vtkCommand.InteractionEvent, SliderCb.Execute)
ImageViewer.SetSlice(int(SliderRepres.GetValue()))
# Contour representation - responsible for placement of points, calculation of lines and contour manipulation
global rep
rep = vtk.vtkOrientedGlyphContourRepresentation()
# vtkContourRepresentation has GetActiveNodeWorldPostion/Orientation
rep.GetProperty().SetOpacity(0) #1
prop = rep.GetLinesProperty()
from vtkUtils import renderLinesAsTubes
from vtk.util.colors import red, green, pink, yellow
renderLinesAsTubes(prop)
prop.SetColor(yellow)
propActive = rep.GetActiveProperty()
#propActive.SetOpacity(0) # 2
renderLinesAsTubes(propActive)
propActive.SetColor(green)
shapeActive = rep.GetActiveCursorShape()
warp = vtk.vtkWarpVector()
warp.SetInputData(shapeActive)
warp.SetInputArrayToProcess(0, 0, 0,
vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS,
vtk.vtkDataSetAttributes.NORMALS)
scale = 0.4
warp.SetScaleFactor(scale)
warp.Update()
rep.SetActiveCursorShape(warp.GetOutput())
# Use vtkContourTriangulator to fill contours
# Point placer
imageActorPointPlacer = vtk.vtkImageActorPointPlacer()
imageActorPointPlacer.SetImageActor(ImageViewer.GetImageActor())
rep.SetPointPlacer(imageActorPointPlacer)
global ContourWidget
# Contour widget - has a vtkWidgetEventTranslator which translate events to vtkContourWidget events
ContourWidget = vtk.vtkContourWidget()
ContourWidget.SetRepresentation(rep)
ContourWidget.SetInteractor(iren)
ContourWidget.SetEnabled(True)
ContourWidget.ProcessEventsOn()
ContourWidget.ContinuousDrawOn()
# Can be Initialize() using polydata
# Override methods that returns display position to get an overlay
# (display postions) instead of computing it from world position and
# the method BuildLines to interpolate using display positions
# instead of world positions
# Thinning of contour control points
# AddFinalPointAction
ContourWidget.AddObserver(vtk.vtkCommand.EndInteractionEvent, callback)
if 0:
# TODO: Make interior transparent
contour = ContourWidget.GetContourRepresentation().GetContourRepresentationAsPolyData()
tc = vtk.vtkContourTriangulator()
tc.SetInputData(contour)
tc.Update()
# Extrusion towards camera
extruder = vtk.vtkLinearExtrusionFilter()
extruder.CappingOn()
extruder.SetScalaFactor(1.0)
extruder.SetInputData(tc.GetOutput())
extruder.SetVector(0,0,1.0)
extruder.SetExtrusionTypeToNormalExtrusion()
polyMapper = vtk.vtkPolyMapper()
polyMapper.SetInputConnection(extruder.GetOutputPort())
polyMapper.ScalarVisibilityOn()
polyMapper.Update()
polyActor = vtk.vtkActor()
polyActor.SetMapper(polyMapper)
prop = polyActor.GetProperty()
prop.SetColor(0,1,0)
#prop.SetRepresentationToWireframe()
renderer.AddActor(polyActor)
renderer.GetRenderWindow().Render()
iren.Start()
def Display(self):
wholeExtent = self.Image.GetExtent()
self.SliceVOI[0] = wholeExtent[0]
self.SliceVOI[1] = wholeExtent[1]
self.SliceVOI[2] = wholeExtent[2]
self.SliceVOI[3] = wholeExtent[3]
self.SliceVOI[4] = wholeExtent[4]
self.SliceVOI[5] = wholeExtent[5]
self.SliceVOI[self.Axis * 2] = wholeExtent[self.Axis * 2]
self.SliceVOI[self.Axis * 2 + 1] = wholeExtent[self.Axis * 2]
range = self.Image.GetScalarRange()
imageShifter = vtk.vtkImageShiftScale()
imageShifter.SetInput(self.Image)
imageShifter.SetShift(-1.0 * range[0])
imageShifter.SetScale(255.0 / (range[1] - range[0]))
imageShifter.SetOutputScalarTypeToUnsignedChar()
widgetImage = imageShifter.GetOutput()
self.ImageActor.SetInput(widgetImage)
self.ImageActor.SetDisplayExtent(self.SliceVOI)
self.vmtkRenderer.Renderer.AddActor(self.ImageActor)
if self.Type == "freehand":
self.ImageTracerWidget.SetCaptureRadius(1.5)
self.ImageTracerWidget.SetViewProp(self.ImageActor)
self.ImageTracerWidget.SetInput(widgetImage)
self.ImageTracerWidget.ProjectToPlaneOn()
self.ImageTracerWidget.SetProjectionNormal(self.Axis)
self.ImageTracerWidget.PlaceWidget()
self.ImageTracerWidget.SetAutoClose(self.AutoClose)
self.ImageTracerWidget.AddObserver("StartInteractionEvent", self.SetWidgetProjectionPosition)
self.ImageTracerWidget.AddObserver("EndInteractionEvent", self.GetLineFromWidget)
elif self.Type == "contour":
self.ImageTracerWidget.AddObserver("EndInteractionEvent", self.GetLineFromWidget)
self.ImageTracerWidget.ContinuousDrawOff()
sliderRep = vtk.vtkSliderRepresentation2D()
sliderRep.SetValue(0.5 * (wholeExtent[self.Axis * 2] + wholeExtent[self.Axis * 2 + 1]))
sliderRep.SetMinimumValue(wholeExtent[self.Axis * 2])
sliderRep.SetMaximumValue(wholeExtent[self.Axis * 2 + 1])
sliderRep.SetTitleText("Slice")
sliderRep.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
sliderRep.GetPoint1Coordinate().SetValue(0.2, 0.9)
sliderRep.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
sliderRep.GetPoint2Coordinate().SetValue(0.8, 0.9)
sliderRep.SetSliderLength(0.02)
sliderRep.SetSliderWidth(0.03)
sliderRep.SetEndCapLength(0.01)
sliderRep.SetEndCapWidth(0.03)
sliderRep.SetTubeWidth(0.005)
sliderRep.SetLabelFormat("%.0f")
self.SliderWidget.AddObserver("InteractionEvent", self.ChangeSlice)
self.SliderWidget.SetRepresentation(sliderRep)
self.SliderWidget.EnabledOn()
interactorStyle = vtk.vtkInteractorStyleImage()
self.vmtkRenderer.RenderWindowInteractor.SetInteractorStyle(interactorStyle)
self.vmtkRenderer.Render()
def __init__(self, args):
# Image loading
self.isovalue = args.isoval
self.clip_x = args.clip[0]
self.clip_y = args.clip[1]
self.clip_z = args.clip[2]
ct_name = args.data
ct_image = vtk.vtkXMLImageDataReader()
ct_image.SetFileName(ct_name)
ct_image.Update()
self.contours = vtk.vtkContourFilter()
self.contours.SetInputConnection(ct_image.GetOutputPort())
self.contours.ComputeNormalsOn()
self.contours.SetValue(0, self.isovalue)
#Cutting planes
self.plane_x = vtk.vtkPlane()
self.plane_x.SetOrigin(self.clip_x, 0, 0)
self.plane_x.SetNormal(1, 0, 0)
self.clipper_x = vtk.vtkClipPolyData()
self.clipper_x.SetClipFunction(self.plane_x)
self.clipper_x.SetInputConnection(self.contours.GetOutputPort())
self.plane_y = vtk.vtkPlane()
self.plane_y.SetOrigin(0, self.clip_y, 0)
self.plane_y.SetNormal(0, 1, 0)
self.clipper_y = vtk.vtkClipPolyData()
self.clipper_y.SetClipFunction(self.plane_y)
self.clipper_y.SetInputConnection(self.clipper_x.GetOutputPort())
self.plane_z = vtk.vtkPlane()
self.plane_z.SetOrigin(0, 0, self.clip_z)
self.plane_z.SetNormal(0, 0, 1)
self.clipper_z = vtk.vtkClipPolyData()
self.clipper_z.SetClipFunction(self.plane_z)
self.clipper_z.SetInputConnection(self.clipper_y.GetOutputPort())
#Color map
color_scale = vtk.vtkColorTransferFunction()
color_scale.SetColorSpaceToRGB()
color_scale.AddRGBPoint(1319, 0.9, 0.9, 0.9)
color_scale.AddRGBPoint(1153, 0.9, 0.9, 0.9)
color_scale.AddRGBPoint(1140, 192 / 256, 104 / 256, 88 / 256) # muscle
color_scale.AddRGBPoint(1040, 248 / 256, 10 / 256, 10 / 256) # muscle
color_scale.AddRGBPoint(500, 177 / 256, 122 / 256, 101 / 256) # skin
color_scale.AddRGBPoint(753, 197 / 256, 140 / 256, 133 / 256) # skin
#Color Bar
color_bar = vtk.vtkScalarBarActor()
color_bar.SetLookupTable(color_scale)
color_bar.SetTitle("Isovalues Scale")
color_bar.SetLabelFormat("%4.0f")
color_bar.SetPosition(0.9, 0.1)
color_bar.SetWidth(0.1)
color_bar.SetHeight(0.7)
# mapper and actor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(self.clipper_z.GetOutputPort())
mapper.SetLookupTable(color_scale)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
interactive_ren = vtk.vtkRenderWindowInteractor()
interactive_ren.SetRenderWindow(render_window)
renderer.AddActor(actor)
renderer.AddActor(color_bar)
renderer.ResetCamera()
renderer.SetBackground(0.2, 0.3, 0.4)
renderer.ResetCameraClippingRange()
slider_isovalue = vtk.vtkSliderRepresentation2D()
slider_isovalue.SetMinimumValue(100)
slider_isovalue.SetMaximumValue(2000)
slider_isovalue.SetValue(self.isovalue)
slider_isovalue.SetTitleText("Isovalue")
slider_isovalue.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
slider_isovalue.GetPoint1Coordinate().SetValue(0.01, 0.4)
slider_isovalue.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
slider_isovalue.GetPoint2Coordinate().SetValue(0.2, 0.4)
slider_isovalue.SetSliderLength(0.01)
slider_isovalue.SetSliderWidth(0.03)
slider_isovalue.SetEndCapLength(0.01)
slider_isovalue.SetEndCapWidth(0.03)
slider_isovalue.SetTubeWidth(0.005)
slider_isovalue.SetLabelFormat("%3.0lf")
slider_isovalue.SetTitleHeight(0.02)
slider_isovalue.SetLabelHeight(0.02)
slider_widget_isovalues = vtk.vtkSliderWidget()
slider_widget_isovalues.SetInteractor(interactive_ren)
slider_widget_isovalues.SetRepresentation(slider_isovalue)
slider_widget_isovalues.KeyPressActivationOff()
slider_widget_isovalues.SetAnimationModeToAnimate()
slider_widget_isovalues.SetEnabled(True)
slider_widget_isovalues.AddObserver("EndInteractionEvent",
self.slider_isovalue_handler)
slider_clip_x = vtk.vtkSliderRepresentation2D()
slider_clip_x.SetMinimumValue(0)
slider_clip_x.SetMaximumValue(190)
slider_clip_x.SetValue(self.clip_x)
slider_clip_x.SetTitleText("X")
slider_clip_x.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
slider_clip_x.GetPoint1Coordinate().SetValue(0.01, 0.3)
slider_clip_x.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
slider_clip_x.GetPoint2Coordinate().SetValue(0.2, 0.3)
slider_clip_x.SetSliderLength(0.01)
slider_clip_x.SetSliderWidth(0.03)
slider_clip_x.SetEndCapLength(0.01)
slider_clip_x.SetEndCapWidth(0.03)
slider_clip_x.SetTubeWidth(0.005)
slider_clip_x.SetLabelFormat("%1.2lf")
slider_clip_x.SetTitleHeight(0.02)
slider_clip_x.SetLabelHeight(0.02)
slider_widget_x = vtk.vtkSliderWidget()
slider_widget_x.SetInteractor(interactive_ren)
slider_widget_x.SetRepresentation(slider_clip_x)
slider_widget_x.KeyPressActivationOff()
slider_widget_x.SetAnimationModeToAnimate()
slider_widget_x.SetEnabled(True)
slider_widget_x.AddObserver("EndInteractionEvent",
self.clip_x_slider_handler)
slider_clip_y = vtk.vtkSliderRepresentation2D()
slider_clip_y.SetMinimumValue(0)
slider_clip_y.SetMaximumValue(190)
slider_clip_y.SetValue(self.clip_y)
slider_clip_y.SetTitleText("Y")
slider_clip_y.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
slider_clip_y.GetPoint1Coordinate().SetValue(0.01, 0.2)
slider_clip_y.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
slider_clip_y.GetPoint2Coordinate().SetValue(0.2, 0.2)
slider_clip_y.SetSliderLength(0.01)
slider_clip_y.SetSliderWidth(0.03)
slider_clip_y.SetEndCapLength(0.01)
slider_clip_y.SetEndCapWidth(0.03)
slider_clip_y.SetTubeWidth(0.005)
slider_clip_y.SetLabelFormat("%1.2lf")
slider_clip_y.SetTitleHeight(0.02)
slider_clip_y.SetLabelHeight(0.02)
slider_widget_y = vtk.vtkSliderWidget()
slider_widget_y.SetInteractor(interactive_ren)
slider_widget_y.SetRepresentation(slider_clip_y)
slider_widget_y.KeyPressActivationOff()
slider_widget_y.SetAnimationModeToAnimate()
slider_widget_y.SetEnabled(True)
slider_widget_y.AddObserver("EndInteractionEvent",
self.clip_y_slider_handler)
slider_clip_z = vtk.vtkSliderRepresentation2D()
slider_clip_z.SetMinimumValue(0)
slider_clip_z.SetMaximumValue(190)
slider_clip_z.SetValue(self.clip_z)
slider_clip_z.SetTitleText("Z")
slider_clip_z.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
slider_clip_z.GetPoint1Coordinate().SetValue(0.01, 0.1)
slider_clip_z.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedDisplay()
slider_clip_z.GetPoint2Coordinate().SetValue(0.2, 0.1)
slider_clip_z.SetSliderLength(0.01)
slider_clip_z.SetSliderWidth(0.03)
slider_clip_z.SetEndCapLength(0.01)
slider_clip_z.SetEndCapWidth(0.03)
slider_clip_z.SetTubeWidth(0.005)
slider_clip_z.SetLabelFormat("%1.2lf")
slider_clip_z.SetTitleHeight(0.02)
slider_clip_z.SetLabelHeight(0.02)
slider_widget_z = vtk.vtkSliderWidget()
slider_widget_z.SetInteractor(interactive_ren)
slider_widget_z.SetRepresentation(slider_clip_z)
slider_widget_z.KeyPressActivationOff()
slider_widget_z.SetAnimationModeToAnimate()
slider_widget_z.SetEnabled(True)
slider_widget_z.AddObserver("EndInteractionEvent",
self.clip_z_slider_handler)
# Render
interactive_ren.Initialize()
render_window.SetSize(800, 600)
render_window.SetWindowName(
"Project 3a: Isocontours - Pedro Acevedo & Randy Consuegra")
render_window.Render()
interactive_ren.Start()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetInterpolationToFlat()
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renWinInteractor = vtk.vtkRenderWindowInteractor()
renWinInteractor.SetRenderWindow(renderWin)
renderer.AddActor(actor)
renderWin.Render()
#build a slide bar
slideBar = vtk.vtkSliderRepresentation2D()
slideBar.SetMinimumValue(3.0)
slideBar.SetMaximumValue(20.0)
slideBar.SetTitleText("sphere")
slideBar.GetSliderProperty().SetColor(1,0,0)
slideBar.GetTitleProperty().SetColor(1,0,0)
slideBar.GetLabelProperty().SetColor(1,0,0)
slideBar.GetSelectedProperty().SetColor(1,0,0)
slideBar.GetTubeProperty().SetColor(0,1,0)
slideBar.GetCapProperty().SetColor(1,1,0)
slideBar.GetPoint1Coordinate().SetCoordinateSystemToDisplay()
slideBar.GetPoint1Coordinate().SetValue(40,40)
def slider(iren,
ren,
callback,
min_value=0,
max_value=255,
value=125,
label="Slider",
right_normalized_pos=(0.9, 0.5),
size=(50, 0),
label_format="%0.0lf",
color=(0.5, 0.5, 0.5),
selected_color=(0.9, 0.2, 0.1)):
""" A 2D slider widget
Parameters
----------
iren : vtkRenderWindowInteractor
Used to process events and handle them to the slider. Can also be given
by the attribute ``ShowManager.iren``.
ren : vtkRenderer or Renderer
Used to update the slider's position when the window changes. Can also
be given by the ``ShowManager.ren`` attribute.
callback : function
Function that has at least ``obj`` and ``event`` as parameters. It will
be called when the slider's bar has changed.
min_value : float
Minimum value of slider.
max_value : float
Maximum value of slider.
value :
Default value of slider.
label : str
Slider's caption.
right_normalized_pos : tuple
2d tuple holding the normalized right (X, Y) position of the slider.
size: tuple
2d tuple holding the size of the slider in pixels.
label_format: str
Formating in which the slider's value will appear for example "%0.2lf"
allows for 2 decimal values.
Returns
-------
slider : SliderObject
This object inherits from vtkSliderWidget and has additional method
called ``place`` which allows to update the position of the slider
when for example the window is resized.
"""
slider_rep = vtk.vtkSliderRepresentation2D()
slider_rep.SetMinimumValue(min_value)
slider_rep.SetMaximumValue(max_value)
slider_rep.SetValue(value)
slider_rep.SetTitleText(label)
slider_rep.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
slider_rep.GetPoint2Coordinate().SetValue(*right_normalized_pos)
coord2 = slider_rep.GetPoint2Coordinate().GetComputedDisplayValue(ren)
slider_rep.GetPoint1Coordinate().SetCoordinateSystemToDisplay()
slider_rep.GetPoint1Coordinate().SetValue(coord2[0] - size[0],
coord2[1] - size[1])
initial_window_size = ren.GetSize()
length = 0.04
width = 0.04
cap_length = 0.01
cap_width = 0.01
tube_width = 0.005
slider_rep.SetSliderLength(length)
slider_rep.SetSliderWidth(width)
slider_rep.SetEndCapLength(cap_length)
slider_rep.SetEndCapWidth(cap_width)
slider_rep.SetTubeWidth(tube_width)
slider_rep.SetLabelFormat(label_format)
slider_rep.GetLabelProperty().SetColor(*color)
slider_rep.GetTubeProperty().SetColor(*color)
slider_rep.GetCapProperty().SetColor(*color)
slider_rep.GetTitleProperty().SetColor(*color)
slider_rep.GetSelectedProperty().SetColor(*selected_color)
slider_rep.GetSliderProperty().SetColor(*color)
slider_rep.GetLabelProperty().SetShadow(0)
slider_rep.GetTitleProperty().SetShadow(0)
class SliderWidget(vtk.vtkSliderWidget):
def place(self, ren):
slider_rep = self.GetRepresentation()
coord2_norm = slider_rep.GetPoint2Coordinate()
coord2_norm.SetCoordinateSystemToNormalizedDisplay()
coord2_norm.SetValue(*right_normalized_pos)
coord2 = coord2_norm.GetComputedDisplayValue(ren)
slider_rep.GetPoint1Coordinate().SetCoordinateSystemToDisplay()
slider_rep.GetPoint1Coordinate().SetValue(coord2[0] - size[0],
coord2[1] - size[1])
window_size = ren.GetSize()
length = initial_window_size[0] * 0.04 / window_size[0]
width = initial_window_size[1] * 0.04 / window_size[1]
slider_rep.SetSliderLength(length)
slider_rep.SetSliderWidth(width)
def set_value(self, value):
return self.GetSliderRepresentation().SetValue(value)
def get_value(self):
return self.GetSliderRepresentation().GetValue()
slider = SliderWidget()
slider.SetInteractor(iren)
slider.SetRepresentation(slider_rep)
slider.SetAnimationModeToAnimate()
slider.KeyPressActivationOff()
slider.AddObserver("InteractionEvent", callback)
slider.SetEnabled(True)
# Place widget after window resizing.
def _place_widget(obj, event):
slider.place(ren)
iren.GetRenderWindow().AddObserver(vtk.vtkCommand.StartEvent,
_place_widget)
iren.GetRenderWindow().AddObserver(vtk.vtkCommand.ModifiedEvent,
_place_widget)
return slider
def create(self):
self.params = {}
self.cparams = {"algorithm":"Yi"}
status = EditUtil.EditUtil().getParameterNode().GetParameter('QuickTCGAEffect,erich')
if (status == "reset"):
params = {}
super(QuickTCGAEffectOptions,self).create()
# self.helpLabel = qt.QLabel("Press Y to run automatic segmentation on the current image using given parameters.", self.frame)
# self.frame.layout().addWidget(self.helpLabel)
#self.clearButton = qt.QPushButton(self.frame)
#self.clearButton.text = "Clear Selection"
#self.frame.layout().addWidget(self.clearButton)
#self.clearButton.connect('clicked()', self.clearSelection)
self.segnoButton = qt.QPushButton(self.frame)
self.segnoButton.text = "Run Segmentation No Declumping (fast)"
self.frame.layout().addWidget(self.segnoButton)
self.segnoButton.connect('clicked()', self.RunSegmenterWO)
self.segButton = qt.QPushButton(self.frame)
self.segButton.text = "Run Segmentation With Declumping (slow)"
self.frame.layout().addWidget(self.segButton)
self.segButton.connect('clicked()', self.RunSegmenter)
self.outlineButton = qt.QPushButton(self.frame)
self.outlineButton.text = "Toggle Outline"
self.frame.layout().addWidget(self.outlineButton)
self.outlineButton.connect('clicked()', self.toggleOutline)
self.wipeButton = qt.QPushButton(self.frame)
self.wipeButton.text = "Clear current segmentation label"
self.frame.layout().addWidget(self.wipeButton)
self.wipeButton.connect('clicked()', self.wipeSegmentation())
self.locRadFrame = qt.QFrame(self.frame)
self.locRadFrame.setLayout(qt.QHBoxLayout())
self.frame.layout().addWidget(self.locRadFrame)
self.widgets.append(self.locRadFrame)
# Nucleus segmentation parameters
nucleusSegCollapsibleButton = ctk.ctkCollapsibleButton()
nucleusSegCollapsibleButton.text = "Nucleus Segmentation Parameters"
nucleusSegCollapsibleButton.collapsed = False;
self.frame.layout().addWidget(nucleusSegCollapsibleButton)
# Nucleus declumping parameters
nucleusDeclumpingCollapsibleButton = ctk.ctkCollapsibleButton()
nucleusDeclumpingCollapsibleButton.text = "Nucleus Declumping Parameters"
nucleusDeclumpingCollapsibleButton.collapsed = False;
self.frame.layout().addWidget(nucleusDeclumpingCollapsibleButton)
self.structuresView = slicer.util.findChildren(slicer.modules.SlicerPathologyWidget.editorWidget.volumes, 'StructuresView')[0]
self.structuresView.connect("activated(QModelIndex)", self.onStructureClickedOrAdded)
# Layout within the seg parameter button
nucleusSegFormLayout = qt.QFormLayout(nucleusSegCollapsibleButton)
# Layout within the declumping parameter button
nucleusDeclumpingFormLayout = qt.QFormLayout(nucleusDeclumpingCollapsibleButton)
sr = vtk.vtkSliderRepresentation2D()
sr.SetHandleSize(10)
self.frameOtsuSlider = ctk.ctkSliderWidget()
self.frameOtsuSlider.connect('valueChanged(double)', self.OtsuSliderValueChanged)
self.frameOtsuSlider.decimals = 1
self.frameOtsuSlider.minimum = 0.5
self.frameOtsuSlider.maximum = 1.5
self.frameOtsuSlider.value = 1.0
self.frameOtsuSlider.singleStep = 0.1
self.frameOtsuSlider.setToolTip("Threshold gain for calling something in the image as nucleus. Run as default value 1.0. Then, if undersegment, increase this to 1.2 and re-run. If oversegment, decrease to 0.8 and re-run. Smaller value of this parameter will give fewer regions segmented as nucleus.")
nucleusSegFormLayout.addRow("Threshold Grain:", self.frameOtsuSlider)
self.frameCurvatureWeightSlider = ctk.ctkSliderWidget()
self.frameCurvatureWeightSlider.connect('valueChanged(double)', self.CurvatureWeightSliderValueChanged)
self.frameCurvatureWeightSlider.decimals = 1
self.frameCurvatureWeightSlider.minimum = 0
self.frameCurvatureWeightSlider.maximum = 10
self.frameCurvatureWeightSlider.value = 8
self.frameCurvatureWeightSlider.singleStep = 0.1
self.frameCurvatureWeightSlider.setToolTip("Large value will result in smoother boundary in the resulting segmentation.")
nucleusSegFormLayout.addRow("Expected Roundness/Smoothness:", self.frameCurvatureWeightSlider)
self.frameSizeThldSlider = ctk.ctkSliderWidget()
self.frameSizeThldSlider.connect('valueChanged(double)', self.SizeThldSliderValueChanged)
self.frameSizeThldSlider.decimals = 1
self.frameSizeThldSlider.minimum = 1
self.frameSizeThldSlider.maximum = 30
self.frameSizeThldSlider.value = 3
self.frameSizeThldSlider.singleStep = 0.1
self.frameSizeThldSlider.setToolTip("Any object smaller than this value will be discarded.")
nucleusSegFormLayout.addRow("Size Lower Threshold:", self.frameSizeThldSlider)
self.frameSizeUpperThldSlider = ctk.ctkSliderWidget()
self.frameSizeUpperThldSlider.connect('valueChanged(double)', self.SizeUpperThldSliderValueChanged)
self.frameSizeUpperThldSlider.decimals = 0
self.frameSizeUpperThldSlider.minimum = 1
self.frameSizeUpperThldSlider.maximum = 500
self.frameSizeUpperThldSlider.value = 50
self.frameSizeUpperThldSlider.setToolTip("Any object larger than this value will be de-clumped.")
nucleusDeclumpingFormLayout.addRow("Size Upper Threshold:", self.frameSizeUpperThldSlider)
self.frameKernelSizeSlider = ctk.ctkSliderWidget()
self.frameKernelSizeSlider.connect('valueChanged(double)', self.KernelSizeSliderValueChanged)
self.frameKernelSizeSlider.decimals = 0
self.frameKernelSizeSlider.minimum = 1
self.frameKernelSizeSlider.maximum = 30
self.frameKernelSizeSlider.value = 20
self.frameKernelSizeSlider.setToolTip("Lower this value will result in smaller object in the declumping.")
nucleusDeclumpingFormLayout.addRow("Kernel Size:", self.frameKernelSizeSlider)
self.frameMPPSlider = ctk.ctkSliderWidget()
self.frameMPPSlider.connect('valueChanged(double)', self.MPPSliderValueChanged)
self.frameMPPSlider.decimals = 5
self.frameMPPSlider.minimum = 0.01
self.frameMPPSlider.maximum = 1
self.frameMPPSlider.value = 0.25
self.frameMPPSlider.singleStep = 0.01
self.frameMPPSlider.setToolTip("For 40x, this is around 0.25. For 20x, this is around 0.5.")
nucleusDeclumpingFormLayout.addRow("Microns Per Pixel:", self.frameMPPSlider)
self.DefaultsButton = qt.QPushButton(self.frame)
self.DefaultsButton.text = "Default Parameter Values"
self.frame.layout().addWidget(self.DefaultsButton)
self.DefaultsButton.connect('clicked()', self.ResetToDefaults)
#nucleusSegFormLayout.addWidget(self.DefaultsButton)
HelpButton(self.frame, ("Otsu threshold:\n Threshold gain for calling something in the image as nucleus. Run as default value 1.0. Then, if undersegment, increase this to 1.2 and re-run. If oversegment, decrease to 0.8 and re-run. Smaller value of this parameter will give fewer regions segmented as nucleus.\n" +
"\nCurvature Weight:\n Large value will result in smoother boundary in the resulting segmentation.\n" +
"\nSize Threshold:\n Any object smaller than this value will be discarded.\n" +
"\nSize Upper Threshold:\n Any object larger than this value will be de-clumped.\n" +
"\nKernel size:\n Lower this value will result in smaller object in the declumping.\n" +
"\nMicrons Per Pixel:\n For 40x, this is around 0.25. For 20x, this is around 0.5.\n"))
self.frame.layout().addStretch(1) # Add vertical spacer
self.omode = 0
self.toggleOutline()
def add_widgets(self):
# axes
axes = vtk.vtkAxesActor()
self.marker_widget = vtk.vtkOrientationMarkerWidget()
self.marker_widget.SetInteractor(self.iren)
self.marker_widget.SetOrientationMarker(axes)
self.marker_widget.SetViewport(0.0, 0.0, 0.25, 0.25)
# scalar bar
self.scalarbar_actor = vtk.vtkScalarBarActor()
self.scalarbar_actor.SetLookupTable(self.lut)
self.scalarbar_widget = vtk.vtkScalarBarWidget()
self.scalarbar_widget.SetInteractor(self.iren)
self.scalarbar_widget.SetScalarBarActor(self.scalarbar_actor)
# contour slider
self.slider_rep = vtk.vtkSliderRepresentation2D()
self.slider_rep.SetTitleText("contour")
self.slider_rep.GetPoint1Coordinate().SetCoordinateSystemToNormalizedViewport()
self.slider_rep.GetPoint1Coordinate().SetValue(0.65, 0.1)
self.slider_rep.GetPoint2Coordinate().SetCoordinateSystemToNormalizedViewport()
self.slider_rep.GetPoint2Coordinate().SetValue(0.95, 0.1)
self.slider_widget = vtk.vtkSliderWidget()
self.slider_widget.SetInteractor(self.iren)
self.slider_widget.SetRepresentation(self.slider_rep)
self.slider_widget.SetAnimationModeToAnimate()
self.slider_widget.AddObserver(vtk.vtkCommand.InteractionEvent,
self.update_contour);
