Exemple #1
0
    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
Exemple #2
0
    def Execute(self):

        if self.Image == None:
            self.PrintError("Error: no Image.")

        if not self.vmtkRenderer:
            self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
            self.vmtkRenderer.Initialize()
            self.OwnRenderer = 1

        self.vmtkRenderer.RegisterScript(self)

        if self.Type == "freehand":
            self.ImageTracerWidget = vtk.vtkImageTracerWidget()
        elif self.Type == "contour":
            self.ImageTracerWidget = vtk.vtkContourWidget()
        self.ImageTracerWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)

        self.SliderWidget = vtk.vtkSliderWidget()
        self.SliderWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)

        self.ImageActor = vtk.vtkImageActor()

        self.vmtkRenderer.AddKeyBinding("n", "Next.", self.NextCallback)
        self.vmtkRenderer.AddKeyBinding("p", "Previous.", self.PreviousCallback)
        self.vmtkRenderer.AddKeyBinding("i", "Interact.", self.InteractCallback)

        self.Display()

        if self.OwnRenderer:
            self.vmtkRenderer.Deallocate()
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 Execute(self):

        if self.Image == None:
            self.PrintError('Error: no Image.')

        if not self.vmtkRenderer:
            self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
            self.vmtkRenderer.Initialize()
            self.OwnRenderer = 1

        if self.Type == 'freehand':
            self.ImageTracerWidget = vtk.vtkImageTracerWidget()
        elif self.Type == 'contour':
            self.ImageTracerWidget = vtk.vtkContourWidget()
        self.ImageTracerWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)

        self.SliderWidget = vtk.vtkSliderWidget()
        self.SliderWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)

        self.ImageActor = vtk.vtkImageActor()

        self.vmtkRenderer.RenderWindowInteractor.AddObserver("KeyPressEvent", self.Keypress)

        self.Display()

        if self.OwnRenderer:
            self.vmtkRenderer.Deallocate()
Exemple #5
0
    def Execute(self):

        if self.Image == None:
            self.PrintError('Error: no Image.')

        if not self.vmtkRenderer:
            self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
            self.vmtkRenderer.Initialize()
            self.OwnRenderer = 1

        self.vmtkRenderer.RegisterScript(self) 

        if self.Type == 'freehand':
            self.ImageTracerWidget = vtk.vtkImageTracerWidget()
        elif self.Type == 'contour':
            self.ImageTracerWidget = vtk.vtkContourWidget()
        self.ImageTracerWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)

        self.SliderWidget = vtk.vtkSliderWidget()
        self.SliderWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)

        self.ImageActor = vtk.vtkImageActor()

        self.vmtkRenderer.AddKeyBinding('n','Next.',self.NextCallback)
        self.vmtkRenderer.AddKeyBinding('p','Previous.',self.PreviousCallback)
        self.vmtkRenderer.AddKeyBinding('i','Interact.', self.InteractCallback)

        self.Display()

        if self.OwnRenderer:
            self.vmtkRenderer.Deallocate()
Exemple #6
0
    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
Exemple #7
0
    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 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 __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
		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()
