Exemplo n.º 1
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

        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()
Exemplo n.º 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

        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()
Exemplo n.º 3
0
def main():
    img_reader = ImageReaderFactory().GenerateImageReader(
        "./data/0000000000.png")

    img_actor = ImageActor(img_reader.GetOutputPort())

    contour_widget = vtk.vtkContourWidget()

    contourRepresentation = vtk.vtkOrientedGlyphContourRepresentation()
    contourRepresentation.GetLinesProperty().SetColor(1, 1, 0)

    contour_widget.SetRepresentation(contourRepresentation)
    contour_widget.GetContourRepresentation().SetLineInterpolator(
        vtk.vtkLinearContourLineInterpolator())

    numPts = 10

    points = vtk.vtkPoints()

    for i in range(numPts):
        angle = 2.0 * vtk.vtkMath.Pi() * i / numPts
        points.InsertNextPoint(
            [0.1 * math.cos(angle), 0.1 * math.sin(angle), -1.0])

    vertexIndices = vtk.vtkIdList()
    for i in range(numPts):
        vertexIndices.InsertNextId(i)
    # vertexIndices.InsertNextId(0)

    lines = vtk.vtkCellArray()
    lines.InsertNextCell(vertexIndices)

    polydata = vtk.vtkPolyData()
    polydata.SetPoints(points)
    polydata.SetLines(lines)

    mapper = vtk.vtkPolyDataMapper2D()
    mapper.SetInputData(polydata)
    actor = vtk.vtkActor2D()
    actor.SetMapper(mapper)

    renderer = vtk.vtkRenderer()
    renderer.SetBackground(0.1, 0.2, 0.4)
    renderer.AddActor(img_actor.actor)
    renderer.AddActor(actor)

    renderWindow = vtk.vtkRenderWindow()
    renderWindow.AddRenderer(renderer)

    interactor = vtk.vtkRenderWindowInteractor()
    interactor.SetRenderWindow(renderWindow)

    style = vtk.vtkInteractorStyleJoystickCamera()
    interactor.SetInteractorStyle(style)

    contour_widget.SetInteractor(interactor)
    contour_widget.On()
    contour_widget.Initialize(polydata)
    renderer.ResetCamera()
    interactor.Start()
Exemplo n.º 4
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()
Exemplo n.º 5
0
    def select_points(self):
        self._is_extract = not self._is_extract
        if self._is_extract:

            self.setCursor(QCursor(Qt.CrossCursor))

            self._contour_widget = vtkContourWidget()
            self._contour_widget.SetInteractor(self.vtkWidget.get_interactor())
            self._contour_representation = vtkOrientedGlyphContourRepresentation()

            self._contour_widget.SetRepresentation(self._contour_representation)
            self._contour_representation.GetLinesProperty().SetColor(1,1,0)
            self._contour_representation.GetLinesProperty().SetLineWidth(2.0)
            self._contour_representation.GetLinesProperty().SetPointSize(10.0)
            self._contour_representation.SetAlwaysOnTop(1)
            self._contour_widget.EnabledOn()

        else:
            self.vtkWidget.get_interactor().GetRenderWindow().SetCurrentCursor(0)
            self._contour_widget.CloseLoop()
            self._contour_widget.ProcessEventsOff()
            self.vtkWidget.get_interactor().GetRenderWindow().Render()

        self.extract_action.setEnabled(True)
        self.clean_action.setEnabled(True)
