00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #include "mitkRenderingManager.h"
00019 #include "mitkRenderingManagerFactory.h"
00020 #include "mitkBaseRenderer.h"
00021 #include "mitkGlobalInteraction.h"
00022
00023 #include <vtkRenderWindow.h>
00024
00025 #include <itkCommand.h>
00026 #include "mitkVector.h"
00027 #include <itkAffineGeometryFrame.h>
00028 #include <itkScalableAffineTransform.h>
00029
00030 #include <algorithm>
00031
00032 namespace mitk
00033 {
00034
00035 RenderingManager::Pointer RenderingManager::s_Instance = 0;
00036 RenderingManagerFactory *RenderingManager::s_RenderingManagerFactory = 0;
00037
00038
00039 RenderingManager
00040 ::RenderingManager()
00041 : m_UpdatePending( false ),
00042 m_MaxLOD( 1 ),
00043 m_LODIncreaseBlocked( false ),
00044 m_LODAbortMechanismEnabled( false ),
00045 m_ClippingPlaneEnabled( false ),
00046 m_TimeNavigationController( NULL ),
00047 m_DataStorage( NULL )
00048 {
00049 m_ShadingEnabled.assign( 3, false );
00050 m_ShadingValues.assign( 4, 0.0 );
00051
00052 m_GlobalInteraction = mitk::GlobalInteraction::GetInstance();
00053
00054 InitializePropertyList();
00055 }
00056
00057
00058 RenderingManager
00059 ::~RenderingManager()
00060 {
00061
00062
00063 RenderWindowVector::iterator it;
00064 for ( it = m_AllRenderWindows.begin(); it != m_AllRenderWindows.end(); ++it )
00065 {
00066 (*it)->UnRegister( NULL );
00067
00068 RenderWindowCallbacksList::iterator callbacks_it = this->m_RenderWindowCallbacksList.find(*it);
00069
00070 (*it)->RemoveObserver(callbacks_it->second.commands[0u]);
00071 (*it)->RemoveObserver(callbacks_it->second.commands[1u]);
00072 (*it)->RemoveObserver(callbacks_it->second.commands[2u]);
00073 }
00074 }
00075
00076
00077 void
00078 RenderingManager
00079 ::SetFactory( RenderingManagerFactory *factory )
00080 {
00081 s_RenderingManagerFactory = factory;
00082 }
00083
00084
00085 const RenderingManagerFactory *
00086 RenderingManager
00087 ::GetFactory()
00088 {
00089 return s_RenderingManagerFactory;
00090 }
00091
00092
00093 bool
00094 RenderingManager
00095 ::HasFactory()
00096 {
00097 if ( RenderingManager::s_RenderingManagerFactory )
00098 {
00099 return true;
00100 }
00101 else
00102 {
00103 return false;
00104 }
00105 }
00106
00107
00108 RenderingManager::Pointer
00109 RenderingManager
00110 ::New()
00111 {
00112 const RenderingManagerFactory* factory = GetFactory();
00113 if(factory == NULL)
00114 return NULL;
00115 return factory->CreateRenderingManager();
00116 }
00117
00118 RenderingManager *
00119 RenderingManager
00120 ::GetInstance()
00121 {
00122 if ( !RenderingManager::s_Instance )
00123 {
00124 if ( s_RenderingManagerFactory )
00125 {
00126 s_Instance = s_RenderingManagerFactory->CreateRenderingManager();
00127 }
00128 }
00129
00130 return s_Instance;
00131 }
00132
00133
00134 bool
00135 RenderingManager
00136 ::IsInstantiated()
00137 {
00138 if ( RenderingManager::s_Instance )
00139 return true;
00140 else
00141 return false;
00142 }
00143
00144
00145 void
00146 RenderingManager
00147 ::AddRenderWindow( vtkRenderWindow *renderWindow )
00148 {
00149 if ( renderWindow
00150 && (m_RenderWindowList.find( renderWindow ) == m_RenderWindowList.end()) )
00151 {
00152 m_RenderWindowList[renderWindow] = RENDERING_INACTIVE;
00153 m_AllRenderWindows.push_back( renderWindow );
00154
00155 if ( m_DataStorage.IsNotNull() )
00156 mitk::BaseRenderer::GetInstance( renderWindow )->SetDataStorage( m_DataStorage.GetPointer() );
00157
00158
00159 renderWindow->Register( NULL );
00160
00161 typedef itk::MemberCommand< RenderingManager > MemberCommandType;
00162
00163
00164
00165 vtkCallbackCommand *startCallbackCommand = vtkCallbackCommand::New();
00166 startCallbackCommand->SetCallback(
00167 RenderingManager::RenderingStartCallback );
00168 renderWindow->AddObserver( vtkCommand::StartEvent, startCallbackCommand );
00169
00170 vtkCallbackCommand *progressCallbackCommand = vtkCallbackCommand::New();
00171 progressCallbackCommand->SetCallback(
00172 RenderingManager::RenderingProgressCallback );
00173 renderWindow->AddObserver( vtkCommand::AbortCheckEvent, progressCallbackCommand );
00174
00175 vtkCallbackCommand *endCallbackCommand = vtkCallbackCommand::New();
00176 endCallbackCommand->SetCallback(
00177 RenderingManager::RenderingEndCallback );
00178 renderWindow->AddObserver( vtkCommand::EndEvent, endCallbackCommand );
00179
00180 RenderWindowCallbacks callbacks;
00181
00182 callbacks.commands[0u] = startCallbackCommand;
00183 callbacks.commands[1u] = progressCallbackCommand;
00184 callbacks.commands[2u] = endCallbackCommand;
00185 this->m_RenderWindowCallbacksList[renderWindow] = callbacks;
00186
00187
00188 startCallbackCommand->Delete();
00189 progressCallbackCommand->Delete();
00190 endCallbackCommand->Delete();
00191
00192 }
00193 }
00194
00195
00196 void
00197 RenderingManager
00198 ::RemoveRenderWindow( vtkRenderWindow *renderWindow )
00199 {
00200 if (m_RenderWindowList.erase( renderWindow ))
00201 {
00202 RenderWindowCallbacksList::iterator callbacks_it = this->m_RenderWindowCallbacksList.find(renderWindow);
00203
00204 renderWindow->RemoveObserver(callbacks_it->second.commands[0u]);
00205 renderWindow->RemoveObserver(callbacks_it->second.commands[1u]);
00206 renderWindow->RemoveObserver(callbacks_it->second.commands[2u]);
00207 this->m_RenderWindowCallbacksList.erase(callbacks_it);
00208
00209 RenderWindowVector::iterator rw_it = std::find( m_AllRenderWindows.begin(), m_AllRenderWindows.end(), renderWindow );
00210
00211
00212 (*rw_it)->UnRegister(NULL);
00213 m_AllRenderWindows.erase( rw_it );
00214 }
00215 }
00216
00217
00218 const RenderingManager::RenderWindowVector&
00219 RenderingManager
00220 ::GetAllRegisteredRenderWindows()
00221 {
00222 return m_AllRenderWindows;
00223 }
00224
00225
00226 void
00227 RenderingManager
00228 ::RequestUpdate( vtkRenderWindow *renderWindow )
00229 {
00230 m_RenderWindowList[renderWindow] = RENDERING_REQUESTED;
00231
00232 if ( !m_UpdatePending )
00233 {
00234 m_UpdatePending = true;
00235 this->GenerateRenderingRequestEvent();
00236 }
00237 }
00238
00239
00240 void
00241 RenderingManager
00242 ::ForceImmediateUpdate( vtkRenderWindow *renderWindow )
00243 {
00244
00245 m_RenderWindowList[renderWindow] = RENDERING_INACTIVE;
00246
00247 m_UpdatePending = false;
00248
00249
00250
00251 int *size = renderWindow->GetSize();
00252 if ( 0 != size[0] && 0 != size[1] )
00253 {
00254
00255 renderWindow->Render();
00256 }
00257 }
00258
00259
00260 void
00261 RenderingManager
00262 ::RequestUpdateAll( RequestType type )
00263 {
00264 RenderWindowList::iterator it;
00265 for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
00266 {
00267 int id = BaseRenderer::GetInstance(it->first)->GetMapperID();
00268 if ( (type == REQUEST_UPDATE_ALL)
00269 || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
00270 || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
00271 {
00272 this->RequestUpdate( it->first );
00273 }
00274 }
00275 }
00276
00277
00278 void
00279 RenderingManager
00280 ::ForceImmediateUpdateAll( RequestType type )
00281 {
00282 RenderWindowList::iterator it;
00283 for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
00284 {
00285 int id = BaseRenderer::GetInstance(it->first)->GetMapperID();
00286 if ( (type == REQUEST_UPDATE_ALL)
00287 || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
00288 || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
00289 {
00290
00291
00292
00293
00294 int *size = it->first->GetSize();
00295 if ( 0 != size[0] && 0 != size[1] )
00296 {
00297
00298 it->first->Render();
00299 }
00300
00301 it->second = RENDERING_INACTIVE;
00302 }
00303 }
00304
00305 m_UpdatePending = false;
00306 }
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343 bool
00344 RenderingManager
00345 ::InitializeViews( const Geometry3D * dataGeometry, RequestType type, bool preserveRoughOrientationInWorldSpace )
00346 {
00347 MITK_DEBUG << "initializing views";
00348
00349 bool boundingBoxInitialized = false;
00350
00351 Geometry3D::ConstPointer geometry = dataGeometry;
00352
00353 if (dataGeometry && preserveRoughOrientationInWorldSpace)
00354 {
00355
00356
00357 Geometry3D::Pointer modifiedGeometry = dynamic_cast<Geometry3D*>( dataGeometry->Clone().GetPointer() );
00358 assert(modifiedGeometry.IsNotNull());
00359
00360
00361 AffineGeometryFrame3D::TransformType::Pointer transform = AffineGeometryFrame3D::TransformType::New();
00362 assert( modifiedGeometry->GetIndexToWorldTransform() );
00363 transform->SetMatrix( modifiedGeometry->GetIndexToWorldTransform()->GetMatrix() );
00364 transform->SetOffset( modifiedGeometry->GetIndexToWorldTransform()->GetOffset() );
00365
00366
00367 AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType& oldMatrix =
00368 const_cast< AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType& > ( transform->GetMatrix().GetVnlMatrix() );
00369 AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType newMatrix(oldMatrix);
00370
00371
00372 Vector3D offset = modifiedGeometry->GetIndexToWorldTransform()->GetOffset();
00373 Geometry3D::BoundsArrayType oldBounds = modifiedGeometry->GetBounds();
00374 Geometry3D::BoundsArrayType newBounds = modifiedGeometry->GetBounds();
00375
00376
00377 for ( unsigned int i = 0; i < 3; ++i )
00378 {
00379
00380
00381 Vector3D currentVector;
00382 currentVector[0] = oldMatrix(0,i);
00383 currentVector[1] = oldMatrix(1,i);
00384 currentVector[2] = oldMatrix(2,i);
00385
00386
00387
00388 unsigned int matchingRow = 0;
00389
00390
00391 float max = std::numeric_limits<float>::min();
00392
00393
00394 int sign = 1;
00395
00396
00397 for (unsigned int dim = 0; dim < 3; ++dim)
00398 {
00399 if ( fabs(currentVector[dim]) > max )
00400 {
00401 matchingRow = dim;
00402 max = fabs(currentVector[dim]);
00403 if(currentVector[dim]<0)
00404 sign = -1;
00405 else
00406 sign = 1;
00407 }
00408 }
00409
00410
00411
00412
00413 if(sign == -1)
00414 {
00415 currentVector *= sign;
00416 offset += modifiedGeometry->GetAxisVector(i);
00417 }
00418
00419
00420
00421
00422 vnl_vector<ScalarType> newMatrixColumn(3);
00423 newMatrixColumn[0] = currentVector[0];
00424 newMatrixColumn[1] = currentVector[1];
00425 newMatrixColumn[2] = currentVector[2];
00426 newMatrix.set_column( matchingRow, newMatrixColumn );
00427
00428
00429
00430 newBounds[2*matchingRow ] = oldBounds[2*i ];
00431 newBounds[2*matchingRow+1] = oldBounds[2*i+1];
00432 }
00433
00434
00435 modifiedGeometry->SetBounds(newBounds);
00436
00437
00438 AffineGeometryFrame3D::TransformType::MatrixType newMatrixITK( newMatrix );
00439 transform->SetMatrix( newMatrixITK );
00440 transform->SetOffset( offset );
00441 modifiedGeometry->SetIndexToWorldTransform( transform );
00442 geometry = modifiedGeometry;
00443
00444 }
00445
00446
00447 int warningLevel = vtkObject::GetGlobalWarningDisplay();
00448 vtkObject::GlobalWarningDisplayOff();
00449
00450 if ( (geometry.IsNotNull() ) && (const_cast< mitk::BoundingBox * >(
00451 geometry->GetBoundingBox())->GetDiagonalLength2() > mitk::eps) )
00452 {
00453 boundingBoxInitialized = true;
00454 }
00455
00456 RenderWindowList::iterator it;
00457 for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
00458 {
00459 mitk::BaseRenderer *baseRenderer =
00460 mitk::BaseRenderer::GetInstance( it->first );
00461 int id = baseRenderer->GetMapperID();
00462 if ( ((type == REQUEST_UPDATE_ALL)
00463 || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
00464 || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)))
00465 )
00466 {
00467 this->InternalViewInitialization( baseRenderer, geometry,
00468 boundingBoxInitialized, id );
00469 }
00470 }
00471
00472 if ( m_TimeNavigationController != NULL )
00473 {
00474 if ( boundingBoxInitialized )
00475 {
00476 m_TimeNavigationController->SetInputWorldGeometry( geometry );
00477 }
00478 m_TimeNavigationController->Update();
00479 }
00480
00481 this->RequestUpdateAll( type );
00482
00483 vtkObject::SetGlobalWarningDisplay( warningLevel );
00484
00485
00486 this->InvokeEvent( mitk::RenderingManagerViewsInitializedEvent() );
00487
00488
00489 return boundingBoxInitialized;
00490 }
00491
00492
00493 bool
00494 RenderingManager
00495 ::InitializeViews( RequestType type )
00496 {
00497 RenderWindowList::iterator it;
00498 for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
00499 {
00500 mitk::BaseRenderer *baseRenderer =
00501 mitk::BaseRenderer::GetInstance( it->first );
00502 int id = baseRenderer->GetMapperID();
00503 if ( (type == REQUEST_UPDATE_ALL)
00504 || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
00505 || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
00506 {
00507
00508 mitk::SliceNavigationController *nc =
00509
00510 baseRenderer->GetSliceNavigationController();
00511
00512
00513 nc->SetViewDirectionToDefault();
00514
00515
00516 nc->Update();
00517 }
00518 }
00519
00520 this->RequestUpdateAll( type );
00521
00522 return true;
00523 }
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559 bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow, const Geometry3D * geometry, bool initializeGlobalTimeSNC )
00560 {
00561 bool boundingBoxInitialized = false;
00562
00563 int warningLevel = vtkObject::GetGlobalWarningDisplay();
00564 vtkObject::GlobalWarningDisplayOff();
00565
00566 if ( (geometry != NULL ) && (const_cast< mitk::BoundingBox * >(
00567 geometry->GetBoundingBox())->GetDiagonalLength2() > mitk::eps) )
00568 {
00569 boundingBoxInitialized = true;
00570 }
00571
00572 mitk::BaseRenderer *baseRenderer =
00573 mitk::BaseRenderer::GetInstance( renderWindow );
00574
00575 int id = baseRenderer->GetMapperID();
00576
00577 this->InternalViewInitialization( baseRenderer, geometry,
00578 boundingBoxInitialized, id );
00579
00580 if ( m_TimeNavigationController != NULL )
00581 {
00582 if ( boundingBoxInitialized && initializeGlobalTimeSNC )
00583 {
00584 m_TimeNavigationController->SetInputWorldGeometry( geometry );
00585 }
00586 m_TimeNavigationController->Update();
00587 }
00588
00589 this->RequestUpdate( renderWindow );
00590
00591 vtkObject::SetGlobalWarningDisplay( warningLevel );
00592
00593 return boundingBoxInitialized;
00594 }
00595
00596
00597 bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow )
00598 {
00599 mitk::BaseRenderer *baseRenderer =
00600 mitk::BaseRenderer::GetInstance( renderWindow );
00601
00602 mitk::SliceNavigationController *nc =
00603 baseRenderer->GetSliceNavigationController();
00604
00605
00606 nc->SetViewDirectionToDefault();
00607
00608
00609 nc->Update();
00610
00611 this->RequestUpdate( renderWindow );
00612
00613 return true;
00614 }
00615
00616
00617 void RenderingManager::InternalViewInitialization(mitk::BaseRenderer *baseRenderer, const mitk::Geometry3D *geometry, bool boundingBoxInitialized, int mapperID )
00618 {
00619 mitk::SliceNavigationController *nc = baseRenderer->GetSliceNavigationController();
00620
00621
00622 nc->SetViewDirectionToDefault();
00623
00624 if ( boundingBoxInitialized )
00625 {
00626
00627 nc->SetInputWorldGeometry( geometry );
00628 nc->Update();
00629
00630 if ( mapperID == 1 )
00631 {
00632
00633
00634 nc->GetSlice()->SetPos( nc->GetSlice()->GetSteps() / 2 );
00635 }
00636
00637
00638 baseRenderer->GetDisplayGeometry()->Fit();
00639 baseRenderer->GetCameraController()->SetViewToAnterior();
00640 }
00641 else
00642 {
00643 nc->Update();
00644 }
00645 }
00646
00647
00648 void RenderingManager::SetTimeNavigationController( SliceNavigationController *nc )
00649 {
00650 m_TimeNavigationController = nc;
00651 }
00652
00653
00654 const SliceNavigationController* RenderingManager::GetTimeNavigationController() const
00655 {
00656 return m_TimeNavigationController;
00657 }
00658
00659
00660 SliceNavigationController* RenderingManager::GetTimeNavigationController()
00661 {
00662 return m_TimeNavigationController;
00663 }
00664
00665
00666 void RenderingManager::ExecutePendingRequests()
00667 {
00668 m_UpdatePending = false;
00669
00670
00671 RenderWindowList::iterator it;
00672 int i = 0;
00673 for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it, ++i )
00674 {
00675 if ( it->second == RENDERING_REQUESTED )
00676 {
00677 this->ForceImmediateUpdate( it->first );
00678 }
00679 }
00680 }
00681
00682
00683 void RenderingManager::RenderingStartCallback( vtkObject *caller, unsigned long , void *, void * )
00684 {
00685 vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
00686 mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
00687 RenderWindowList &renderWindowList = renman->m_RenderWindowList;
00688
00689 if ( renderWindow )
00690 {
00691 renderWindowList[renderWindow] = RENDERING_INPROGRESS;
00692 }
00693
00694 renman->m_UpdatePending = false;
00695 }
00696
00697
00698 void
00699 RenderingManager
00700 ::RenderingProgressCallback( vtkObject *caller, unsigned long , void *, void * )
00701 {
00702 vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
00703 mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
00704
00705 if ( renman->m_LODAbortMechanismEnabled )
00706 {
00707 vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
00708 if ( renderWindow )
00709 {
00710 BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
00711 if ( renderer && (renderer->GetNumberOfVisibleLODEnabledMappers() > 0) )
00712 {
00713 renman->DoMonitorRendering();
00714 }
00715 }
00716 }
00717 }
00718
00719 void
00720 RenderingManager
00721 ::RenderingEndCallback( vtkObject *caller, unsigned long , void *, void * )
00722 {
00723 vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
00724 mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
00725
00726 RenderWindowList &renderWindowList = renman->m_RenderWindowList;
00727 RendererBoolMap &renderingAbortedMap = renman->m_RenderingAbortedMap;
00728 RendererIntMap &nextLODMap = renman->m_NextLODMap;
00729 unsigned int &maxLOD = renman->m_MaxLOD;
00730 bool &lodIncreaseBlocked = renman->m_LODIncreaseBlocked;
00731
00732
00733 if ( renderWindow )
00734 {
00735 BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
00736 if ( renderer )
00737 {
00738 renderWindowList[renderer->GetRenderWindow()] = RENDERING_INACTIVE;
00739
00740
00741 if ( renderer->GetNumberOfVisibleLODEnabledMappers() > 0 )
00742 {
00743 bool newRenderingRequest = false;
00744
00745
00746 if ( renderingAbortedMap[renderer] )
00747 {
00748
00749 renderingAbortedMap[renderer] = false;
00750 nextLODMap[renderer] = 0;
00751 newRenderingRequest = true;
00752 }
00753 else
00754 {
00755
00756
00757 if ( !lodIncreaseBlocked )
00758 {
00759
00760 if ( nextLODMap[renderer] < maxLOD )
00761 {
00762
00763 nextLODMap[renderer]++;
00764
00765
00766 newRenderingRequest = true;
00767 }
00768 else
00769 {
00770
00771 nextLODMap[renderer] = 0;
00772 }
00773 }
00774 }
00775
00776
00777 mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
00778
00779
00780 renman->DoFinishAbortRendering();
00781
00782
00783
00784 if ( newRenderingRequest )
00785 {
00786 renman->RequestUpdate( renderer->GetRenderWindow() );
00787 }
00788 }
00789 }
00790 }
00791 }
00792
00793
00794 bool
00795 RenderingManager
00796 ::IsRendering() const
00797 {
00798 RenderWindowList::const_iterator it;
00799 for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
00800 {
00801 if ( it->second == RENDERING_INPROGRESS )
00802 {
00803 return true;
00804 }
00805 }
00806 return false;
00807 }
00808
00809
00810 void
00811 RenderingManager
00812 ::AbortRendering()
00813 {
00814 RenderWindowList::iterator it;
00815 for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
00816 {
00817 if ( it->second == RENDERING_INPROGRESS )
00818 {
00819 it->first->SetAbortRender( true );
00820 m_RenderingAbortedMap[BaseRenderer::GetInstance(it->first)] = true;
00821 }
00822 }
00823 }
00824
00825
00826 int
00827 RenderingManager
00828 ::GetNextLOD( BaseRenderer *renderer )
00829 {
00830 if ( renderer != NULL )
00831 {
00832 return m_NextLODMap[renderer];
00833 }
00834 else
00835 {
00836 return 0;
00837 }
00838 }
00839
00840
00841 void
00842 RenderingManager
00843 ::SetNextLOD( unsigned int lod, BaseRenderer *renderer )
00844 {
00845 unsigned int newLOD = lod < m_MaxLOD ? lod : m_MaxLOD;
00846
00847 if ( renderer != NULL )
00848 {
00849 m_NextLODMap[renderer] = newLOD;
00850 }
00851 else
00852 {
00853
00854 RenderWindowList::iterator it;
00855 for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
00856 {
00857 m_NextLODMap[BaseRenderer::GetInstance( it->first )] = newLOD;
00858 }
00859 }
00860 }
00861
00862
00863 void
00864 RenderingManager
00865 ::SetMaximumLOD( unsigned int max )
00866 {
00867 m_MaxLOD = max;
00868 }
00869
00870
00871
00872 void
00873 RenderingManager
00874 ::SetShading(bool state, unsigned int lod)
00875 {
00876 if(lod>m_MaxLOD)
00877 {
00878 itkWarningMacro(<<"LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD);
00879 return;
00880 }
00881 m_ShadingEnabled[lod] = state;
00882
00883 }
00884
00885 bool
00886 RenderingManager
00887 ::GetShading(unsigned int lod)
00888 {
00889 if(lod>m_MaxLOD)
00890 {
00891 itkWarningMacro(<<"LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD);
00892 return false;
00893 }
00894 return m_ShadingEnabled[lod];
00895 }
00896
00897
00898
00899 void
00900 RenderingManager
00901 ::SetClippingPlaneStatus(bool status)
00902 {
00903 m_ClippingPlaneEnabled = status;
00904 }
00905
00906
00907 bool
00908 RenderingManager
00909 ::GetClippingPlaneStatus()
00910 {
00911 return m_ClippingPlaneEnabled;
00912 }
00913
00914
00915 void
00916 RenderingManager
00917 ::SetShadingValues(float ambient, float diffuse, float specular, float specpower)
00918 {
00919 m_ShadingValues[0] = ambient;
00920 m_ShadingValues[1] = diffuse;
00921 m_ShadingValues[2] = specular;
00922 m_ShadingValues[3] = specpower;
00923 }
00924
00925
00926 RenderingManager::FloatVector &
00927 RenderingManager
00928 ::GetShadingValues()
00929 {
00930 return m_ShadingValues;
00931 }
00932
00933 void RenderingManager::SetDepthPeelingEnabled( bool enabled )
00934 {
00935 RenderWindowList::iterator it;
00936 for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
00937 {
00938 mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance( it->first );
00939 baseRenderer->SetDepthPeelingEnabled(enabled);
00940 }
00941 }
00942
00943 void RenderingManager::SetMaxNumberOfPeels( int maxNumber )
00944 {
00945 RenderWindowList::iterator it;
00946 for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
00947 {
00948 mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance( it->first );
00949 baseRenderer->SetMaxNumberOfPeels(maxNumber);
00950 }
00951 }
00952
00953 void RenderingManager::InitializePropertyList()
00954 {
00955 if (m_PropertyList.IsNull())
00956 {
00957 m_PropertyList = PropertyList::New();
00958 }
00959
00960 this->SetProperty("coupled-zoom", BoolProperty::New(false));
00961 this->SetProperty("coupled-plane-rotation", BoolProperty::New(false));
00962 this->SetProperty("MIP-slice-rendering", BoolProperty::New(false));
00963 }
00964
00965 PropertyList::Pointer RenderingManager::GetPropertyList() const
00966 {
00967 return m_PropertyList;
00968 }
00969
00970 BaseProperty* RenderingManager::GetProperty(const char *propertyKey) const
00971 {
00972 return m_PropertyList->GetProperty(propertyKey);
00973 }
00974
00975 void RenderingManager::SetProperty(const char *propertyKey, BaseProperty* propertyValue)
00976 {
00977 m_PropertyList->SetProperty(propertyKey, propertyValue);
00978 }
00979
00980
00981 void RenderingManager::SetDataStorage( DataStorage* storage )
00982 {
00983 if ( storage != NULL )
00984 {
00985 m_DataStorage = storage;
00986
00987 RenderingManager::RenderWindowVector::iterator iter;
00988 for ( iter = m_AllRenderWindows.begin(); iter<m_AllRenderWindows.end(); iter++ )
00989 {
00990 mitk::BaseRenderer::GetInstance( (*iter) )->SetDataStorage( m_DataStorage.GetPointer() );
00991 }
00992 }
00993 }
00994
00995 mitk::DataStorage* RenderingManager::GetDataStorage()
00996 {
00997 return m_DataStorage;
00998 }
00999
01000
01001 void RenderingManager::SetGlobalInteraction( mitk::GlobalInteraction* globalInteraction )
01002 {
01003 if ( globalInteraction != NULL )
01004 {
01005 m_GlobalInteraction = globalInteraction;
01006 }
01007 }
01008
01009 mitk::GlobalInteraction* RenderingManager::GetGlobalInteraction()
01010 {
01011 return m_GlobalInteraction;
01012 }
01013
01014
01015 TestingRenderingManagerFactory renderingManagerFactory;
01016
01017
01018 }