Exemple #11
0
def interactive_viewer(streamlines, outlierness):
    import vtk
    from dipy.viz import fvtk, actor, window, widget
    from dipy.data.fetcher import read_viz_icons

    colormap_name = "jet"
    stream_actor = actor.line(streamlines, colors=fvtk.create_colormap(outlierness, name=colormap_name))
    stream_actor.SetPosition(-np.array(stream_actor.GetCenter()))

    global threshold
    threshold = 0.8

    streamlines_color = np.zeros(len(streamlines), dtype="float32")
    streamlines_color[outlierness < threshold] = 1
    streamlines_color[outlierness >= threshold] = 0

    lut = vtk.vtkLookupTable()
    lut.SetNumberOfTableValues(2)
    lut.Build()
    lut.SetTableValue(0, tuple(fvtk.colors.orange_red) + (1,))
    lut.SetTableValue(1, tuple(fvtk.colors.green) + (1,))
    lut.SetTableRange(0, 1)

    stream_split_actor = actor.line(streamlines, colors=streamlines_color, lookup_colormap=lut)
    stream_split_actor.SetPosition(-np.array(stream_split_actor.GetCenter()))
    hist_actor, hist_fig = create_hist_actor(outlierness, colormap_name=colormap_name)

    # Main renderder
    bg = (0, 0, 0)
    global screen_size
    screen_size = (0, 0)
    ren_main = window.Renderer()
    ren_main.background(bg)
    show_m = window.ShowManager(ren_main, size=(1066, 600), interactor_style="trackball")
    show_m.window.SetNumberOfLayers(2)
    ren_main.SetLayer(1)
    ren_main.InteractiveOff()

    # Outlierness renderer
    ren_outlierness = window.Renderer()
    show_m.window.AddRenderer(ren_outlierness)
    ren_outlierness.background(bg)
    ren_outlierness.SetViewport(0, 0.3, 0.5, 1)
    ren_outlierness.add(stream_actor)
    ren_outlierness.reset_camera_tight()

    ren_split = window.Renderer()
    show_m.window.AddRenderer(ren_split)
    ren_split.background(bg)
    ren_split.SetViewport(0.5, 0.3, 1, 1)
    ren_split.add(stream_split_actor)
    ren_split.SetActiveCamera(ren_outlierness.GetActiveCamera())

    # Histogram renderer
    ren_hist = window.Renderer()
    show_m.window.AddRenderer(ren_hist)
    ren_hist.projection("parallel")
    ren_hist.background(bg)
    ren_hist.SetViewport(0, 0, 1, 0.3)
    ren_hist.add(hist_actor)
    ren_hist.SetInteractive(False)

    def apply_threshold(obj, evt):
        global threshold
        new_threshold = np.round(obj.GetSliderRepresentation().GetValue(), decimals=2)
        obj.GetSliderRepresentation().SetValue(new_threshold)
        if threshold != new_threshold:
            threshold = new_threshold

            streamlines_color = np.zeros(len(streamlines), dtype=np.float32)
            streamlines_color[outlierness < threshold] = 1
            streamlines_color[outlierness >= threshold] = 0

            colors = []
            for color, streamline in zip(streamlines_color, streamlines):
                colors += [color] * len(streamline)

            scalars = stream_split_actor.GetMapper().GetInput().GetPointData().GetScalars()
            for i, c in enumerate(colors):
                scalars.SetValue(i, c)

            scalars.Modified()

    threshold_slider_rep = vtk.vtkSliderRepresentation3D()
    threshold_slider_rep.SetMinimumValue(0.)
    threshold_slider_rep.SetMaximumValue(1.)
    threshold_slider_rep.SetValue(threshold)
    threshold_slider_rep.SetLabelFormat("%0.2lf")
    threshold_slider_rep.SetLabelHeight(0.02)
    threshold_slider_rep.GetPoint1Coordinate().SetCoordinateSystemToWorld()
    x1, x2, y1, y2, z1, z2 = hist_actor.GetBounds()
    threshold_slider_rep.GetPoint1Coordinate().SetValue(x1*1., y1-5, 0)
    threshold_slider_rep.GetPoint2Coordinate().SetCoordinateSystemToWorld()
    threshold_slider_rep.GetPoint2Coordinate().SetValue(x2*1., y1-5, 0)
    threshold_slider_rep.SetEndCapLength(0.)
    threshold_slider_rep.SetEndCapWidth(0.)

    threshold_slider = vtk.vtkSliderWidget()
    threshold_slider.SetInteractor(show_m.iren)
    threshold_slider.SetRepresentation(threshold_slider_rep)
    threshold_slider.SetCurrentRenderer(ren_hist)
    threshold_slider.SetAnimationModeToJump()
    threshold_slider.EnabledOn()

    threshold_slider.AddObserver("InteractionEvent", apply_threshold)

    #ren_main
    def _place_buttons():
        sz = 30.0
        width, _ = ren_main.GetSize()

        # bds = np.zeros(6)
        # bds[0] = width - sz - 5
        # bds[1] = bds[0] + sz
        # bds[2] = 5
        # bds[3] = bds[2] + sz
        # bds[4] = bds[5] = 0.0
        # save_button.GetRepresentation().PlaceWidget(bds)

    def _window_callback(obj, event):
        ren_hist.reset_camera_tight(margin_factor=1.2)
        _place_buttons()

    show_m.add_window_callback(_window_callback)
    show_m.initialize()
    show_m.render()
    show_m.start()

    inliers = [s for s, keep in zip(streamlines, outlierness < threshold) if keep]
    outliers = [s for s, keep in zip(streamlines, outlierness >= threshold) if keep]
    return inliers, outliers