Exemplo n.º 6
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()
Exemplo n.º 7
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()
Exemplo n.º 8
0
    def Execute(self):

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

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

        self.vmtkRenderer.RegisterScript(self)

        triangleFilter = vtk.vtkTriangleFilter()
        triangleFilter.SetInputData(self.Surface)
        triangleFilter.Update()

        self.Surface = triangleFilter.GetOutput()

        contourScalars = vtk.vtkDoubleArray()
        contourScalars.SetNumberOfComponents(1)
        contourScalars.SetNumberOfTuples(self.Surface.GetNumberOfPoints())
        contourScalars.SetName(self.ContourScalarsArrayName)
        contourScalars.FillComponent(0,self.OutsideValue)

        self.Surface.GetPointData().AddArray(contourScalars)
        self.Surface.GetPointData().SetActiveScalars(self.ContourScalarsArrayName)

        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputData(self.Surface)
        mapper.ScalarVisibilityOn()
        self.Actor = vtk.vtkActor()
        self.Actor.SetMapper(mapper)
        self.Actor.GetMapper().SetScalarRange(-1.0,0.0)
        self.vmtkRenderer.Renderer.AddActor(self.Actor)

        self.ContourWidget = vtk.vtkContourWidget()
        self.ContourWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)

        rep = vtk.vtkOrientedGlyphContourRepresentation.SafeDownCast(self.ContourWidget.GetRepresentation())
        rep.GetLinesProperty().SetColor(1, 0.2, 0)
        rep.GetLinesProperty().SetLineWidth(3.0)

        pointPlacer = vtk.vtkPolygonalSurfacePointPlacer()
        pointPlacer.AddProp(self.Actor)
        pointPlacer.GetPolys().AddItem(self.Surface)
        rep.SetPointPlacer(pointPlacer)

        self.Interpolator = vtk.vtkPolygonalSurfaceContourLineInterpolator()
        self.Interpolator.GetPolys().AddItem(self.Surface)
        rep.SetLineInterpolator(self.Interpolator)

        self.vmtkRenderer.AddKeyBinding('space','Generate scalars',self.ScalarsCallback)
        self.vmtkRenderer.AddKeyBinding('d','Delete contour',self.DeleteContourCallback)
        self.vmtkRenderer.AddKeyBinding('i','Start interaction',self.InteractCallback)
        self.Display()

        if self.OwnRenderer:
            self.vmtkRenderer.Deallocate()
Exemplo n.º 9
0
    def Execute(self):

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

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

        self.vmtkRenderer.RegisterScript(self) 

        triangleFilter = vtk.vtkTriangleFilter()
        triangleFilter.SetInputData(self.Surface)
        triangleFilter.Update()

        self.Surface = triangleFilter.GetOutput()

        contourScalars = vtk.vtkDoubleArray()
        contourScalars.SetNumberOfComponents(1)
        contourScalars.SetNumberOfTuples(self.Surface.GetNumberOfPoints())
        contourScalars.SetName(self.ContourScalarsArrayName)
        contourScalars.FillComponent(0,self.OutsideValue)

        self.Surface.GetPointData().AddArray(contourScalars)
        self.Surface.GetPointData().SetActiveScalars(self.ContourScalarsArrayName)

        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputData(self.Surface)
        mapper.ScalarVisibilityOn()
        self.Actor = vtk.vtkActor()
        self.Actor.SetMapper(mapper)
        self.Actor.GetMapper().SetScalarRange(-1.0,0.0)
        self.vmtkRenderer.Renderer.AddActor(self.Actor)

        self.ContourWidget = vtk.vtkContourWidget()
        self.ContourWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)

        rep = vtk.vtkOrientedGlyphContourRepresentation.SafeDownCast(self.ContourWidget.GetRepresentation())
        rep.GetLinesProperty().SetColor(1, 0.2, 0)
        rep.GetLinesProperty().SetLineWidth(3.0)

        pointPlacer = vtk.vtkPolygonalSurfacePointPlacer()
        pointPlacer.AddProp(self.Actor)
        pointPlacer.GetPolys().AddItem(self.Surface)
        rep.SetPointPlacer(pointPlacer)

        self.Interpolator = vtk.vtkPolygonalSurfaceContourLineInterpolator()
        self.Interpolator.GetPolys().AddItem(self.Surface)
        rep.SetLineInterpolator(self.Interpolator)

        self.vmtkRenderer.AddKeyBinding('space','Generate scalars',self.ScalarsCallback)
        self.vmtkRenderer.AddKeyBinding('d','Delete contour',self.DeleteContourCallback)
        self.vmtkRenderer.AddKeyBinding('i','Start interaction',self.InteractCallback)
        self.Display()

        if self.OwnRenderer:
            self.vmtkRenderer.Deallocate()
