ENH: Clean VTK viewer class

Enforces const correctness

Base/SimulationManager/imstkVTKInteractorStyle.cpp

@@ -78,10 +78,10 @@ VTKInteractorStyle::OnTimer()
     }
 
     // Update Camera
-    m_simManager->getViewer()->getCurrentRenderer()->updateSceneCamera(m_simManager->getCurrentScene()->getCamera());
+    m_simManager->getViewer()->getActiveRenderer()->updateSceneCamera(m_simManager->getActiveScene()->getCamera());
 
     // Update render delegates
-    m_simManager->getViewer()->getCurrentRenderer()->updateRenderDelegates();
+    m_simManager->getViewer()->getActiveRenderer()->updateRenderDelegates();
 
     // Reset camera clipping range
     this->CurrentRenderer->ResetCameraClippingRange();
@@ -115,10 +115,10 @@ VTKInteractorStyle::OnTimer()
         this->Interactor->CreateOneShotTimer(1);
     }
 
-    // Call custom behaviour
+    // Call custom behavior
     if (m_onTimerFunction)
     {
-        // Call the custom behaviour to run on every frame
+        // Call the custom behavior to run on every frame
         m_onTimerFunction(this);
     }
 }

Base/SimulationManager/imstkVTKViewer.cpp

@@ -28,25 +28,25 @@
 namespace imstk
 {
 std::shared_ptr<Scene>
-VTKViewer::getCurrentScene() const
+VTKViewer::getActiveScene() const
 {
-    return m_currentScene;
+    return m_activeScene;
 }
 
 void
-VTKViewer::setCurrentScene(std::shared_ptr<Scene>scene)
+VTKViewer::setActiveScene(std::shared_ptr<Scene> scene)
 {
     // If already current scene
-    if( scene == m_currentScene )
+    if( scene == m_activeScene )
     {
         LOG(WARNING) << scene->getName() << " already is the viewer current scene.";
         return;
     }
 
     // If the current scene has a renderer, remove it
-    if( m_currentScene )
+    if( m_activeScene )
     {
-        auto vtkRenderer = this->getCurrentRenderer()->getVtkRenderer();
+        auto vtkRenderer = this->getActiveRenderer()->getVtkRenderer();
         if(m_vtkRenderWindow->HasRenderer(vtkRenderer))
         {
             m_vtkRenderWindow->RemoveRenderer(vtkRenderer);
@@ -54,34 +54,34 @@ VTKViewer::setCurrentScene(std::shared_ptr<Scene>scene)
     }
 
     // Update current scene
-    m_currentScene = scene;
+    m_activeScene = scene;
 
     // Create renderer if it doesn't exist
-    if (!m_rendererMap.count(m_currentScene))
+    if (!m_rendererMap.count(m_activeScene))
     {
-        m_rendererMap[m_currentScene] = std::make_shared<VTKRenderer>(m_currentScene);
+        m_rendererMap[m_activeScene] = std::make_shared<VTKRenderer>(m_activeScene);
     }
 
     // Set renderer to renderWindow
-    m_vtkRenderWindow->AddRenderer(this->getCurrentRenderer()->getVtkRenderer());
+    m_vtkRenderWindow->AddRenderer(this->getActiveRenderer()->getVtkRenderer());
 
     // Set renderer to interactorStyle
-    m_interactorStyle->SetCurrentRenderer(this->getCurrentRenderer()->getVtkRenderer());
+    m_interactorStyle->SetCurrentRenderer(this->getActiveRenderer()->getVtkRenderer());
 
     // Set name to renderWindow
-    m_vtkRenderWindow->SetWindowName(m_currentScene->getName().data());
+    m_vtkRenderWindow->SetWindowName(m_activeScene->getName().data());
 }
 
 std::shared_ptr<VTKRenderer>
-VTKViewer::getCurrentRenderer() const
+VTKViewer::getActiveRenderer() const
 {
-    return m_rendererMap.at(m_currentScene);
+    return m_rendererMap.at(m_activeScene);
 }
 
 void
-VTKViewer::setRenderingMode(VTKRenderer::Mode mode)
+VTKViewer::setRenderingMode(const VTKRenderer::Mode mode)
 {
-    if( !m_currentScene )
+    if( !m_activeScene )
     {
         LOG(WARNING) << "Missing scene, can not set rendering mode.\n"
                      << "Use Viewer::setCurrentScene to setup scene.";
@@ -89,7 +89,7 @@ VTKViewer::setRenderingMode(VTKRenderer::Mode mode)
     }
 
     // Setup renderer
-    this->getCurrentRenderer()->setMode(mode);
+    this->getActiveRenderer()->setMode(mode);
     if( !m_running )
     {
         return;
@@ -116,17 +116,18 @@ VTKViewer::setRenderingMode(VTKRenderer::Mode mode)
 const VTKRenderer::Mode&
 VTKViewer::getRenderingMode()
 {
-    return this->getCurrentRenderer()->getMode();
+    return this->getActiveRenderer()->getMode();
 }
 
 void
 VTKViewer::startRenderingLoop()
 {
     m_running = true;
-    m_vtkRenderWindow->GetInteractor()->Initialize();
-    m_vtkRenderWindow->GetInteractor()->CreateOneShotTimer(0);
-    m_vtkRenderWindow->GetInteractor()->Start();
-    m_vtkRenderWindow->GetInteractor()->DestroyTimer();
+    auto interactor = m_vtkRenderWindow->GetInteractor();
+    interactor->Initialize();
+    interactor->CreateOneShotTimer(0);
+    interactor->Start();
+    interactor->DestroyTimer();
     m_running = false;
 }
 
@@ -146,7 +147,7 @@ VTKViewer::getVtkRenderWindow() const
     return m_vtkRenderWindow;
 }
 
-const bool&
+bool
 VTKViewer::isRendering() const
 {
     return m_running;
@@ -165,7 +166,7 @@ VTKViewer::getTargetFrameRate() const
 }
 
 void
-VTKViewer::setTargetFrameRate(const double& fps)
+VTKViewer::setTargetFrameRate(const double fps)
 {
     if(fps < 0)
     {
@@ -257,6 +258,6 @@ VTKViewer::getScreenCaptureUtility() const
 void
 VTKViewer::setBackgroundColors(const Vec3d color1, const Vec3d color2 /*= Vec3d::Zero()*/, const bool gradientBackground /*= false*/)
 {
-    this->getCurrentRenderer()->updateBackground(color1, color2, gradientBackground);
+    this->getActiveRenderer()->updateBackground(color1, color2, gradientBackground);
 }
 } // imstk

Base/SimulationManager/imstkVTKViewer.h

@@ -34,7 +34,7 @@
 #include "vtkRenderWindow.h"
 #include "vtkRenderWindowInteractor.h"
 
-//Screenshot utility
+// Screenshot utility
 #include "imstkVTKScreenCaptureUtility.h"
 
 namespace imstk
@@ -56,8 +56,8 @@ public:
     {
         m_interactorStyle->m_simManager = manager;
         m_vtkRenderWindow->SetInteractor(m_vtkRenderWindow->MakeRenderWindowInteractor());
-        m_vtkRenderWindow->GetInteractor()->SetInteractorStyle( m_interactorStyle );
-        m_vtkRenderWindow->SetSize(1000,800);
+        m_vtkRenderWindow->GetInteractor()->SetInteractorStyle(m_interactorStyle);
+        m_vtkRenderWindow->SetSize(1000, 800);
         m_screenCapturer = std::make_shared<VTKScreenCaptureUtility>(m_vtkRenderWindow);
     }
 
@@ -69,23 +69,23 @@ public:
     ///
     /// \brief Get scene currently being rendered
     ///
-    std::shared_ptr<Scene> getCurrentScene() const;
+    std::shared_ptr<Scene> getActiveScene() const;
 
     ///
     /// \brief Set scene to be rendered
     ///
-    void setCurrentScene(std::shared_ptr<Scene>scene);
+    void setActiveScene(std::shared_ptr<Scene> scene);
 
     ///
     /// \brief Retrieve the renderer associated with the current scene
     ///
-    std::shared_ptr<VTKRenderer> getCurrentRenderer() const;
+    std::shared_ptr<VTKRenderer> getActiveRenderer() const;
 
     ///
     /// \brief Setup the current renderer to render what's needed
     /// based on the mode chosen
     ///
-    void setRenderingMode(VTKRenderer::Mode mode);
+    void setRenderingMode(const VTKRenderer::Mode mode);
 
     ///
     /// \brief Get the current renderer mode
@@ -105,12 +105,12 @@ public:
     ///
     /// \brief Get pointer to the vtkRenderWindow rendering
     ///
-    vtkSmartPointer<vtkRenderWindow>getVtkRenderWindow() const;
+    vtkSmartPointer<vtkRenderWindow> getVtkRenderWindow() const;
 
     ///
     /// \brief Returns true if the Viewer is rendering
     ///
-    const bool& isRendering() const;
+    bool isRendering() const;
 
     ///
     /// \brief Get the target FPS for rendering
@@ -120,7 +120,7 @@ public:
     ///
     /// \brief Set the target FPS for rendering
     ///
-    void setTargetFrameRate(const double& fps);
+    void setTargetFrameRate(const double fps);
 
     ///
     /// \brief Set custom event handlers on interactor style
@@ -157,7 +157,7 @@ protected:
 
     vtkSmartPointer<vtkRenderWindow> m_vtkRenderWindow = vtkSmartPointer<vtkRenderWindow>::New();
     vtkSmartPointer<VTKInteractorStyle> m_interactorStyle = vtkSmartPointer<VTKInteractorStyle>::New();
-    std::shared_ptr<Scene> m_currentScene;
+    std::shared_ptr<Scene> m_activeScene;
     std::unordered_map<std::shared_ptr<Scene>, std::shared_ptr<VTKRenderer>> m_rendererMap;
     std::shared_ptr<VTKScreenCaptureUtility> m_screenCapturer; ///> Screen shot utility
     bool m_running = false;