Exemple #12
0
SliderRepres = vtk.vtkSliderRepresentation2D()
min = 0 #ImageViewer.GetSliceMin()
max = 100 #ImageViewer.GetSliceMax()
SliderRepres.SetMinimumValue(min)
SliderRepres.SetMaximumValue(max)
SliderRepres.SetValue(min)
SliderRepres.SetTitleText("scale factor")
SliderRepres.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderRepres.GetPoint1Coordinate().SetValue(0.1, 0.1)
SliderRepres.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderRepres.GetPoint2Coordinate().SetValue(0.4, 0.1)
SliderRepres.SetSliderLength(0.02)
SliderRepres.SetSliderWidth(0.03)
SliderRepres.SetEndCapLength(0.01)
SliderRepres.SetEndCapWidth(0.03)
SliderRepres.SetTubeWidth(0.005)
SliderRepres.SetLabelFormat("%3.0lf / 1000")
SliderRepres.SetTitleHeight(0.02)
SliderRepres.SetLabelHeight(0.02)
SliderWidget = vtk.vtkSliderWidget()
SliderWidget.SetInteractor(iren)
SliderWidget.SetRepresentation(SliderRepres)
SliderWidget.KeyPressActivationOff()
SliderWidget.SetAnimationModeToAnimate()
SliderWidget.SetEnabled(True)
SliderWidget.AddObserver("InteractionEvent", vtkSliderCallback)

iren.Initialize()
renWin.Render()
iren.Start()
  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]
Exemple #14
0
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)
SliderRepres.SetLabelHeight(0.02)
SliderRepres.GetSelectedProperty().SetColor(0,1,0)


SliderWidget = vtk.vtkSliderWidget()
SliderWidget.SetInteractor(iren)
SliderWidget.SetRepresentation(SliderRepres)
SliderWidget.KeyPressActivationOff()
SliderWidget.SetAnimationModeToAnimate()
SliderWidget.SetEnabled(True)
SliderWidget.AddObserver("EndInteractionEvent", vtkSliderCallback2)

# Execute the Pipeline
renWin.Render() 

# initialize and start the interactor 
iren.Initialize() 
iren.Start() 