Exemplo n.º 10
0
 def __init__(self, scenes, ilsa, onCloseAction):
     logging.debug("In CPRContour::__init__()")
     self._onCloseAction = onCloseAction
     self._panoramicPlane = None
     self._transversalPlane = None
     
     self._scene = None
     self.contourRep = vtk.vtkOrientedGlyphContourRepresentation()
     self.contourRep.GetLinesProperty().SetColor(1,1,1)
     self.contourRep.SetLineInterpolator(vtk.vtkLinearContourLineInterpolator())
     self.visible = True
     
     self.actualContourRep = vtk.vtkOrientedGlyphContourRepresentation()
     self.actualContourRep.GetLinesProperty().SetColor(0,1,0)
     self.actualContourRep.SetLineInterpolator(vtk.vtkLinearContourLineInterpolator())
     
     self.actualContourWidget = vtk.vtkContourWidget()
     self.actualContourWidget.SetRepresentation(self.actualContourRep)
     
     self.transversalContourRep = vtk.vtkOrientedGlyphContourRepresentation()
     self.transversalContourRep.GetLinesProperty().SetColor(0,1,0)
     self.transversalContourRep.SetLineInterpolator(vtk.vtkLinearContourLineInterpolator())
     
     self.transversalContourWidget = vtk.vtkContourWidget()
     self.transversalContourWidget.SetRepresentation(self.transversalContourRep)
     
     self.replyList = []
     self.numberOfNodes = 0
     self.contourWidget = vtk.vtkContourWidget()
     self._started = False
     self._closed = False
     self.sceneEvents = {}
     self._ilsa = ilsa
     axialScenes = []
     for scene in scenes:
         if isinstance(scene, VtkImagePlane):
             if scene.planeOrientation == scene.PLANE_ORIENTATION_AXIAL:
                 axialScenes.append(scene)
     self.scenes = axialScenes
     self.addEvents()
     self.pointColor = (0, 1, 0)
     self.lineColor = (1, 1, 1)
     self.actualLineColor = (0, 1, 0)
     self.transversalSize = 30.0
     self.lastNormal = None
Exemplo n.º 11
0
 def enable(self, parent, key = 'result', color = ((1, 0, 0), (0, 1, 0), (0, 0, 1)), dash = False, show = True):
     self.parent = parent
     self.datakey = key
     self.contourRep = []
     self.contourWidget = []
     # The flag of showing the contour
     self.contour = [True, True, True]
     # Avoid putting point when modifying the window level
     self.leftMove = True
     self.leftClicked = False
     
     self.currentContour = 0
     self.contourInfo = ['1 (CCA)', '2 (ECA)', '3 (ICA)']
     
     for i in range(3):
         self.contourRep.append(vtk.vtkOrientedGlyphContourRepresentation())
         self.contourWidget.append(vtk.vtkContourWidget())
         self.contourWidget[i].SetInteractor(self.parent.window_interactor)
         self.contourWidget[i].SetRepresentation(self.contourRep[i])
         
     self.contourRep[0].GetLinesProperty().SetColor(color[0])
     self.contourRep[1].GetLinesProperty().SetColor(color[1])
     self.contourRep[2].GetLinesProperty().SetColor(color[2])
     self.contourRep[0].GetProperty().SetColor(color[0])
     self.contourRep[1].GetProperty().SetColor(color[1])
     self.contourRep[2].GetProperty().SetColor(color[2])
     if self.editable or self.key == 'Centerline':
         self.contourRep[0].GetProperty().SetOpacity(1)
         self.contourRep[1].GetProperty().SetOpacity(1)
         self.contourRep[2].GetProperty().SetOpacity(1)
     else:
         self.contourRep[0].GetProperty().SetOpacity(0)
         self.contourRep[1].GetProperty().SetOpacity(0)
         self.contourRep[2].GetProperty().SetOpacity(0)
     self.contourRep[0].GetActiveProperty().SetColor(1, 1, 1)
     self.contourRep[1].GetActiveProperty().SetColor(1, 1, 1)
     self.contourRep[2].GetActiveProperty().SetColor(1, 1, 1)
     if dash:
         for contourRep in self.contourRep:
             contourRep.GetLinesProperty().SetLineStipplePattern(0xf0f0)
     
     for i in range(3):
         eventTranslator = self.contourWidget[i].GetEventTranslator()
         eventTranslator.RemoveTranslation("RightButtonPressEvent")
         eventTranslator.RemoveTranslation("KeyPressEvent")
         eventTranslator.SetTranslation(vtk.vtkCommand.KeyPressEvent, 0, "", 0, "Delete", vtk.vtkWidgetEvent.Delete)
         
         self.contourWidget[i].ProcessEventsOff()
         self.contourWidget[i].SetWidgetState(1)
         self.contourWidget[i].SetEnabled(1)
         self.contourWidget[i].On()
         
     status = self.parent.getDirectionAndSlice()
     
     self.show = show
     self.updateAfter(self.parent.view, int(status[1]))
