mitkVtkLayerController.cpp

Go to the documentation of this file.

/*=========================================================================
 
Program:   Medical Imaging & Interaction Toolkit
Language:  C++
Date:      $Date$
Version:   $Revision$
 
Copyright (c) German Cancer Research Center, Division of Medical and
Biological Informatics. All rights reserved.
See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
 
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notices for more information.
 
=========================================================================*/

#include "mitkVtkLayerController.h"

#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkObjectFactory.h>
#include <vtkRendererCollection.h>
#include <algorithm>

mitk::VtkLayerController::vtkLayerControllerMapType mitk::VtkLayerController::s_LayerControllerMap;

mitk::VtkLayerController * mitk::VtkLayerController::GetInstance(vtkRenderWindow* renWin)
{
  for(vtkLayerControllerMapType::iterator mapit = s_LayerControllerMap.begin();
      mapit != s_LayerControllerMap.end(); mapit++)
  {
    if( (*mapit).first == renWin)
      return (*mapit).second;

  }
  return NULL;
}

void  mitk::VtkLayerController::AddInstance(vtkRenderWindow* renWin, vtkRenderer * mitkSceneRenderer)
{
  // ensure that no vtkRenderWindow is managed twice
  mitk::VtkLayerController::RemoveInstance(renWin);

  // instanciate controller, add it to the map
  mitk::VtkLayerController* ControllerInstance = new mitk::VtkLayerController(renWin);
  ControllerInstance->InsertSceneRenderer(mitkSceneRenderer);

  s_LayerControllerMap.insert(vtkLayerControllerMapType::value_type(renWin,ControllerInstance));
}     

void  mitk::VtkLayerController::RemoveInstance(vtkRenderWindow* renWin)
{
  vtkLayerControllerMapType::iterator mapit = s_LayerControllerMap.find(renWin);
  if(mapit != s_LayerControllerMap.end())
  {
    delete mapit->second;
    s_LayerControllerMap.erase( mapit );
  }
}

mitk::VtkLayerController::VtkLayerController(vtkRenderWindow* renderWindow)
{
  m_RenderWindow = renderWindow;
  m_RenderWindow->Register( NULL );
  m_BackgroundRenderers.clear();
  m_ForegroundRenderers.clear();
  m_SceneRenderers.clear();

}

mitk::VtkLayerController::~VtkLayerController()
{
  if ( m_RenderWindow != NULL )
  {
    m_RenderWindow->UnRegister( NULL );
  }
}

void mitk::VtkLayerController::InsertBackgroundRenderer(vtkRenderer* renderer, bool forceAbsoluteBackground)
{
  
  if(renderer == NULL)
    return;
  
  // Remove renderer if it already exists 
  RemoveRenderer(renderer);

  if(forceAbsoluteBackground)
  {
    RendererVectorType::iterator it = m_BackgroundRenderers.begin();
    m_BackgroundRenderers.insert(it,renderer);
  }
  else
    m_BackgroundRenderers.push_back(renderer);
  UpdateLayers();
}
void mitk::VtkLayerController::InsertForegroundRenderer(vtkRenderer* renderer, bool forceAbsoluteForeground)
{
  
  if(renderer == NULL)
    return;
  
  // Remove renderer if it already exists 
  RemoveRenderer(renderer);

  if(forceAbsoluteForeground)
  {
    RendererVectorType::iterator it = m_ForegroundRenderers.begin();
    m_ForegroundRenderers.insert(it,renderer);
  }
  else
    m_ForegroundRenderers.push_back(renderer);

  UpdateLayers();
}
vtkRenderer* mitk::VtkLayerController::GetSceneRenderer()
{
  if(m_SceneRenderers.size() > 0)
  {
    RendererVectorType::iterator it = m_SceneRenderers.begin();
    return (*it);
  }
  else
    return NULL;
}
void mitk::VtkLayerController::InsertSceneRenderer(vtkRenderer* renderer)
{
  
  if(renderer == NULL)
    return;
  
  // Remove renderer if it already exists
  RemoveRenderer(renderer);

  m_SceneRenderers.push_back(renderer);
  UpdateLayers();
}
void mitk::VtkLayerController::RemoveRenderer(vtkRenderer* renderer)
{
  RendererVectorType::iterator it;
  // background layers
  if(m_BackgroundRenderers.size() > 0)
  {
    it = std::find(m_BackgroundRenderers.begin(),m_BackgroundRenderers.end(),renderer);
    if(it != m_BackgroundRenderers.end())
    {
      m_BackgroundRenderers.erase(it);
      UpdateLayers();
      return;
    }
  }
  // scene layers
  if(m_SceneRenderers.size() > 0)
  {
    it = std::find(m_SceneRenderers.begin(),m_SceneRenderers.end(),renderer);
    if(it != m_SceneRenderers.end())
    {
      m_SceneRenderers.erase(it);
      UpdateLayers();
      return;
    }
  }
  // foreground layers
  if(m_ForegroundRenderers.size() > 0 )
  {
    it = std::find(m_ForegroundRenderers.begin(),m_ForegroundRenderers.end(),renderer);
    if(it != m_ForegroundRenderers.end())
    {
      m_ForegroundRenderers.erase(it);
      UpdateLayers();
      return;
    }
  }
}
void mitk::VtkLayerController::SetRenderWindow(vtkRenderWindow* renwin)
{
  if(renwin != NULL)
  {
    RendererVectorType::iterator it;
    // Tell all renderers that there is a new renderwindow
    for(it = m_BackgroundRenderers.begin(); it != m_BackgroundRenderers.end(); it++)
    {
      (*it)->SetRenderWindow(renwin);
    }
    for(it = m_SceneRenderers.begin(); it != m_SceneRenderers.end(); it++)
    {
      (*it)->SetRenderWindow(renwin);
    }
    for(it = m_ForegroundRenderers.begin(); it != m_ForegroundRenderers.end(); it++)
    {
      (*it)->SetRenderWindow(renwin);
    }
    // Set the new RenderWindow
    m_RenderWindow = renwin;
  }
  // Now sort renderers and add them to the renderwindow
  UpdateLayers();
}