Exemple #15
0
def Main():
    global continuousSize, continuousType, continuousData, contours, planeSource1s, planeSource2s, planeSource3s, plane1s, plane2s, plane3s, clipper1s, clipper2s, clipper3s, clipX, clipY, clipZ, lut

    print "data: %s" % sys.argv[1]
    reader = vtk.vtkStructuredPointsReader()
    reader.SetFileName(sys.argv[1])
    reader.Update()

    print "gradientmag: %s" % sys.argv[2]
    gmreader = vtk.vtkStructuredPointsReader()
    gmreader.SetFileName(sys.argv[2])
    gmreader.Update()

    continuousSize = 0
    continuousType = "HSV"
    continuousData = []

    print "params: %s" % sys.argv[3]
    loadParamsFile(sys.argv[3])

    clipX = 0
    clipY = 0
    clipZ = 0

    r = reader.GetOutput().GetScalarRange()
    datamin = r[0]
    datamax = r[1]

    for i in range(4, len(sys.argv)):
        if sys.argv[i] == "--clip":
            print "clip (%s,%s,%s)" % (sys.argv[i + 1], sys.argv[i + 2],
                                       sys.argv[i + 3])
            clipX = float(sys.argv[i + 1])
            clipY = float(sys.argv[i + 2])
            clipZ = float(sys.argv[i + 3])

    clipperActors = []
    planeSource1s = []
    planeSource2s = []
    planeSource3s = []
    plane1s = []
    plane2s = []
    plane3s = []
    clipper1s = []
    clipper2s = []
    clipper3s = []

    for i in range(0, len(continuousData)):
        contours = vtk.vtkContourFilter()
        contours.SetInputConnection(reader.GetOutputPort())
        contours.ComputeNormalsOn()
        contours.SetValue(0, float(continuousData[i][0]))

        planeSource1s.append(vtk.vtkPlaneSource())
        planeSource1s[i].SetNormal(1, 0, 0)
        planeSource1s[i].SetOrigin(clipX, 0, 0)
        plane1s.append(vtk.vtkPlane())
        plane1s[i].SetNormal(planeSource1s[i].GetNormal())
        plane1s[i].SetOrigin(planeSource1s[i].GetOrigin())
        clipper1s.append(vtk.vtkClipPolyData())
        clipper1s[i].SetClipFunction(plane1s[i])
        clipper1s[i].SetInputConnection(contours.GetOutputPort())
        clipper1s[i].Update()

        planeSource2s.append(vtk.vtkPlaneSource())
        planeSource2s[i].SetNormal(0, 1, 0)
        planeSource2s[i].SetOrigin(0, clipY, 0)
        plane2s.append(vtk.vtkPlane())
        plane2s[i].SetNormal(planeSource2s[i].GetNormal())
        plane2s[i].SetOrigin(planeSource2s[i].GetOrigin())
        clipper2s.append(vtk.vtkClipPolyData())
        clipper2s[i].SetClipFunction(plane2s[i])
        clipper2s[i].SetInputConnection(clipper1s[i].GetOutputPort())
        clipper2s[i].Update()

        planeSource3s.append(vtk.vtkPlaneSource())
        planeSource3s[i].SetNormal(0, 0, 1)
        planeSource3s[i].SetOrigin(0, 0, clipZ)
        plane3s.append(vtk.vtkPlane())
        plane3s[i].SetNormal(planeSource3s[i].GetNormal())
        plane3s[i].SetOrigin(planeSource3s[i].GetOrigin())
        clipper3s.append(vtk.vtkClipPolyData())
        clipper3s[i].SetClipFunction(plane3s[i])
        clipper3s[i].SetInputConnection(clipper2s[i].GetOutputPort())
        clipper3s[i].Update()

        probeFilter = vtk.vtkProbeFilter()
        probeFilter.SetInputConnection(0, clipper3s[i].GetOutputPort())
        probeFilter.SetInputConnection(1, gmreader.GetOutputPort())
        probeFilter.Update()

        gmrange = probeFilter.GetOutput().GetScalarRange()
        gmin = gmrange[0]
        gmax = gmrange[1]

        gmclipper1 = vtk.vtkClipPolyData()
        gmclipper1.SetInputConnection(probeFilter.GetOutputPort())
        gmclipper1.InsideOutOff()
        gmclipper1.SetValue(int(continuousData[i][1]))
        gmclipper1.Update()

        gmclipper2 = vtk.vtkClipPolyData()
        gmclipper2.SetInputConnection(gmclipper1.GetOutputPort())
        gmclipper2.InsideOutOn()
        gmclipper2.SetValue(int(continuousData[i][2]))
        gmclipper2.Update()

        lut = vtk.vtkColorTransferFunction()
        if continuousType == "HSV":
            lut.SetColorSpaceToHSV()
            p = continuousData[i]
            print "Color: %s" % p
            lut.AddHSVPoint(p[0], p[3], p[4], p[5])
        elif continuousType == "RGB":
            lut.SetColorSpaceToRGB()
            p = continuousData[i]
            print "Color: %s" % p
            lut.AddRGBPoint(p[0], p[3], p[4], p[5])

        clipperMapper = vtk.vtkPolyDataMapper()
        clipperMapper.SetLookupTable(lut)
        clipperMapper.SetInputConnection(gmclipper2.GetOutputPort())

        clipperActors.append(vtk.vtkActor())
        clipperActors[i].GetProperty().SetRepresentationToWireframe()
        clipperActors[i].SetMapper(clipperMapper)

        backFaces = vtk.vtkProperty()
        backFaces.SetSpecular(0)
        backFaces.SetDiffuse(0)
        backFaces.SetAmbient(0)
        backFaces.SetAmbientColor(1, 0, 0)
        clipperActors[i].SetBackfaceProperty(backFaces)

    lut_color = vtk.vtkColorTransferFunction()
    for d in continuousData:
        if continuousType == "HSV":
            lut_color.SetColorSpaceToHSV()
            lut_color.AddHSVPoint(d[0], d[3], d[4], d[5])
        elif continuousType == "RGB":
            lut_color.SetColorSpaceToRGB()
            lut_color.AddRGBPoint(d[0], d[3], d[4], d[5])

    colorMapper = vtk.vtkPolyDataMapper()
    colorMapper.SetLookupTable(lut_color)

    colorBar = vtkScalarBarActor()
    colorBar.SetLookupTable(colorMapper.GetLookupTable())
    colorBar.SetTitle("isovalue")
    colorBar.SetNumberOfLabels(6)
    colorBar.SetLabelFormat("%4.0f")
    colorBar.SetPosition(0.9, 0.1)
    colorBar.SetWidth(0.1)
    colorBar.SetHeight(0.7)

    ren = vtk.vtkRenderer()
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren)
    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)

    for i in range(0, len(clipperActors)):
        clipperActors[i].GetProperty().SetOpacity(
            continuousData[i][6])  # load opacity for actor
        ren.AddActor(clipperActors[i])
    ren.AddActor(colorBar)

    # for depth peeling
    ren.SetUseDepthPeeling(1)
    ren.SetMaximumNumberOfPeels(2)  # default 4
    ren.SetOcclusionRatio(0.1)  # default 0

    ren.ResetCamera()
    ren.SetBackground(0.2, 0.3, 0.4)
    ren.ResetCameraClippingRange()

    # for depth peeling
    renWin.SetAlphaBitPlanes(1)
    renWin.SetMultiSamples(0)

    renWin.SetSize(1200, 600)

    clipXSlider = vtk.vtkSliderRepresentation2D()
    clipXSlider.SetMinimumValue(0)
    clipXSlider.SetMaximumValue(300)
    clipXSlider.SetValue(clipX)
    clipXSlider.SetTitleText("X")
    clipXSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
    clipXSlider.GetPoint1Coordinate().SetValue(0.0, 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("InteractionEvent", clipXSliderHandler)

    clipYSlider = vtk.vtkSliderRepresentation2D()
    clipYSlider.SetMinimumValue(0)
    clipYSlider.SetMaximumValue(300)
    clipYSlider.SetValue(clipY)
    clipYSlider.SetTitleText("Y")
    clipYSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
    clipYSlider.GetPoint1Coordinate().SetValue(0.0, 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("InteractionEvent", clipYSliderHandler)

    clipZSlider = vtk.vtkSliderRepresentation2D()
    clipZSlider.SetMinimumValue(0)
    clipZSlider.SetMaximumValue(300)
    clipZSlider.SetValue(clipZ)
    clipZSlider.SetTitleText("Z")
    clipZSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
    clipZSlider.GetPoint1Coordinate().SetValue(0.0, 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("InteractionEvent", clipZSliderHandler)

    # Render
    iren.Initialize()
    renWin.Render()
    iren.Start()
Exemple #16
0
	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()
Exemple #17
0
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()
Exemple #18
0
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()
Exemple #19
-1
    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);