Exemplo n.º 12
0
    def Execute(self):
        from vmtk import vmtkscripts
        if self.Surface == None:
            self.PrintError('Error: no Surface.')

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

        self.vmtkRenderer.RegisterScript(self)

        triangleFilter = vtk.vtkTriangleFilter()
        triangleFilter.SetInputData(self.Surface)
        triangleFilter.Update()

        self.Surface = triangleFilter.GetOutput()

        self.tagviewer = vmtkscripts.vmtkSurfaceViewer()
        self.tagviewer.Surface = self.Surface
        self.tagviewer.vmtkRenderer = self.vmtkRenderer
        self.tagviewer.Representation = 'edges'
        self.tagviewer.Opacity = self.Opacity
        self.tagviewer.Execute()

        self.ContourWidget = vtk.vtkContourWidget()
        self.ContourWidget.SetInteractor(
            self.vmtkRenderer.RenderWindowInteractor)

        rep = vtk.vtkOrientedGlyphContourRepresentation.SafeDownCast(
            self.ContourWidget.GetRepresentation())
        rep.GetLinesProperty().SetColor(1, 0, 0)
        rep.GetLinesProperty().SetLineWidth(4.0)

        pointPlacer = vtk.vtkPolygonalSurfacePointPlacer()
        pointPlacer.AddProp(self.tagviewer.Actor)
        pointPlacer.GetPolys().AddItem(self.Surface)
        rep.SetPointPlacer(pointPlacer)

        self.Interpolator = vtk.vtkPolygonalSurfaceContourLineInterpolator()
        self.Interpolator.GetPolys().AddItem(self.Surface)
        rep.SetLineInterpolator(self.Interpolator)

        self.InputInfo("Building loop ...\n")

        self.vmtkRenderer.AddKeyBinding('space', 'Generate loop',
                                        self.LoopCallback)
        self.vmtkRenderer.AddKeyBinding('d', 'Delete contour',
                                        self.DeleteContourCallback)
        self.vmtkRenderer.AddKeyBinding('i', 'Start/stop contour drawing',
                                        self.InteractCallback)

        self.Display()

        if self.OwnRenderer:
            self.vmtkRenderer.Deallocate()
