.. _program_listing_file_MRMLDM_vtkMRMLLayerDisplayableManager.cxx:

Program Listing for File vtkMRMLLayerDisplayableManager.cxx
===========================================================

|exhale_lsh| :ref:`Return to documentation for file <file_MRMLDM_vtkMRMLLayerDisplayableManager.cxx>` (``MRMLDM/vtkMRMLLayerDisplayableManager.cxx``)

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

.. code-block:: cpp

   #include "vtkMRMLLayerDisplayableManager.h"
   
   // Layer DM includes
   #include "vtkMRMLLayerDMPipelineFactory.h"
   #include "vtkMRMLLayerDMPipelineManager.h"
   
   // Slicer includes
   #include "vtkMRMLAbstractViewNode.h"
   #include "vtkMRMLScene.h"
   #include "vtkMRMLSliceViewDisplayableManagerFactory.h"
   #include "vtkMRMLThreeDViewDisplayableManagerFactory.h"
   
   // VTK includes
   #include <vtkImageData.h>
   #include <vtkObjectFactory.h>
   #include <vtkRenderWindow.h>
   #include <vtkRenderer.h>
   
   // STD includes
   #include <cstring>
   
   vtkStandardNewMacro(vtkMRMLLayerDisplayableManager);
   
   vtkMRMLLayerDisplayableManager::vtkMRMLLayerDisplayableManager()
     : m_pipelineManager(nullptr)
   {
   }
   
   bool vtkMRMLLayerDisplayableManager::CanProcessInteractionEvent(vtkMRMLInteractionEventData* eventData, double& distance2)
   {
     if (!this->m_pipelineManager)
     {
       return false;
     }
   
     return this->m_pipelineManager->CanProcessInteractionEvent(eventData, distance2);
   }
   
   bool vtkMRMLLayerDisplayableManager::ProcessInteractionEvent(vtkMRMLInteractionEventData* eventData)
   {
     if (!this->m_pipelineManager)
     {
       return false;
     }
   
     return this->m_pipelineManager->ProcessInteractionEvent(eventData);
   }
   
   void vtkMRMLLayerDisplayableManager::RegisterInDefaultViews()
   {
     vtkMRMLLayerDisplayableManager::RegisterInFactory(vtkMRMLSliceViewDisplayableManagerFactory::GetInstance());
     vtkMRMLLayerDisplayableManager::RegisterInFactory(vtkMRMLThreeDViewDisplayableManagerFactory::GetInstance());
   }
   
   void vtkMRMLLayerDisplayableManager::RegisterInFactory(vtkMRMLDisplayableManagerFactory* factory)
   {
     if (!factory || vtkMRMLLayerDisplayableManager::IsRegisteredInFactory(factory))
     {
       return;
     }
   
     const vtkNew<vtkMRMLLayerDisplayableManager> dm;
     factory->RegisterDisplayableManager(dm->GetClassName());
   }
   
   bool vtkMRMLLayerDisplayableManager::IsRegisteredInFactory(vtkMRMLDisplayableManagerFactory* factory)
   {
     if (!factory)
     {
       return false;
     }
   
     const vtkNew<vtkMRMLLayerDisplayableManager> dm;
     return factory->IsDisplayableManagerRegistered(dm->GetClassName());
   }
   
   vtkSmartPointer<vtkMRMLLayerDMPipelineI> vtkMRMLLayerDisplayableManager::GetNodePipeline(vtkMRMLNode* node) const
   {
     return m_pipelineManager->GetNodePipeline(node);
   }
   
   void vtkMRMLLayerDisplayableManager::OnMRMLSceneStartBatchProcess()
   {
     if (!this->m_pipelineManager)
     {
       return;
     }
     this->m_pipelineManager->BlockRequestRender(true);
   }
   
   void vtkMRMLLayerDisplayableManager::OnMRMLSceneEndBatchProcess()
   {
     if (!this->m_pipelineManager)
     {
       return;
     }
     this->m_pipelineManager->BlockRequestRender(false);
     this->m_pipelineManager->RequestRender();
   }
   
   void vtkMRMLLayerDisplayableManager::OnMRMLSceneNodeAdded(vtkMRMLNode* node)
   {
     if (!this->m_pipelineManager)
     {
       return;
     }
     this->m_pipelineManager->AddNode(node);
   }
   
   void vtkMRMLLayerDisplayableManager::OnMRMLSceneNodeRemoved(vtkMRMLNode* node)
   {
     if (!this->m_pipelineManager)
     {
       return;
     }
     this->m_pipelineManager->RemoveNode(node);
   }
   
   void vtkMRMLLayerDisplayableManager::UnobserveMRMLScene()
   {
     if (!this->m_pipelineManager)
     {
       return;
     }
     this->m_pipelineManager->ClearDisplayableNodes();
   }
   
   void vtkMRMLLayerDisplayableManager::UpdateFromMRML()
   {
     this->SetUpdateFromMRMLRequested(false);
   
     if (!this->m_pipelineManager)
     {
       return;
     }
     this->m_pipelineManager->SetScene(this->GetMRMLScene());
     this->m_pipelineManager->UpdateFromScene();
   }
   
   void vtkMRMLLayerDisplayableManager::OnMRMLDisplayableNodeModifiedEvent(vtkObject* caller)
   {
     auto viewNode = vtkMRMLAbstractViewNode::SafeDownCast(caller);
     if (!viewNode || !this->m_pipelineManager)
     {
       return;
     }
   
     this->m_pipelineManager->SetViewNode(viewNode);
   }
   
   int vtkMRMLLayerDisplayableManager::GetMouseCursor()
   {
     if (!this->m_pipelineManager)
     {
       return vtkMRMLAbstractDisplayableManager::GetMouseCursor();
     }
     return this->m_pipelineManager->GetMouseCursor();
   }
   
   void vtkMRMLLayerDisplayableManager::Create()
   {
     vtkRenderer* renderer = this->GetRenderer();
     if (!renderer || !renderer->GetRenderWindow())
     {
       vtkErrorMacro("vtkMRMLLayerDisplayableManager::Create() failed: renderer is invalid");
       return;
     }
   
     if (!this->m_pipelineManager)
     {
       this->m_pipelineManager = vtkSmartPointer<vtkMRMLLayerDMPipelineManager>::New();
     }
   
     this->m_pipelineManager->SetRenderWindow(renderer->GetRenderWindow());
     this->m_pipelineManager->SetRenderer(renderer);
     this->m_pipelineManager->SetFactory(vtkMRMLLayerDMPipelineFactory::GetInstance());
     this->m_pipelineManager->SetScene(this->GetMRMLScene());
     this->m_pipelineManager->SetViewNode(vtkMRMLAbstractViewNode::SafeDownCast(this->GetMRMLDisplayableNode()));
     this->m_pipelineManager->SetRequestRender([this] { this->RequestRender(); });
   
     // Make sure the DM is up to date with the current scene state
     this->UpdateFromMRML();
   }
   
   void vtkMRMLLayerDisplayableManager::SetRenderer(vtkRenderer* newRenderer)
   {
     Superclass::SetRenderer(newRenderer);
     if (!this->m_pipelineManager)
     {
       return;
     }
   
     this->m_pipelineManager->SetRenderWindow(newRenderer ? newRenderer->GetRenderWindow() : nullptr);
     this->m_pipelineManager->SetRenderer(newRenderer);
   }
   
   void vtkMRMLLayerDisplayableManager::SetHasFocus(bool hasFocus, vtkMRMLInteractionEventData* eventData)
   {
     Superclass ::SetHasFocus(hasFocus, eventData);
     if (this->m_pipelineManager && !hasFocus)
     {
       this->m_pipelineManager->LoseFocus(eventData);
     }
   }
   
   vtkSmartPointer<vtkImageData> vtkMRMLLayerDisplayableManager::RenderWindowBufferToImage(vtkRenderWindow* window)
   {
     auto imageData = vtkSmartPointer<vtkImageData>::New();
     RenderWindowBufferToImage(window, imageData);
     return imageData;
   }
   
   void vtkMRMLLayerDisplayableManager::RenderWindowBufferToImage(vtkRenderWindow* window, const vtkSmartPointer<vtkImageData>& imageData)
   {
     if (!window || !imageData)
     {
       return;
     }
   
     // Set image bounds to full RW bounds
     const auto size = window->GetSize();
     int imageBounds[4] = { 0, size[0] - 1, 0, size[1] - 1 };
   
     // Read pixel data from the back buffer
     const auto pixels = window->GetPixelData(imageBounds[0], imageBounds[2], imageBounds[1], imageBounds[3], 0);
   
     if (!pixels)
     {
       return;
     }
   
     // Configure imageData extent and allocate scalars for RGB
     imageData->SetExtent(imageBounds[0], imageBounds[1], imageBounds[2], imageBounds[3], 0, 0);
     imageData->AllocateScalars(VTK_UNSIGNED_CHAR, 3);
   
     // Copy pixel buffer into vtkImageData
     const auto dest = static_cast<unsigned char*>(imageData->GetScalarPointer());
     const auto numPixels = static_cast<size_t>(size[0]) * size[1];
     std::memcpy(dest, pixels, numPixels * 3 * sizeof(unsigned char));
   
     // Free the pixel buffer allocated by VTK
     delete[] pixels;
   }