mitk: mitkBaseRenderer.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date$
00006 Version:   $Revision$
00007 
00008 Copyright (c) German Cancer Research Center, Division of Medical and
00009 Biological Informatics. All rights reserved.
00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012 This software is distributed WITHOUT ANY WARRANTY; without even
00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014 PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 
00018 
00019 #include "mitkBaseRenderer.h"
00020 #include "mitkMapper.h"
00021 #include "mitkResliceMethodProperty.h"
00022 
00023 // Geometries
00024 #include "mitkPlaneGeometry.h"
00025 #include "mitkSlicedGeometry3D.h"
00026 
00027 
00028 // Controllers
00029 #include "mitkCameraController.h"
00030 #include "mitkSliceNavigationController.h"
00031 #include "mitkCameraRotationController.h"
00032 #include "mitkVtkInteractorCameraController.h"
00033 
00034 #ifdef MITK_USE_TD_MOUSE
00035   #include "mitkTDMouseVtkCameraController.h"
00036 #else
00037   #include "mitkCameraController.h"
00038 #endif
00039 
00040 #include "mitkVtkLayerController.h"
00041 
00042 // Events
00043 #include "mitkEventMapper.h"
00044 #include "mitkGlobalInteraction.h"
00045 #include "mitkPositionEvent.h"
00046 #include "mitkDisplayPositionEvent.h"
00047 
00048 #include "mitkProperties.h"
00049 #include "mitkWeakPointerProperty.h"
00050 
00051 #include "mitkInteractionConst.h"
00052 
00053 // VTK
00054 #include <vtkLinearTransform.h>
00055 #include <vtkRenderer.h>
00056 #include <vtkRenderWindow.h>
00057 #include <vtkCamera.h>
00058 
00059 #include <vtkProperty.h>
00060 #include <vtkPolyDataMapper.h>
00061 #include <vtkActor.h>
00062 
00063 
00064 mitk::BaseRenderer::BaseRendererMapType mitk::BaseRenderer::baseRendererMap;
00065 
00066 
00067 mitk::BaseRenderer* mitk::BaseRenderer::GetInstance(vtkRenderWindow * renWin)
00068 {
00069    for(BaseRendererMapType::iterator mapit = baseRendererMap.begin(); 
00070       mapit != baseRendererMap.end(); mapit++)
00071   {
00072     if( (*mapit).first == renWin)
00073       return (*mapit).second;
00074   }
00075   return NULL;
00076 }
00077 
00078 
00079 void mitk::BaseRenderer::AddInstance(vtkRenderWindow* renWin, BaseRenderer* baseRenderer)
00080 {
00081   if(renWin == NULL || baseRenderer == NULL)
00082     return;
00083 
00084   // ensure that no BaseRenderer is managed twice
00085   mitk::BaseRenderer::RemoveInstance(renWin);
00086 
00087   baseRendererMap.insert(BaseRendererMapType::value_type(renWin,baseRenderer));
00088 }
00089 
00090 
00091 void mitk::BaseRenderer::RemoveInstance(vtkRenderWindow* renWin)
00092 {
00093   BaseRendererMapType::iterator mapit = baseRendererMap.find(renWin);
00094   if(mapit != baseRendererMap.end())
00095     baseRendererMap.erase(mapit);
00096 }
00097 
00098 
00099 mitk::BaseRenderer* mitk::BaseRenderer::GetByName( const std::string& name )
00100 {
00101   for(BaseRendererMapType::iterator mapit = baseRendererMap.begin(); 
00102     mapit != baseRendererMap.end(); mapit++)
00103   {
00104     if( (*mapit).second->m_Name == name)
00105       return (*mapit).second;
00106   }
00107   return NULL;
00108 }
00109 
00110 
00111 vtkRenderWindow* mitk::BaseRenderer::GetRenderWindowByName( const std::string& name )
00112 {
00113   for(BaseRendererMapType::iterator mapit = baseRendererMap.begin(); 
00114   mapit != baseRendererMap.end(); mapit++)
00115   {
00116     if( (*mapit).second->m_Name == name)
00117       return (*mapit).first;
00118   }
00119   return NULL;
00120 }
00121 
00122 
00123 mitk::BaseRenderer::BaseRenderer( const char* name, vtkRenderWindow * renWin, mitk::RenderingManager* rm ) :
00124 m_RenderWindow(NULL), m_VtkRenderer(NULL), m_MapperID(defaultMapper), m_DataStorage(NULL), m_RenderingManager(rm), m_LastUpdateTime(0),
00125 m_CameraController(NULL), m_SliceNavigationController(NULL), m_CameraRotationController(NULL), /*m_Size(),*/
00126  m_Focused(false), m_WorldGeometry(NULL), m_TimeSlicedWorldGeometry(NULL), m_CurrentWorldGeometry(NULL), m_CurrentWorldGeometry2D(NULL),
00127 m_DisplayGeometry(NULL), m_Slice(0), m_TimeStep(), m_CurrentWorldGeometry2DUpdateTime(), m_DisplayGeometryUpdateTime(),
00128 m_TimeStepUpdateTime(), m_WorldGeometryData(NULL), m_DisplayGeometryData(NULL), m_CurrentWorldGeometry2DData(NULL),
00129 m_WorldGeometryNode(NULL), m_DisplayGeometryNode(NULL), m_CurrentWorldGeometry2DNode(NULL), m_DisplayGeometryTransformTime(0),
00130 m_CurrentWorldGeometry2DTransformTime(0), m_Name(name), /*m_Bounds(),*/ m_EmptyWorldGeometry(true), m_DepthPeelingEnabled(true),
00131 m_MaxNumberOfPeels(100), m_NumberOfVisibleLODEnabledMappers(0)
00132 {
00133   m_Bounds[0] = 0;
00134   m_Bounds[1] = 0;
00135   m_Bounds[2] = 0;
00136   m_Bounds[3] = 0;
00137   m_Bounds[4] = 0;
00138   m_Bounds[5] = 0;
00139 
00140   if (name != NULL)
00141   {
00142     m_Name = name;
00143   }
00144   else
00145   {
00146     m_Name = "unnamed renderer";
00147     itkWarningMacro(<< "Created unnamed renderer. Bad for serialization. Please choose a name.");
00148   }
00149 
00150   if(renWin != NULL)
00151   {
00152     m_RenderWindow = renWin;
00153     m_RenderWindow->Register(NULL);
00154   }
00155   else
00156   {
00157     itkWarningMacro(<< "Created mitkBaseRenderer without vtkRenderWindow present.");
00158   }
00159 
00160   m_Size[0] = 0;
00161   m_Size[1] = 0;
00162 
00163   //instances.insert( this );
00164 
00165   //adding this BaseRenderer to the List of all BaseRenderer
00166   m_RenderingManager->GetGlobalInteraction()->AddFocusElement(this);
00167 
00168   WeakPointerProperty::Pointer rendererProp = WeakPointerProperty::New((itk::Object*)this);
00169 
00170   m_CurrentWorldGeometry2D = mitk::PlaneGeometry::New();
00171 
00172   m_CurrentWorldGeometry2DData = mitk::Geometry2DData::New();
00173   m_CurrentWorldGeometry2DData->SetGeometry2D(m_CurrentWorldGeometry2D);
00174   m_CurrentWorldGeometry2DNode = mitk::DataNode::New();
00175   m_CurrentWorldGeometry2DNode->SetData(m_CurrentWorldGeometry2DData);
00176   m_CurrentWorldGeometry2DNode->GetPropertyList()->SetProperty("renderer", rendererProp);
00177   m_CurrentWorldGeometry2DNode->GetPropertyList()->SetProperty("layer", IntProperty::New(1000));
00178 
00179   m_CurrentWorldGeometry2DNode->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( ) );
00180   m_CurrentWorldGeometry2DNode->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( 1 ) );
00181 
00182   m_CurrentWorldGeometry2DTransformTime = m_CurrentWorldGeometry2DNode->GetVtkTransform()->GetMTime();
00183 
00184   m_DisplayGeometry = mitk::DisplayGeometry::New();
00185   m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldGeometry2D);
00186   m_DisplayGeometryData = mitk::Geometry2DData::New();
00187   m_DisplayGeometryData->SetGeometry2D(m_DisplayGeometry);
00188   m_DisplayGeometryNode = mitk::DataNode::New();
00189   m_DisplayGeometryNode->SetData(m_DisplayGeometryData);
00190   m_DisplayGeometryNode->GetPropertyList()->SetProperty("renderer", rendererProp);
00191   m_DisplayGeometryTransformTime = m_DisplayGeometryNode->GetVtkTransform()->GetMTime();
00192 
00193 
00194   mitk::SliceNavigationController::Pointer sliceNavigationController = mitk::SliceNavigationController::New( "navigation" );
00195   sliceNavigationController->SetRenderer( this );
00196   sliceNavigationController->ConnectGeometrySliceEvent( this );
00197   sliceNavigationController->ConnectGeometryUpdateEvent( this );
00198   sliceNavigationController->ConnectGeometryTimeEvent( this, false );
00199   m_SliceNavigationController = sliceNavigationController;
00200 
00201   m_CameraRotationController = mitk::CameraRotationController::New();
00202   m_CameraRotationController->SetRenderWindow( m_RenderWindow );
00203   m_CameraRotationController->AcquireCamera();
00204 
00205 //if TD Mouse Interaction is activated, then call TDMouseVtkCameraController instead of VtkInteractorCameraController
00206 #ifdef MITK_USE_TD_MOUSE
00207     m_CameraController = mitk::TDMouseVtkCameraController::New();
00208 #else
00209     m_CameraController = mitk::CameraController::New(NULL);
00210 #endif
00211 
00212   m_VtkRenderer = vtkRenderer::New();
00213 
00214   if (mitk::VtkLayerController::GetInstance(m_RenderWindow) == NULL)
00215   {  
00216     mitk::VtkLayerController::AddInstance(m_RenderWindow,m_VtkRenderer);
00217     mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer);
00218   }
00219   else
00220     mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer);  
00221 }
00222 
00223 
00224 mitk::BaseRenderer::~BaseRenderer()
00225 {
00226   if(m_VtkRenderer!=NULL)
00227   {
00228     m_VtkRenderer->Delete();
00229     m_VtkRenderer = NULL;
00230   }
00231 
00232   if(m_CameraController.IsNotNull())
00233     m_CameraController->SetRenderer(NULL);
00234   
00235   m_RenderingManager->GetGlobalInteraction()->RemoveFocusElement(this);
00236 
00237   mitk::VtkLayerController::RemoveInstance(m_RenderWindow);
00238 
00239   RemoveAllLocalStorages();
00240     
00241   
00242   m_DataStorage = NULL;
00243 
00244   if(m_RenderWindow!=NULL)
00245   {
00246     m_RenderWindow->Delete();
00247     m_RenderWindow = NULL;
00248   }
00249 }
00250 
00251 void mitk::BaseRenderer::RemoveAllLocalStorages()
00252 {
00253   this->InvokeEvent(mitk::BaseRenderer::RendererResetEvent());
00254   
00255   std::list<mitk::BaseLocalStorageHandler*>::iterator it;
00256   for ( it=m_RegisteredLocalStorageHandlers.begin() ; it != m_RegisteredLocalStorageHandlers.end(); it++ )
00257     (*it)->ClearLocalStorage(this,false);
00258   m_RegisteredLocalStorageHandlers.clear();  
00259 }
00260 
00261 void mitk::BaseRenderer::RegisterLocalStorageHandler( mitk::BaseLocalStorageHandler *lsh )
00262 {
00263   m_RegisteredLocalStorageHandlers.push_back(lsh);
00264   
00265 }
00266 
00267 void mitk::BaseRenderer::UnregisterLocalStorageHandler( mitk::BaseLocalStorageHandler *lsh )
00268 {
00269   m_RegisteredLocalStorageHandlers.remove(lsh);
00270 }
00271 
00272 
00273 void mitk::BaseRenderer::SetDataStorage(DataStorage* storage)
00274 {
00275   if ( storage != NULL )
00276   {
00277     m_DataStorage = storage;
00278     this->Modified();
00279   }
00280 }
00281 
00282 const mitk::BaseRenderer::MapperSlotId mitk::BaseRenderer::defaultMapper = 1;
00283 
00284 void mitk::BaseRenderer::Paint()
00285 {
00286 }
00287 
00288 void mitk::BaseRenderer::Initialize()
00289 {
00290 }
00291 
00292 void mitk::BaseRenderer::Resize(int w, int h)
00293 {
00294   m_Size[0] = w;
00295   m_Size[1] = h;
00296 
00297   if(m_CameraController)
00298     m_CameraController->Resize(w, h); //(formerly problematic on windows: vtkSizeBug)
00299 
00300   GetDisplayGeometry()->SetSizeInDisplayUnits(w, h);
00301 }
00302 
00303 void mitk::BaseRenderer::InitRenderer(vtkRenderWindow* renderwindow)
00304 {
00305   if(m_RenderWindow != NULL)
00306   {
00307     m_RenderWindow->Delete();
00308   }
00309   m_RenderWindow = renderwindow;
00310   if(m_RenderWindow != NULL)
00311   {
00312     m_RenderWindow->Register(NULL);
00313   }
00314   
00315   RemoveAllLocalStorages();
00316   
00317   if(m_CameraController.IsNotNull())
00318   {
00319     m_CameraController->SetRenderer(this);
00320   }
00321 
00322   //BUG (#1551) added settings for depth peeling
00323 #if ( ( VTK_MAJOR_VERSION >= 5 ) && ( VTK_MINOR_VERSION>=2)  )
00324   m_RenderWindow->SetAlphaBitPlanes(1);
00325   m_VtkRenderer->SetUseDepthPeeling(m_DepthPeelingEnabled);
00326   m_VtkRenderer->SetMaximumNumberOfPeels(m_MaxNumberOfPeels);
00327   m_VtkRenderer->SetOcclusionRatio(0.1);
00328 #endif
00329 }
00330 
00331 void mitk::BaseRenderer::InitSize(int w, int h)
00332 {
00333   m_Size[0] = w;
00334   m_Size[1] = h;
00335   GetDisplayGeometry()->SetSizeInDisplayUnits(w, h, false);
00336   GetDisplayGeometry()->Fit();
00337 }
00338 
00339 void mitk::BaseRenderer::SetSlice(unsigned int slice)
00340 {
00341   if(m_Slice!=slice)
00342   {
00343     m_Slice = slice;
00344     if(m_TimeSlicedWorldGeometry.IsNotNull())
00345     {
00346       SlicedGeometry3D* slicedWorldGeometry=dynamic_cast<SlicedGeometry3D*>(m_TimeSlicedWorldGeometry->GetGeometry3D(m_TimeStep));
00347       if(slicedWorldGeometry!=NULL)
00348       {
00349         if(m_Slice >= slicedWorldGeometry->GetSlices())
00350           m_Slice = slicedWorldGeometry->GetSlices()-1;
00351         SetCurrentWorldGeometry2D(slicedWorldGeometry->GetGeometry2D(m_Slice));
00352         SetCurrentWorldGeometry(slicedWorldGeometry);
00353       }
00354     }
00355     else
00356       Modified();
00357   }
00358 }
00359 
00360 void mitk::BaseRenderer::SetTimeStep(unsigned int timeStep)
00361 {
00362   if(m_TimeStep!=timeStep)
00363   {
00364     m_TimeStep = timeStep;
00365     m_TimeStepUpdateTime.Modified();
00366 
00367     if(m_TimeSlicedWorldGeometry.IsNotNull())
00368     {
00369       if(m_TimeStep >= m_TimeSlicedWorldGeometry->GetTimeSteps())
00370         m_TimeStep = m_TimeSlicedWorldGeometry->GetTimeSteps()-1;
00371       SlicedGeometry3D* slicedWorldGeometry=dynamic_cast<SlicedGeometry3D*>(m_TimeSlicedWorldGeometry->GetGeometry3D(m_TimeStep));
00372       if(slicedWorldGeometry!=NULL)
00373       {
00374         SetCurrentWorldGeometry2D(slicedWorldGeometry->GetGeometry2D(m_Slice));
00375         SetCurrentWorldGeometry(slicedWorldGeometry);
00376       }
00377     }
00378     else
00379       Modified();
00380   }
00381 }
00382 
00383 int mitk::BaseRenderer::GetTimeStep(const mitk::BaseData* data) const
00384 {
00385   if( (data==NULL) || (data->IsInitialized()==false) )
00386   {
00387     return -1;
00388   }
00389   return data->GetTimeSlicedGeometry()->MSToTimeStep(GetTime());
00390 }
00391 
00392 mitk::ScalarType mitk::BaseRenderer::GetTime() const
00393 {
00394   if(m_TimeSlicedWorldGeometry.IsNull())
00395   {
00396     return 0;
00397   }
00398   else
00399   {
00400     ScalarType timeInMS = m_TimeSlicedWorldGeometry->TimeStepToMS(GetTimeStep());
00401     if(timeInMS == ScalarTypeNumericTraits::NonpositiveMin())
00402       return 0;
00403     else
00404       return timeInMS;
00405   }
00406 }
00407 
00408 void mitk::BaseRenderer::SetWorldGeometry(mitk::Geometry3D* geometry)
00409 {
00410   itkDebugMacro("setting WorldGeometry to " << geometry);
00411 
00412   if(m_WorldGeometry != geometry)
00413   {
00414     if(geometry->GetBoundingBox()->GetDiagonalLength2() == 0)
00415       return;
00416     
00417     m_WorldGeometry = geometry;
00418     m_TimeSlicedWorldGeometry=dynamic_cast<TimeSlicedGeometry*>(geometry);
00419     SlicedGeometry3D* slicedWorldGeometry;
00420     if(m_TimeSlicedWorldGeometry.IsNotNull())
00421     {
00422       itkDebugMacro("setting TimeSlicedWorldGeometry to " << m_TimeSlicedWorldGeometry);
00423       if(m_TimeStep >= m_TimeSlicedWorldGeometry->GetTimeSteps())
00424         m_TimeStep = m_TimeSlicedWorldGeometry->GetTimeSteps()-1;
00425       slicedWorldGeometry=dynamic_cast<SlicedGeometry3D*>(m_TimeSlicedWorldGeometry->GetGeometry3D(m_TimeStep));
00426     }
00427     else
00428     {
00429       slicedWorldGeometry=dynamic_cast<SlicedGeometry3D*>(geometry);
00430     }
00431     Geometry2D::Pointer geometry2d;
00432     if(slicedWorldGeometry!=NULL)
00433     {
00434       if(m_Slice >= slicedWorldGeometry->GetSlices() && (m_Slice != 0))
00435         m_Slice = slicedWorldGeometry->GetSlices()-1;
00436       geometry2d = slicedWorldGeometry->GetGeometry2D(m_Slice);
00437       if(geometry2d.IsNull())
00438       {
00439         PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
00440         plane->InitializeStandardPlane(slicedWorldGeometry);
00441         geometry2d = plane;
00442       }
00443       SetCurrentWorldGeometry(slicedWorldGeometry);
00444     }
00445     else
00446     {
00447       geometry2d=dynamic_cast<Geometry2D*>(geometry);
00448       if(geometry2d.IsNull())
00449       {
00450         PlaneGeometry::Pointer plane = PlaneGeometry::New();
00451         plane->InitializeStandardPlane(geometry);
00452         geometry2d = plane;
00453       }
00454       SetCurrentWorldGeometry(geometry);
00455     }
00456     SetCurrentWorldGeometry2D(geometry2d); // calls Modified()
00457   }
00458   if(m_CurrentWorldGeometry2D.IsNull())
00459     itkWarningMacro("m_CurrentWorldGeometry2D is NULL");
00460 }
00461 
00462 void mitk::BaseRenderer::SetDisplayGeometry(mitk::DisplayGeometry* geometry2d)
00463 {
00464   itkDebugMacro("setting DisplayGeometry to " << geometry2d);
00465   if (m_DisplayGeometry != geometry2d)
00466   {
00467     m_DisplayGeometry = geometry2d;
00468     m_DisplayGeometryData->SetGeometry2D(m_DisplayGeometry);
00469     m_DisplayGeometryUpdateTime.Modified();
00470     Modified();
00471   }
00472 }
00473 
00474 void mitk::BaseRenderer::SetCurrentWorldGeometry2D(mitk::Geometry2D* geometry2d)
00475 {
00476   if (m_CurrentWorldGeometry2D != geometry2d)
00477   {
00478     m_CurrentWorldGeometry2D = geometry2d;
00479     m_CurrentWorldGeometry2DData->SetGeometry2D(m_CurrentWorldGeometry2D);
00480     m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldGeometry2D);
00481     m_CurrentWorldGeometry2DUpdateTime.Modified();
00482     Modified();
00483   }
00484 }
00485 
00486 void mitk::BaseRenderer::SendUpdateSlice()
00487 {
00488   m_DisplayGeometryUpdateTime.Modified();
00489   m_CurrentWorldGeometry2DUpdateTime.Modified();
00490 }
00491 
00492 void mitk::BaseRenderer::SetCurrentWorldGeometry(mitk::Geometry3D* geometry)
00493 {
00494   m_CurrentWorldGeometry = geometry;
00495   if(geometry == NULL)
00496   {
00497     m_Bounds[0] = 0;
00498     m_Bounds[1] = 0;
00499     m_Bounds[2] = 0;
00500     m_Bounds[3] = 0;
00501     m_Bounds[4] = 0;
00502     m_Bounds[5] = 0;
00503     m_EmptyWorldGeometry = true;
00504     return;
00505   }
00506   BoundingBox::Pointer boundingBox = 
00507     m_CurrentWorldGeometry->CalculateBoundingBoxRelativeToTransform(NULL);
00508   const BoundingBox::BoundsArrayType& worldBounds = boundingBox->GetBounds();
00509   m_Bounds[0] = worldBounds[0];
00510   m_Bounds[1] = worldBounds[1];
00511   m_Bounds[2] = worldBounds[2];
00512   m_Bounds[3] = worldBounds[3];
00513   m_Bounds[4] = worldBounds[4];
00514   m_Bounds[5] = worldBounds[5];
00515   if(boundingBox->GetDiagonalLength2()<=mitk::eps)
00516     m_EmptyWorldGeometry = true;
00517   else
00518     m_EmptyWorldGeometry = false;
00519 }
00520 
00521 void mitk::BaseRenderer::SetGeometry(const itk::EventObject & geometrySendEvent)
00522 {
00523   const SliceNavigationController::GeometrySendEvent* sendEvent =
00524     dynamic_cast<const SliceNavigationController::GeometrySendEvent *>(&geometrySendEvent);
00525 
00526   assert(sendEvent!=NULL);
00527   SetWorldGeometry(sendEvent ->GetTimeSlicedGeometry());
00528 }
00529 
00530 void mitk::BaseRenderer::UpdateGeometry(const itk::EventObject & geometryUpdateEvent)
00531 {
00532   const SliceNavigationController::GeometryUpdateEvent* updateEvent =
00533     dynamic_cast<const SliceNavigationController::GeometryUpdateEvent*>(&geometryUpdateEvent);
00534 
00535   if (updateEvent==NULL) return;
00536 
00537   if (m_CurrentWorldGeometry.IsNotNull())
00538   {
00539     SlicedGeometry3D* slicedWorldGeometry=dynamic_cast<SlicedGeometry3D*>(m_CurrentWorldGeometry.GetPointer());
00540     if (slicedWorldGeometry)
00541     {
00542       Geometry2D* geometry2D = slicedWorldGeometry->GetGeometry2D(m_Slice);
00543     
00544       SetCurrentWorldGeometry2D(geometry2D); // calls Modified()
00545     }
00546   }
00547 }
00548 
00549 void mitk::BaseRenderer::SetGeometrySlice(const itk::EventObject & geometrySliceEvent)
00550 {
00551   const SliceNavigationController::GeometrySliceEvent* sliceEvent =
00552     dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(&geometrySliceEvent);
00553 
00554   assert(sliceEvent!=NULL);
00555   SetSlice(sliceEvent->GetPos());
00556 }
00557 
00558 void mitk::BaseRenderer::SetGeometryTime(const itk::EventObject & geometryTimeEvent)
00559 {
00560   const SliceNavigationController::GeometryTimeEvent * timeEvent =
00561     dynamic_cast<const SliceNavigationController::GeometryTimeEvent *>(&geometryTimeEvent);
00562 
00563   assert(timeEvent!=NULL);
00564   SetTimeStep(timeEvent->GetPos());
00565 }
00566 
00567 const double* mitk::BaseRenderer::GetBounds() const
00568 {
00569   return m_Bounds;
00570 }
00571 
00572 
00573 void mitk::BaseRenderer::MousePressEvent(mitk::MouseEvent *me)
00574 {
00575   //set the Focus on the renderer
00576   /*bool success =*/ m_RenderingManager->GetGlobalInteraction()->SetFocus(this);
00577   /*
00578   if (! success) 
00579     mitk::StatusBar::GetInstance()->DisplayText("Warning! from mitkBaseRenderer.cpp: Couldn't focus this BaseRenderer!");
00580   */
00581 
00582   //if (m_CameraController)
00583   //{
00584   //  if(me->GetButtonState()!=512) // provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
00585   //    m_CameraController->MousePressEvent(me);
00586   //}
00587   if(m_MapperID==1)
00588   {
00589     Point2D p(me->GetDisplayPosition());
00590     Point2D p_mm;
00591     Point3D position;
00592     GetDisplayGeometry()->ULDisplayToDisplay(p,p);
00593     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
00594     GetDisplayGeometry()->Map(p_mm, position);
00595     mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
00596     mitk::EventMapper::MapEvent( &event, m_RenderingManager->GetGlobalInteraction() );
00597   }
00598   else if(m_MapperID>1)//==2 for 3D and ==5 for stencil
00599   {
00600     Point2D p(me->GetDisplayPosition());
00601 
00602     GetDisplayGeometry()->ULDisplayToDisplay(p,p);
00603     me->SetDisplayPosition(p);
00604     mitk::EventMapper::MapEvent( me, m_RenderingManager->GetGlobalInteraction() );
00605   }
00606 }
00607 
00608 void mitk::BaseRenderer::MouseReleaseEvent(mitk::MouseEvent *me)
00609 {
00610 
00611   //if (m_CameraController)
00612   //{
00613   //  if(me->GetButtonState()!=512) // provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
00614   //    m_CameraController->MouseReleaseEvent(me);
00615   //}
00616 
00617   if(m_MapperID==1)
00618   {
00619     Point2D p(me->GetDisplayPosition());
00620     Point2D p_mm;
00621     Point3D position;
00622     GetDisplayGeometry()->ULDisplayToDisplay(p,p);
00623     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
00624     GetDisplayGeometry()->Map(p_mm, position);
00625     mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
00626     mitk::EventMapper::MapEvent( &event, m_RenderingManager->GetGlobalInteraction() );
00627   }
00628   else if(m_MapperID==2)
00629   {
00630     Point2D p(me->GetDisplayPosition());
00631     GetDisplayGeometry()->ULDisplayToDisplay(p,p);
00632     me->SetDisplayPosition(p);
00633     mitk::EventMapper::MapEvent( me, m_RenderingManager->GetGlobalInteraction() );
00634   }
00635 }
00636 
00637 void mitk::BaseRenderer::MouseMoveEvent(mitk::MouseEvent *me)
00638 {
00639   //if (m_CameraController)
00640   //{
00641   //  if((me->GetButtonState()<=512) || (me->GetButtonState()>=516))// provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
00642   //    m_CameraController->MouseMoveEvent(me);
00643   //}
00644   if(m_MapperID==1)
00645   {
00646     Point2D p(me->GetDisplayPosition());
00647     Point2D p_mm;
00648     Point3D position;
00649     GetDisplayGeometry()->ULDisplayToDisplay(p,p);
00650     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
00651     GetDisplayGeometry()->Map(p_mm, position);
00652     mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
00653     mitk::EventMapper::MapEvent( &event, m_RenderingManager->GetGlobalInteraction() );
00654   }
00655   else if(m_MapperID==2)
00656   {
00657     Point2D p(me->GetDisplayPosition());
00658     GetDisplayGeometry()->ULDisplayToDisplay(p,p);
00659     me->SetDisplayPosition(p);
00660     mitk::EventMapper::MapEvent( me, m_RenderingManager->GetGlobalInteraction() );
00661   }
00662 }
00663 
00664 void mitk::BaseRenderer::PickWorldPoint(const mitk::Point2D& displayPoint, mitk::Point3D& worldPoint) const
00665 {
00666   mitk::Point2D worldPoint2D;
00667   GetDisplayGeometry()->DisplayToWorld(displayPoint, worldPoint2D);
00668   GetDisplayGeometry()->Map(worldPoint2D, worldPoint);
00669 }
00670 
00671 void mitk::BaseRenderer::WheelEvent(mitk::WheelEvent * we)
00672 {
00673   if(m_MapperID==1)
00674   {
00675     Point2D p(we->GetDisplayPosition());
00676     Point2D p_mm;
00677     Point3D position;
00678     GetDisplayGeometry()->ULDisplayToDisplay(p,p);
00679     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
00680     GetDisplayGeometry()->Map(p_mm, position);
00681     mitk::PositionEvent event(this, we->GetType(), we->GetButton(), we->GetButtonState(), mitk::Key_unknown, p, position);
00682     mitk::EventMapper::MapEvent( &event, m_RenderingManager->GetGlobalInteraction() );
00683   }
00684   else if(m_MapperID==2)
00685   {
00686     Point2D p(we->GetDisplayPosition());
00687     GetDisplayGeometry()->ULDisplayToDisplay(p,p);
00688     we->SetDisplayPosition(p);
00689     mitk::EventMapper::MapEvent( we, m_RenderingManager->GetGlobalInteraction() );
00690   }
00691 }
00692 
00693 void mitk::BaseRenderer::KeyPressEvent(mitk::KeyEvent *ke)
00694 {
00695   if(m_MapperID==1)
00696   {
00697     Point2D p(ke->GetDisplayPosition());
00698     Point2D p_mm;
00699     Point3D position;
00700     GetDisplayGeometry()->ULDisplayToDisplay(p,p);
00701     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
00702     GetDisplayGeometry()->Map(p_mm, position);
00703     mitk::KeyEvent event(this, ke->GetType(), ke->GetButton(), ke->GetButtonState(), ke->GetKey(), ke->GetText(), p);
00704     mitk::EventMapper::MapEvent( &event, m_RenderingManager->GetGlobalInteraction() );
00705   }
00706   else if(m_MapperID==2)
00707   {
00708     Point2D p(ke->GetDisplayPosition());
00709     GetDisplayGeometry()->ULDisplayToDisplay(p,p);
00710     ke->SetDisplayPosition(p);
00711     mitk::EventMapper::MapEvent( ke, m_RenderingManager->GetGlobalInteraction() );
00712   }
00713 }
00714 
00715 void mitk::BaseRenderer::DrawOverlayMouse(mitk::Point2D& itkNotUsed(p2d))
00716 {
00717   MITK_INFO<<"BaseRenderer::DrawOverlayMouse()- should be inconcret implementation OpenGLRenderer."<<std::endl;
00718 }
00719 
00720 void mitk::BaseRenderer::RequestUpdate()
00721 {
00722   m_RenderingManager->RequestUpdate(this->m_RenderWindow);
00723 }
00724 
00725 void mitk::BaseRenderer::ForceImmediateUpdate()
00726 {
00727   m_RenderingManager->ForceImmediateUpdate(this->m_RenderWindow);
00728 }
00729 
00730 
00731 unsigned int mitk::BaseRenderer::GetNumberOfVisibleLODEnabledMappers() const
00732 {
00733   return m_NumberOfVisibleLODEnabledMappers;
00734 }
00735 
00736 
00737 mitk::RenderingManager* mitk::BaseRenderer::GetRenderingManager() const
00738 {
00739   return m_RenderingManager.GetPointer();
00740 }
00741 
00742 
00746 void mitk::BaseRenderer::SetSliceNavigationController(mitk::SliceNavigationController *SlicenavigationController)
00747 {
00748   if (SlicenavigationController == NULL)
00749     return;
00750 
00751   //disconnect old from globalinteraction
00752   m_RenderingManager->GetGlobalInteraction()->RemoveListener(SlicenavigationController);
00753   
00754   //copy worldgeometry
00755   SlicenavigationController->SetInputWorldGeometry( SlicenavigationController->GetCreatedWorldGeometry() );
00756   SlicenavigationController->Update();
00757 
00758     
00759   //set new 
00760   m_SliceNavigationController = SlicenavigationController;
00761   m_SliceNavigationController->SetRenderer( this );
00762 
00763   if (m_SliceNavigationController.IsNotNull())
00764   {  
00765     m_SliceNavigationController->ConnectGeometrySliceEvent( this );
00766     m_SliceNavigationController->ConnectGeometryUpdateEvent( this );
00767     m_SliceNavigationController->ConnectGeometryTimeEvent( this, false );
00768   }
00769 
00770  
00771 }
00772 
00773 
00777 void mitk::BaseRenderer::SetCameraController(CameraController* cameraController)
00778 {
00779   mitk::VtkInteractorCameraController::Pointer vtkInteractorCameraController = dynamic_cast<mitk::VtkInteractorCameraController*>(cameraController);
00780   if (vtkInteractorCameraController.IsNotNull())
00781     MITK_INFO<<"!!!WARNING!!!: RenderWindow interaction events are no longer handled via CameraController (See Bug #954)."<<std::endl;
00782   m_CameraController->SetRenderer(NULL);
00783   m_CameraController = NULL;
00784   m_CameraController = cameraController;
00785   m_CameraController->SetRenderer(this);
00786 }
00787 
00788 void mitk::BaseRenderer::PrintSelf(std::ostream& os, itk::Indent indent) const
00789 {
00790   os << indent << " MapperID: " << m_MapperID << std::endl;
00791   os << indent << " Slice: " << m_Slice << std::endl;
00792   os << indent << " TimeStep: " << m_TimeStep << std::endl;
00793 
00794   os << indent << " WorldGeometry: ";
00795   if(m_WorldGeometry.IsNull())
00796     os << "NULL" << std::endl;
00797   else
00798     m_WorldGeometry->Print(os, indent);
00799 
00800   os << indent << " CurrentWorldGeometry2D: ";
00801   if(m_CurrentWorldGeometry2D.IsNull())
00802     os << "NULL" << std::endl;
00803   else
00804     m_CurrentWorldGeometry2D->Print(os, indent);
00805 
00806   os << indent << " CurrentWorldGeometry2DUpdateTime: " << m_CurrentWorldGeometry2DUpdateTime << std::endl;
00807   os << indent << " CurrentWorldGeometry2DTransformTime: " << m_CurrentWorldGeometry2DTransformTime << std::endl;
00808 
00809   os << indent << " DisplayGeometry: ";
00810   if(m_DisplayGeometry.IsNull())
00811     os << "NULL" << std::endl;
00812   else
00813     m_DisplayGeometry->Print(os, indent);
00814 
00815   os << indent << " DisplayGeometryTransformTime: " << m_DisplayGeometryTransformTime << std::endl;
00816   Superclass::PrintSelf(os,indent);
00817 }
00818 
00819 void mitk::BaseRenderer::SetDepthPeelingEnabled( bool enabled )
00820 {
00821   m_DepthPeelingEnabled = enabled;
00822 #if ( ( VTK_MAJOR_VERSION >= 5 ) && ( VTK_MINOR_VERSION>=2)  )
00823   m_VtkRenderer->SetUseDepthPeeling(enabled);
00824 #endif
00825 }
00826 
00827 void mitk::BaseRenderer::SetMaxNumberOfPeels( int maxNumber )
00828 {
00829   m_MaxNumberOfPeels = maxNumber;
00830 #if ( ( VTK_MAJOR_VERSION >= 5 ) && ( VTK_MINOR_VERSION>=2)  )
00831   m_VtkRenderer->SetMaximumNumberOfPeels(maxNumber);
00832 #endif
00833 }
00834