Exemplo n.º 13
0
    def Execute(self):
        from vmtk import vmtkscripts
        if self.Surface == None:
            self.PrintError('Error: no Surface.')

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

        self.vmtkRenderer.RegisterScript(self) 

        triangleFilter = vtk.vtkTriangleFilter()
        triangleFilter.SetInputData(self.Surface)
        triangleFilter.Update()

        self.Surface = triangleFilter.GetOutput()

        self.tagviewer = vmtkscripts.vmtkSurfaceViewer()
        self.tagviewer.Surface = self.Surface
        self.tagviewer.vmtkRenderer = self.vmtkRenderer
        self.tagviewer.Representation = 'edges'
        self.tagviewer.Opacity = self.Opacity
        self.tagviewer.Execute()

        self.ContourWidget = vtk.vtkContourWidget()
        self.ContourWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)

        rep = vtk.vtkOrientedGlyphContourRepresentation.SafeDownCast(self.ContourWidget.GetRepresentation())
        rep.GetLinesProperty().SetColor(1, 0, 0)
        rep.GetLinesProperty().SetLineWidth(4.0)

        pointPlacer = vtk.vtkPolygonalSurfacePointPlacer()
        pointPlacer.AddProp(self.tagviewer.Actor)
        pointPlacer.GetPolys().AddItem(self.Surface)
        rep.SetPointPlacer(pointPlacer)

        self.Interpolator = vtk.vtkPolygonalSurfaceContourLineInterpolator()
        self.Interpolator.GetPolys().AddItem(self.Surface)
        rep.SetLineInterpolator(self.Interpolator)

        self.InputInfo("Building loop ...\n")

        self.vmtkRenderer.AddKeyBinding('space','Generate loop',self.LoopCallback)
        self.vmtkRenderer.AddKeyBinding('d','Delete contour',self.DeleteContourCallback)
        self.vmtkRenderer.AddKeyBinding('i','Start/stop contour drawing',self.InteractCallback)


        self.Display()


        if self.OwnRenderer:
            self.vmtkRenderer.Deallocate()
Exemplo n.º 14
0
    def _init_cw(self):
        self._cw = vtk.vtkContourWidget()

        rep = vtk.vtkOrientedGlyphContourRepresentation()
        self._cw.SetRepresentation(rep)

        iapp = vtk.vtkImageActorPointPlacer()
        iapp.SetImageActor(self._image_viewer.GetImageActor())
        rep.SetPointPlacer(iapp)

        self._cw.SetInteractor(self._view_frame.rwi)
        self._cw.On()
Exemplo n.º 15
0
    def _init_cw(self):
        self._cw = vtk.vtkContourWidget()

        rep = vtk.vtkOrientedGlyphContourRepresentation()
        self._cw.SetRepresentation(rep)

        iapp = vtk.vtkImageActorPointPlacer()
        iapp.SetImageActor(self._image_viewer.GetImageActor())
        rep.SetPointPlacer(iapp)

        self._cw.SetInteractor(self._view_frame.rwi)
        self._cw.On()
Exemplo n.º 16
0
 def scene(self, scene):
     self._scene = scene
     self._scene.incrementReferenceCount()
     self._scene.getPlane().mscreenParent.incrementReferenceCount()
     for sceneKey, events in self.sceneEvents.items():
         if sceneKey != scene:
             sceneKey.removeObserver(events[0])
             sceneKey.removeObserver(events[1])
     self.sceneEvents = {scene:self.sceneEvents[scene]}
     self.contourWidget = vtk.vtkContourWidget()
     self.contourWidget.SetRepresentation(self.contourRep)
     self.contourWidget.AddObserver("InteractionEvent", self.onInteractAction)
     self.contourWidget.AddObserver("EndInteractionEvent", self.endIteractAction)
     
     self.contourWidget.SetInteractor(self._scene.interactor)
     self.actualContourWidget.SetInteractor(self._scene.interactor)
     self.transversalContourWidget.SetInteractor(self._scene.interactor)
     self.contourWidget.On()
Exemplo n.º 17
0
def main():
    global mapper

    renderer, window, interactor = make_rwi()

    cd = make_contour_data(20, 1.0)
    #write_poly("before.vtp", cd)

    contourRep = vtk.vtkOrientedGlyphContourRepresentation()
    contourRep.GetLinesProperty().SetColor(1, 0, 0) # set color to red
    contourRep.GetProperty().SetColor(0,1,0)
    contourRep.GetActiveProperty().SetColor(0,0,0)
 
    contourWidget = vtk.vtkContourWidget()
    contourWidget.SetInteractor(interactor)
    contourWidget.SetRepresentation(contourRep)
    contourWidget.On()

    contourWidget.Initialize(cd, 1)
    contourWidget.CloseLoop()
    cd = contourWidget.GetRepresentation().GetContourRepresentationAsPolyData()
    #write_poly("after.vtp", cd)
    
    contourWidget.AddObserver('InteractionEvent', my_callback)
    contourWidget.Render()
    
    mapper = vtk.vtkDataSetMapper()
    td = gen_triangles(cd)
    mapper.SetInputConnection(td.GetOutputPort())

    actor = vtk.vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().SetColor(0,1,0)
    actor.GetProperty().SetOpacity(0.2)  #actor.GetProperty().SetRepresentationToWireframe()

    renderer.AddActor(actor)

    render_things(renderer, window, interactor)
