.. _program_listing_file_Testing_Python_DisplayableManagerTest.py:

Program Listing for File DisplayableManagerTest.py
==================================================

|exhale_lsh| :ref:`Return to documentation for file <file_Testing_Python_DisplayableManagerTest.py>` (``Testing/Python/DisplayableManagerTest.py``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: py

   import slicer
   from slicer import (
       vtkMRMLLayerDMPipelineFactory,
       vtkMRMLLayerDMPipelineI,
       vtkMRMLLayerDMPipelineManager,
       vtkMRMLLayerDMPipelineScriptedCreator,
       vtkMRMLLayerDisplayableManager,
       vtkMRMLScene,
       vtkMRMLScriptedModuleNode,
       vtkMRMLSliceViewDisplayableManagerFactory,
       vtkMRMLThreeDViewDisplayableManagerFactory,
   )
   from slicer.ScriptedLoadableModule import ScriptedLoadableModuleTest
   from vtk import VTK_OBJECT, vtkActor, vtkImageData, vtkObjectFactory, vtkRenderer
   
   from MockPipeline import MockPipeline
   
   
   class DisplayableManagerTest(ScriptedLoadableModuleTest):
       def setUp(self):
           slicer.mrmlScene.Clear(0)
   
           # Verify the DM can be created by the vtk Object Factory
           assert vtkObjectFactory.CreateInstance(vtkMRMLLayerDisplayableManager.__name__) is not None
   
           # Register the DM to the default views
           vtkMRMLLayerDisplayableManager.RegisterInDefaultViews()
   
           # Verify registration is correct for both 2D and 3D views
           assert vtkMRMLLayerDisplayableManager.IsRegisteredInFactory(
               vtkMRMLSliceViewDisplayableManagerFactory.GetInstance()
           )
           assert vtkMRMLLayerDisplayableManager.IsRegisteredInFactory(
               vtkMRMLThreeDViewDisplayableManagerFactory.GetInstance()
           )
   
           self.threeDNode = slicer.mrmlScene.GetNodeByID("vtkMRMLViewNode1")
           self.node = vtkMRMLScriptedModuleNode()
   
           # Register a pipeline creator with static pipeline
           self.pipeline = MockPipeline()
           self.factory = vtkMRMLLayerDMPipelineFactory.GetInstance()
           self.creator = vtkMRMLLayerDMPipelineScriptedCreator()
           self.creator.SetPythonCallback(
               lambda view, node: self.pipeline if view == self.threeDNode and node == self.node else None
           )
           self.factory.AddPipelineCreator(self.creator)
   
       def tearDown(self):
           self.factory.RemovePipelineCreator(self.creator)
   
       def test_registered_pipelines_can_add_their_actors_to_views(self):
           # Configure pipeline renderer added to add a new actor
           actor = vtkActor()
   
           def onRendererAdded(renderer: vtkRenderer):
               if renderer:
                   renderer.AddViewProp(actor)
   
           self.pipeline.mockOnRendererAdded.side_effect = onRendererAdded
   
           # Trigger pipeline creation by adding a node to the scene
           slicer.mrmlScene.AddNode(self.node)
   
           # Verify the pipeline's actor is present in the threed view
           renderWindow = slicer.app.layoutManager().viewWidget(self.threeDNode).viewWidget().renderWindow()
           renderer = renderWindow.GetRenderers().GetItemAsObject(0)
           assert renderer.HasViewProp(actor)
   
       def test_registered_pipelines_have_access_to_scene_manager_view_and_display_node(self):
           # Trigger pipeline creation by adding a new model node to the scene
           slicer.mrmlScene.AddNode(self.node)
   
           # Check getters point to the right instances
           assert self.pipeline.GetScene() == slicer.mrmlScene
           assert isinstance(self.pipeline.GetPipelineManager(), vtkMRMLLayerDMPipelineManager)
           assert self.pipeline.GetViewNode() == self.threeDNode
           assert self.pipeline.GetDisplayNode() == self.node
   
       def test_registered_pipelines_can_override_setters_to_scene_manager_view_and_display_node(self):
           # Trigger pipeline creation by adding a new model node to the scene
           slicer.mrmlScene.AddNode(self.node)
   
           # Check overridden setters where called
           self.pipeline.mockSetScene.assert_called_with(slicer.mrmlScene)
           self.pipeline.mockSetPipelineManager.assert_called_with(self.pipeline.GetPipelineManager())
           self.pipeline.mockSetViewNode.assert_called_with(self.threeDNode)
           self.pipeline.mockSetDisplayNode.assert_called_with(self.node)
   
       def test_pipelines_have_access_to_sibling_pipelines(self):
           # Register a second pipeline creator
           otherNode = vtkMRMLScriptedModuleNode()
           otherPipeline = MockPipeline()
   
           otherCreator = vtkMRMLLayerDMPipelineScriptedCreator()
           otherCreator.SetPythonCallback(
               lambda view, node: otherPipeline if view == self.threeDNode and node == otherNode else None
           )
           self.factory.AddPipelineCreator(otherCreator)
   
           # Add both nodes to the scene for pipeline creation to happen
           slicer.mrmlScene.AddNode(self.node)
           slicer.mrmlScene.AddNode(otherNode)
   
           # Assert the first pipeline has access to the second one
           assert self.pipeline.GetNodePipeline(otherNode) == otherPipeline
   
       def test_pipelines_can_add_observers_to_vtk_objects_and_events(self):
           def onSetScene(scene: vtkMRMLScene):
               assert self.pipeline.GetScene() != scene
               self.pipeline.UpdateObserver(self.pipeline.GetScene(), scene, vtkMRMLScene.NodeAddedEvent)
               vtkMRMLLayerDMPipelineI.SetScene(self.pipeline, scene)
   
           # Add observer on the scene when its added
           self.pipeline.mockSetScene.side_effect = onSetScene
   
           slicer.mrmlScene.AddNode(self.node)
           self.pipeline.mockSetScene.assert_called_once()
   
           modelNode = slicer.mrmlScene.AddNewNodeByClass("vtkMRMLModelNode")
           self.pipeline.mockOnUpdate.assert_called_once()
           args = self.pipeline.mockOnUpdate.call_args[0]
           assert args[0] == slicer.mrmlScene
           assert args[1] == vtkMRMLScene.NodeAddedEvent
           assert self.pipeline.CastCallData(args[2], VTK_OBJECT) == modelNode
   
       def test_pipelines_update_display_is_called_at_init(self):
           slicer.mrmlScene.AddNode(self.node)
           self.pipeline.mockUpdatePipeline.assert_called_once()
   
       def test_pipelines_update_display_is_called_at_reset(self):
           slicer.mrmlScene.AddNode(self.node)
           self.pipeline.mockUpdatePipeline.reset_mock()
   
           self.pipeline.ResetDisplay()
           self.pipeline.mockUpdatePipeline.assert_called_once()
   
       def test_pipeline_exceptions_are_propagated_to_python(self):
           _error_msg = "Something went wrong in Python"
           self.pipeline.mockUpdatePipeline.side_effect = RuntimeError(_error_msg)
   
           with self.assertRaises(RuntimeError) as context:
               slicer.mrmlScene.AddNode(self.node)
           assert _error_msg in str(context.exception)
   
       def test_can_render_to_image_data(self):
           render_window = slicer.app.layoutManager().threeDWidget(0).threeDView().renderWindow()
   
           # Direct return value call
           image = vtkMRMLLayerDisplayableManager.RenderWindowBufferToImage(render_window)
           assert isinstance(image, vtkImageData)
           assert image.GetDimensions()[0] == render_window.GetSize()[0]
           assert image.GetDimensions()[1] == render_window.GetSize()[1]
   
           # Mutated call
           image = vtkImageData()
           vtkMRMLLayerDisplayableManager.RenderWindowBufferToImage(render_window, image)
           assert isinstance(image, vtkImageData)
           assert image.GetDimensions()[0] == render_window.GetSize()[0]
           assert image.GetDimensions()[1] == render_window.GetSize()[1]