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 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 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 _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);