Exemplo n.º 18
0
    def _InitializeWidget(self):
        contourWidget = vtk.vtkContourWidget()
        contourWidget.SetInteractor(self.RenderWindowInteractor)
        contourWidget.FollowCursorOn()

        eventTranslator = contourWidget.GetEventTranslator()
        # Right Button Press controls both camera dolly and contour loop closing,
        # which can lead to premature interaction end
        eventTranslator.RemoveTranslation(vtk.vtkCommand.RightButtonPressEvent)
        set_event_translator_key_press_event(eventTranslator,
                                             vtk.vtkWidgetEvent.AddFinalPoint,
                                             'c')
        set_event_translator_key_press_event(eventTranslator,
                                             vtk.vtkWidgetEvent.Delete, 'd')
        set_event_translator_key_press_event(eventTranslator,
                                             vtk.vtkWidgetEvent.Reset, 'r')

        rep = contourWidget.GetRepresentation()
        repProperty = rep.GetLinesProperty()
        repProperty.SetColor(1, 0, 0)
        repProperty.SetLineWidth(4.0)

        pointPlacer = vtk.vtkPolygonalSurfacePointPlacer()
        pointPlacer.AddProp(self.Actor)
        pointPlacer.GetPolys().AddItem(self.InputData)

        interpolator = vtk.vtkPolygonalSurfaceContourLineInterpolator()
        interpolator.GetPolys().AddItem(self.InputData)

        rep.SetPointPlacer(pointPlacer)
        rep.SetLineInterpolator(interpolator)

        self.ContourWidget = contourWidget
        self.PointPlacer = pointPlacer
        self.Interpolator = interpolator
        self.ContourRepresentation = rep
Exemplo n.º 19
0
def main():
    colors = vtk.vtkNamedColors()

    # colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0])

    # Create the RenderWindow, Renderer and both Actors

    renderer = vtk.vtkRenderer()
    renderer.SetBackground(colors.GetColor3d('MidnightBlue'))

    renderWindow = vtk.vtkRenderWindow()
    renderWindow.AddRenderer(renderer)
    renderWindow.SetWindowName('ContourWidget')
    renderWindow.SetSize(600, 600)

    interactor = vtk.vtkRenderWindowInteractor()
    interactor.SetRenderWindow(renderWindow)

    contourRep = vtk.vtkOrientedGlyphContourRepresentation()
    contourRep.GetLinesProperty().SetColor(colors.GetColor3d('Red'))

    contourWidget = vtk.vtkContourWidget()
    contourWidget.SetInteractor(interactor)
    contourWidget.SetRepresentation(contourRep)
    contourWidget.On()

    for arg in sys.argv:
        if '-Shift' == arg:
            contourWidget.GetEventTranslator().RemoveTranslation(
                vtk.vtkCommand.LeftButtonPressEvent)
            contourWidget.GetEventTranslator().SetTranslation(
                vtk.vtkCommand.LeftButtonPressEvent,
                vtk.vtkWidgetEvent.Translate)
        elif '-Scale' == arg:
            contourWidget.GetEventTranslator().RemoveTranslation(
                vtk.vtkCommand.LeftButtonPressEvent)
            contourWidget.GetEventTranslator().SetTranslation(
                vtk.vtkCommand.LeftButtonPressEvent, vtk.vtkWidgetEvent.Scale)

    pd = vtk.vtkPolyData()

    points = vtk.vtkPoints()

    num_pts = 21
    for i in range(0, num_pts):
        angle = 2.0 * math.pi * i / 20.0
        points.InsertPoint(i, 0.1 * math.cos(angle), 0.1 * math.sin(angle),
                           0.0)
        # lines.InsertNextCell(i)
    vertex_indices = list(range(0, num_pts))
    vertex_indices.append(0)
    lines = vtk.vtkCellArray()
    lines.InsertNextCell(num_pts + 1, vertex_indices)

    pd.SetPoints(points)
    pd.SetLines(lines)

    # contourWidget.Initialize(pd, 1)
    contourWidget.Initialize(pd, 1)
    contourWidget.Render()
    renderer.ResetCamera()
    renderWindow.Render()

    interactor.Initialize()
    interactor.Start()