bool mitk::VtkLayerController::IsRendererInserted(vtkRenderer* renderer)
{
  RendererVectorType::iterator it;
  // background layers
  if(m_BackgroundRenderers.size() > 0)
  {
    it = std::find(m_BackgroundRenderers.begin(),m_BackgroundRenderers.end(),renderer);
    if ( it != m_BackgroundRenderers.end() )
    {
      return true;
    }
  }
  // scene layers
  if(m_SceneRenderers.size() > 0)
  {
    it = std::find(m_SceneRenderers.begin(),m_SceneRenderers.end(),renderer);
    if ( it != m_SceneRenderers.end() )
    {
      return true;
    }
  }
  // foreground layers
  if(m_ForegroundRenderers.size() > 0 )
  {
    it = std::find(m_ForegroundRenderers.begin(),m_ForegroundRenderers.end(),renderer);
    if ( it != m_ForegroundRenderers.end() )
    {
      return true;
    }
  }
  return false;
  
}
void mitk::VtkLayerController::UpdateLayers()
{
  // Remove all Renderers from renderwindow
  vtkRendererCollection* v = m_RenderWindow->GetRenderers();
  v->RemoveAllItems();


  unsigned int numberOfLayers = static_cast<unsigned int>(m_BackgroundRenderers.size() + m_SceneRenderers.size() + m_ForegroundRenderers.size());
  int currentLayerNumber;
  bool traverseUpwards;

  #if ( VTK_MAJOR_VERSION >= 5 )
    currentLayerNumber  = 0;
    traverseUpwards     = true;
  #else
    currentLayerNumber  = numberOfLayers - 1;
    traverseUpwards     = false;
  #endif
  
  
  m_RenderWindow->SetNumberOfLayers(numberOfLayers);
  RendererVectorType::iterator it;
  // assign a layer number for the backround renderers
  for(it = m_BackgroundRenderers.begin(); it != m_BackgroundRenderers.end(); it++)
  {
    (*it)->SetRenderWindow(m_RenderWindow);
    (*it)->SetLayer(currentLayerNumber);
    m_RenderWindow->AddRenderer((*it));
    
    if(traverseUpwards)
      currentLayerNumber++;
    else
      currentLayerNumber--;
  }
  // assign a layer number for the scene renderers
  for(it = m_SceneRenderers.begin(); it != m_SceneRenderers.end(); it++)
  {   
    (*it)->SetRenderWindow(m_RenderWindow);
    (*it)->SetLayer(currentLayerNumber);
    m_RenderWindow->AddRenderer((*it));
    
    if(traverseUpwards)
      currentLayerNumber++;
    else
      currentLayerNumber--;
  }
  // assign a layer number for the foreground renderers
  for(it = m_ForegroundRenderers.begin(); it != m_ForegroundRenderers.end(); it++)
  {
    (*it)->SetRenderWindow(m_RenderWindow);
    (*it)->SetLayer(currentLayerNumber);
    m_RenderWindow->AddRenderer((*it));
    
    if(traverseUpwards)
      currentLayerNumber++;
    else
      currentLayerNumber--;
  }
}
unsigned int mitk::VtkLayerController::GetNumberOfRenderers()
{
  return static_cast<unsigned int>(m_BackgroundRenderers.size() + m_SceneRenderers.size() + m_ForegroundRenderers.size());
}

void mitk::VtkLayerController::SetEraseForAllRenderers(int i)
{
  #if ( VTK_MAJOR_VERSION >= 5 )
  
  this->m_RenderWindow->SetErase(i);

  RendererVectorType::iterator it;
  for(it = m_BackgroundRenderers.begin(); it != m_BackgroundRenderers.end(); it++)
    (*it)->SetErase(i);
  
  for(it = m_SceneRenderers.begin(); it != m_SceneRenderers.end(); it++)
   (*it)->SetErase(i);

  for(it = m_ForegroundRenderers.begin(); it != m_ForegroundRenderers.end(); it++)
   (*it)->SetErase(i);
  
  #endif
}