Exemplo n.º 20
0
    def enable(self,
               parent,
               key='result',
               color=((1, 0, 0), (0, 1, 0), (0, 0, 1)),
               dash=False,
               show=True):
        self.parent = parent
        self.datakey = key
        self.contourRep = []
        self.contourWidget = []
        # The flag of showing the contour
        self.contour = [True, True, True]
        # Avoid putting point when modifying the window level
        self.leftMove = True
        self.leftClicked = False

        self.currentContour = 0
        self.contourInfo = ['1 (Red)', '2 (Green)', '3 (Blue)']

        for i in range(3):
            self.contourRep.append(vtk.vtkOrientedGlyphContourRepresentation())
            self.contourWidget.append(vtk.vtkContourWidget())
            self.contourWidget[i].SetInteractor(self.parent.window_interactor)
            self.contourWidget[i].SetRepresentation(self.contourRep[i])

        if self.editable:
            # Disappear the line
            self.contourRep[0].GetLinesProperty().SetOpacity(0)
            self.contourRep[1].GetLinesProperty().SetOpacity(0)
            self.contourRep[2].GetLinesProperty().SetOpacity(0)
            self.contour = [False, False, False]

        self.contourRep[0].GetLinesProperty().SetColor(color[0])
        self.contourRep[1].GetLinesProperty().SetColor(color[1])
        self.contourRep[2].GetLinesProperty().SetColor(color[2])
        self.contourRep[0].GetLinesProperty().SetLineWidth(3.0)
        self.contourRep[1].GetLinesProperty().SetLineWidth(3.0)
        self.contourRep[2].GetLinesProperty().SetLineWidth(3.0)
        self.contourRep[0].GetProperty().SetColor(color[0])
        self.contourRep[1].GetProperty().SetColor(color[1])
        self.contourRep[2].GetProperty().SetColor(color[2])
        if self.editable or self.key == 'Centerline' or self.key == 'Mask':
            self.contourRep[0].GetProperty().SetOpacity(1)
            self.contourRep[1].GetProperty().SetOpacity(1)
            self.contourRep[2].GetProperty().SetOpacity(1)
        else:
            self.contourRep[0].GetProperty().SetOpacity(0)
            self.contourRep[1].GetProperty().SetOpacity(0)
            self.contourRep[2].GetProperty().SetOpacity(0)
        self.contourRep[0].GetActiveProperty().SetColor(1, 1, 1)
        self.contourRep[1].GetActiveProperty().SetColor(1, 1, 1)
        self.contourRep[2].GetActiveProperty().SetColor(1, 1, 1)
        if dash:
            for contourRep in self.contourRep:
                contourRep.GetLinesProperty().SetLineStipplePattern(0xf0f0)

        for i in range(3):
            eventTranslator = self.contourWidget[i].GetEventTranslator()
            eventTranslator.RemoveTranslation("RightButtonPressEvent")
            eventTranslator.RemoveTranslation("KeyPressEvent")
            eventTranslator.SetTranslation(vtk.vtkCommand.KeyPressEvent, 0, "",
                                           0, "Delete",
                                           vtk.vtkWidgetEvent.Delete)

            self.contourWidget[i].ProcessEventsOff()
            self.contourWidget[i].SetWidgetState(1)
            self.contourWidget[i].SetEnabled(1)
            self.contourWidget[i].On()

        status = self.parent.getDirectionAndSlice()

        self.show = show
        self.updateAfter(self.parent.view, int(status[1]))
  def __init__(self,
               input_file,
               gaussian,
               radius,
               thresh,
               zoom,
               zSlice,
               brightness,
               window_size,
               *args, **kwargs):
    """MainWindow constructor"""
    super().__init__(*args, **kwargs)

    # Window setup
    self.resize(window_size[0],window_size[1])
    self.title = "Qt Viewer for Lesion Augmentation"

    self.statusBar().showMessage("Welcome.",8000)

    # Capture defaults
    self.gaussian = gaussian
    self.radius = radius
    self.thresh = thresh
    self.zoom = zoom
    self.brightness = brightness
    self.shape_dic = None
    self.lesion_dic = {}
    self.thresholdArray = None
    self.imageArray = None
    self.zSlice = 100
    self.shape = None
    self.crop = None
    self.colorWindow = 1000
    self.colorLevel = 500
    # Initialize the window
    self.initUI()

    # Set up some VTK pipeline classes
    self.reader = None
    self.gauss = vtk.vtkImageGaussianSmooth()
    self.lesion = vtk.vtkImageData()
    self.threshold = vtk.vtkImageThreshold()
    self.mapToColors = vtk.vtkImageMapToColors()

    self.imageViewer = vtk.vtkImageViewer2()

    self.resizeImage = vtk.vtkImageResize()
    self.resizeSeg = vtk.vtkImageResize()

    self.contourRep = vtk.vtkOrientedGlyphContourRepresentation()
    self.contourWidget = vtk.vtkContourWidget()
    self.placer = vtk.vtkImageActorPointPlacer()

    self.polyData = None

    self.origmapper = vtk.vtkImageMapper()#vtkImageSliceMapper()#
    self.mapper = vtk.vtkImageMapper()
    self.stencilmapper = vtk.vtkPolyDataMapper()

    self.origactor = vtk.vtkActor2D() #vtkImageActor()
    self.actor = vtk.vtkActor2D()
    self.stencilactor = vtk.vtkActor()
    # Take inputs from command line. Only use these if there is an input file specified
    if (input_file != None):
      if (not os.path.exists(input_file)):
        qtw.QMessageBox.warning(self, "Error", "Invalid input file.")
        return

      self.createPipeline(input_file)
      self.statusBar().showMessage("Loading file " + input_file,4000)
      self.changeSigma(gaussian)
      self.changeRadius(radius)
      self.changeThreshold(thresh)
      self.changeBrightness(brightness)
      self.changeSlice(zSlice)
Exemplo n.º 22
0
SliderRepres.SetTubeWidth(0.005)
SliderRepres.SetLabelFormat("%3.0lf")
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", vtkSliderCallback2)

ImageViewer.SetSlice(SliderRepres.GetValue())

ContourWidget = vtk.vtkContourWidget()

rep = vtk.vtkOrientedGlyphContourRepresentation()
ContourWidget.SetRepresentation(rep)

imageActorPointPlacer = vtk.vtkImageActorPointPlacer()
imageActorPointPlacer.SetImageActor(ImageViewer.GetImageActor())
rep.SetPointPlacer(imageActorPointPlacer);
rep.GetProperty().SetColor(0,1,0);

del imageActorPointPlacer
del rep

ContourWidget.SetInteractor(iren)
ContourWidget.SetEnabled(True)
ContourWidget.ProcessEventsOn()
Exemplo n.º 23
0
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()
Exemplo n.º 24
0
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)

mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(r.GetOutput())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetOpacity(0.5)

contourRep = vtk.vtkOrientedGlyphContourRepresentation()
contourRep.GetLinesProperty().SetColor(0, 0, 1)
contourRep.GetLinesProperty().SetLineWidth(5)
contourRep.GetProperty().SetPointSize(5)

contourWidget = vtk.vtkContourWidget()
contourWidget.SetInteractor(iren)
contourWidget.SetRepresentation(contourRep)
contourWidget.On()
contourWidget.Initialize(TemplateF, 1)
contourWidget.CloseLoop()

pointPlacer = vtk.vtkPolygonalSurfacePointPlacer()
pointPlacer.AddProp(actor)
pointPlacer.GetPolys().AddItem(r.GetOutput())
pointPlacer.SnapToClosestPointOn()
contourRep.SetPointPlacer(pointPlacer)

ren.AddActor(actor)
ren.ResetCamera()
renWin.Render()