mitk: QmitkMovieMaker.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: 16947 $
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 #include "QmitkMovieMaker.h"
00019 //#include "QmitkMovieMakerControls.h"
00020 #include "QmitkStepperAdapter.h"
00021 #include "QmitkStdMultiWidget.h"
00022 #include "QmitkCommonFunctionality.h"
00023 /*=========================================================================
00024 
00025  Program:   Medical Imaging & Interaction Toolkit
00026  Language:  C++
00027  Date:      $Date$
00028  Version:   $Revision: 16947 $
00029 
00030  Copyright (c) German Cancer Research Center, Division of Medical and
00031  Biological Informatics. All rights reserved.
00032  See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00033 
00034  This software is distributed WITHOUT ANY WARRANTY; without even
00035  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00036  PURPOSE.  See the above copyright notices for more information.
00037 
00038  =========================================================================*/
00039 
00040 #include "QmitkMovieMaker.h"
00041 //#include "QmitkMovieMakerControls.h"
00042 #include "QmitkStepperAdapter.h"
00043 #include "QmitkStdMultiWidget.h"
00044 #include "QmitkCommonFunctionality.h"
00045 
00046 #include "mitkVtkPropRenderer.h"
00047 #include "mitkGlobalInteraction.h"
00048 
00049 #include <iostream>
00050 
00051 #include <vtkRenderer.h>
00052 #include <vtkCamera.h>
00053 
00054 #include <qaction.h>
00055 #include <qfiledialog.h>
00056 #include <qtimer.h>
00057 #include <qdatetime.h>
00058 #include <qspinbox.h>
00059 #include <qcombobox.h>
00060 
00061 #include "qapplication.h"
00062 
00063 #include "vtkImageWriter.h"
00064 #include "vtkJPEGWriter.h"
00065 #include "vtkPNGWriter.h"
00066 #include "vtkRenderLargeImage.h"
00067 #include "vtkRenderWindowInteractor.h"
00068 #include "vtkRenderer.h"
00069 #include "vtkTestUtilities.h"
00070 
00071 #include <vtkActor.h>
00072 #include "vtkMitkRenderProp.h"
00073 
00074 #include <vtkRenderer.h>
00075 #include <vtkRenderWindow.h>
00076 #include "vtkRenderWindowInteractor.h"
00077 #include <qradiobutton.h>
00078 
00079 QmitkMovieMaker::QmitkMovieMaker(QObject *parent, const char * /*name*/)
00080 
00081 :
00082   QmitkFunctionality(), m_Controls(NULL),
00083   m_StepperAdapter(NULL),
00084   m_FocusManagerCallback(0), m_Looping(true), m_Direction(0), m_Aspect(0)
00085 {
00086 
00087   parentWidget = parent;
00088 
00089   m_Timer = new QTimer(this);
00090   m_Time = new QTime();
00091 
00092   m_FocusManagerCallback = MemberCommand::New();
00093   m_FocusManagerCallback->SetCallbackFunction(this, &QmitkMovieMaker::FocusChange);
00094 
00095   m_movieGenerator = mitk::MovieGenerator::New();
00096 
00097   if (m_movieGenerator.IsNull())
00098   {
00099     MITK_ERROR << "Either mitk::MovieGenerator is not implemented for your";
00100     MITK_ERROR << " platform or an error occurred during";
00101     MITK_ERROR << " mitk::MovieGenerator::New()" ;
00102   }
00103 
00104 }
00105 
00106 QmitkMovieMaker::~QmitkMovieMaker()
00107 {
00108   delete m_StepperAdapter;
00109   delete m_Timer;
00110   delete m_Time;
00111   //delete m_RecordingRenderer;
00112 
00113 }
00114 
00115 mitk::BaseController* QmitkMovieMaker::GetSpatialController()
00116 {
00117   mitk::BaseRenderer* focusedRenderer = mitk::GlobalInteraction::GetInstance()->GetFocus();
00118 
00119   if (mitk::BaseRenderer::GetInstance(GetActiveStdMultiWidget()->mitkWidget1->GetRenderWindow())
00120       == focusedRenderer)
00121   {
00122     return GetActiveStdMultiWidget()->mitkWidget1->GetController();
00123   }
00124   else if (mitk::BaseRenderer::GetInstance(
00125       GetActiveStdMultiWidget()->mitkWidget2->GetRenderWindow()) == focusedRenderer)
00126   {
00127     return GetActiveStdMultiWidget()->mitkWidget2->GetController();
00128   }
00129   else if (mitk::BaseRenderer::GetInstance(
00130       GetActiveStdMultiWidget()->mitkWidget3->GetRenderWindow()) == focusedRenderer)
00131   {
00132     return GetActiveStdMultiWidget()->mitkWidget3->GetController();
00133   }
00134   else if (mitk::BaseRenderer::GetInstance(
00135       GetActiveStdMultiWidget()->mitkWidget4->GetRenderWindow()) == focusedRenderer)
00136   {
00137     return GetActiveStdMultiWidget()->mitkWidget4->GetController();
00138   }
00139 
00140   return GetActiveStdMultiWidget()->mitkWidget4->GetController();
00141 }
00142 
00143 mitk::BaseController* QmitkMovieMaker::GetTemporalController()
00144 {
00145   return GetActiveStdMultiWidget()->GetTimeNavigationController();
00146 }
00147 
00148 void QmitkMovieMaker::CreateConnections()
00149 {
00150   if (m_Controls)
00151   {
00152     // start / pause / stop playing
00153     connect((QObject*) m_Controls->btnPlay, SIGNAL(clicked()), (QObject*) this,
00154         SLOT(StartPlaying()));
00155     connect((QObject*) m_Controls->btnPause, SIGNAL(clicked()), this, SLOT(PausePlaying()));
00156     connect((QObject*) m_Controls->btnStop, SIGNAL(clicked()), this, SLOT(StopPlaying()));
00157 
00158     connect((QObject*) m_Controls->rbtnForward, SIGNAL(clicked()), this, SLOT(RBTNForward()));
00159     connect((QObject*) m_Controls->rbtnBackward, SIGNAL(clicked()), this, SLOT(RBTNBackward()));
00160     connect((QObject*) m_Controls->rbtnPingPong, SIGNAL(clicked()), this, SLOT(RBTNPingPong()));
00161 
00162     // radio button group: forward, backward, ping-pong
00163     connect( this, SIGNAL(SwitchDirection(int)), this, SLOT(SetDirection(int)) );
00164 
00165     // radio button group: spatial, temporal
00166     connect((QObject*) m_Controls->rbtnSpatial, SIGNAL(clicked()), this, SLOT(RBTNSpatial()));
00167     connect((QObject*) m_Controls->rbtnTemporal, SIGNAL(clicked()), this, SLOT(RBTNTemporal()));
00168     connect((QObject*) m_Controls->rbtnCombined, SIGNAL(clicked()), this, SLOT(RBTNCombined()));
00169     connect( this, SIGNAL(SwitchAspect(int)), this, SLOT(SetAspect(int)) );
00170 
00171     // stepper window selection
00172     connect((QObject*) (m_Controls->cmbSelectedStepperWindow), SIGNAL ( activated ( int) ), (QObject*) this, SLOT ( SetStepperWindow (int) ) );
00173 
00174     // recording window selection
00175     connect((QObject*) (m_Controls->cmbSelectedRecordingWindow), SIGNAL ( activated ( int) ), (QObject*) this, SLOT ( SetRecordingWindow (int) ) );
00176 
00177     // advance the animation
00178     // every timer tick
00179     connect((QObject*) m_Timer, SIGNAL(timeout()), this, SLOT(AdvanceAnimation()));
00180 
00181     // movie generation
00182     // when the movie button is clicked
00183     connect((QObject*) m_Controls->btnMovie, SIGNAL(clicked()), this, SLOT(GenerateMovie()));
00184 
00185     connect((QObject*) m_Controls->btnScreenshot, SIGNAL(clicked()), this, SLOT(
00186         GenerateScreenshot()));
00187     connect((QObject*) m_Controls->m_HRScreenshot, SIGNAL(clicked()), this, SLOT(
00188         GenerateHR3DScreenshot()));
00189 
00190     // blocking of ui elements during movie generation
00191     connect((QObject*) this, SIGNAL(StartBlockControls()), (QObject*) this, SLOT(BlockControls()));
00192 
00193     connect((QObject*) this, SIGNAL(EndBlockControls()), (QObject*) this, SLOT(UnBlockControls()));
00194 
00195     connect((QObject*) this, SIGNAL(EndBlockControlsMovieDeactive()), (QObject*) this, SLOT(
00196         UnBlockControlsMovieDeactive()));
00197 
00198     // allow for change of spatialtime relation
00199     connect((QObject*) m_Controls->spatialTimeRelation, SIGNAL(valueChanged ( int ) ), this, SLOT( DeleteMStepper() ) );
00200     
00201   }
00202 }
00203 
00204 void QmitkMovieMaker::Activated()
00205 {
00206   QmitkFunctionality::Activated();
00207 
00208   // create a member command that will be executed from the observer
00209   itk::SimpleMemberCommand<QmitkMovieMaker>::Pointer stepperChangedCommand;
00210   stepperChangedCommand = itk::SimpleMemberCommand<QmitkMovieMaker>::New();
00211   // set the callback function of the member command
00212   stepperChangedCommand->SetCallbackFunction(this, &QmitkMovieMaker::UpdateGUI);
00213   // add an observer to the data tree node pointer connected to the above member command
00214   MITK_INFO << "Add observer on insertion point node in NavigationPathController::AddObservers";
00215   m_StepperObserverTag = this->GetTemporalController()->GetTime()->AddObserver(
00216       itk::ModifiedEvent(), stepperChangedCommand);
00217 
00218   m_FocusManagerObserverTag
00219       = mitk::GlobalInteraction::GetInstance()->GetFocusManager()->AddObserver(mitk::FocusEvent(),
00220           m_FocusManagerCallback);
00221   this->UpdateGUI();
00222   // Initialize steppers etc.
00223   this->FocusChange();
00224 }
00225 
00226 void QmitkMovieMaker::Deactivated()
00227 {
00228   QmitkFunctionality::Deactivated();
00229   this->GetTemporalController()->GetTime()->RemoveObserver(m_StepperObserverTag);
00230   mitk::GlobalInteraction::GetInstance()->GetFocusManager()->RemoveObserver(
00231       m_FocusManagerObserverTag); // remove (if tag is invalid, nothing is removed)
00232 }
00233 
00234 void QmitkMovieMaker::FocusChange()
00235 {
00236   mitk::Stepper *stepper = this->GetAspectStepper();
00237   m_StepperAdapter->SetStepper(stepper);
00238 
00239   // Make the stepper movement non-inverted
00240   stepper->InverseDirectionOff();
00241 
00242   // Set stepping direction and aspect (spatial / temporal) for new stepper
00243   this->UpdateLooping();
00244   this->UpdateDirection();
00245 
00246   // Set newly focused window as active in "Selected Window" combo box
00247   const mitk::RenderingManager::RenderWindowVector rwv =
00248       mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
00249 
00250   int i;
00251   mitk::RenderingManager::RenderWindowVector::const_iterator iter;
00252   for (iter = rwv.begin(), i = 0; iter != rwv.end(); ++iter, ++i)
00253   {
00254     mitk::BaseRenderer* focusedRenderer =
00255         mitk::GlobalInteraction::GetInstance()->GetFocusManager()->GetFocused();
00256 
00257     if (focusedRenderer == mitk::BaseRenderer::GetInstance((*iter)))
00258     {
00259       m_Controls->cmbSelectedStepperWindow->setCurrentIndex(i);
00260       //      this->cmbSelectedStepperWindow_activated(i);
00261       this->SetStepperWindow(i);
00262       m_Controls->cmbSelectedRecordingWindow->setCurrentIndex(i);
00263       //      this->cmbSelectedRecordWindow_activated(i);
00264       this->SetRecordingWindow(i);
00265       break;
00266     }
00267   }
00268 }
00269 
00270 void QmitkMovieMaker::AdvanceAnimation()
00271 {
00272   // This method is called when a timer timeout occurs. It increases the
00273   // stepper value according to the elapsed time and the stepper interval.
00274   // Note that a screen refresh is not forced, but merely requested, and may
00275   // occur only after more calls to AdvanceAnimation().
00276 
00277   mitk::Stepper* stepper = this->GetAspectStepper();
00278 
00279   m_StepperAdapter->SetStepper(stepper);
00280 
00281   int elapsedTime = m_Time->elapsed();
00282   m_Time->restart();
00283 
00284   static double increment = 0.0;
00285   increment = increment - static_cast<int> (increment);
00286   increment += elapsedTime * stepper->GetSteps() / (m_Controls->spnDuration->value() * 1000.0);
00287 
00288   int i, n = static_cast<int> (increment);
00289   for (i = 0; i < n; ++i)
00290   {
00291     stepper->Next();
00292   }
00293 }
00294 
00295 void QmitkMovieMaker::RenderSlot()
00296 {
00297   int *i = widget->GetRenderWindow()->GetSize();
00298   m_PropRenderer->Resize(i[0], i[1]);
00299 
00300   widget->GetRenderWindow()->Render();
00301 }
00302 
00303 void QmitkMovieMaker::PausePlaying()
00304 {
00305 
00306   m_Controls->slidAngle->setDisabled(false);
00307   m_Controls->btnMovie->setEnabled(true);
00308   m_Controls->btnPlay->setEnabled(true);
00309   m_Controls->btnScreenshot->setEnabled(true);
00310 
00311   m_Timer->stop();
00312 
00313   m_Controls->btnPlay->setHidden(false);
00314   m_Controls->btnPause->setHidden(true);
00315   if (m_movieGenerator.IsNull())
00316     m_Controls->btnMovie->setEnabled(false);
00317 }
00318 
00319 void QmitkMovieMaker::StopPlaying()
00320 {
00321   m_Controls->slidAngle->setDisabled(false);
00322   m_Controls->btnMovie->setEnabled(true);
00323   m_Controls->btnPlay->setEnabled(true);
00324   m_Controls->btnScreenshot->setEnabled(true);
00325 
00326   m_Controls->btnPlay->setHidden(false);
00327   m_Controls->btnPause->setHidden(true);
00328 
00329   m_Timer->stop();
00330   switch (m_Direction)
00331   {
00332   case 0:
00333   case 2:
00334     this->GetAspectStepper()->First();
00335     break;
00336 
00337   case 1:
00338     this->GetAspectStepper()->Last();
00339     break;
00340   }
00341 
00342   // Reposition slider GUI element
00343   m_StepperAdapter->SetStepper(this->GetAspectStepper());
00344 
00345   if (m_movieGenerator.IsNull())
00346     m_Controls->btnMovie->setEnabled(false);
00347 
00348 }
00349 
00350 void QmitkMovieMaker::SetLooping(bool looping)
00351 {
00352   m_Looping = looping;
00353   this->UpdateLooping();
00354 }
00355 
00356 void QmitkMovieMaker::SetDirection(int direction)
00357 {
00358   m_Direction = direction;
00359   this->UpdateDirection();
00360 }
00361 
00362 void QmitkMovieMaker::SetAspect(int aspect)
00363 {
00364   m_Aspect = aspect;
00365 
00366   m_StepperAdapter->SetStepper(this->GetAspectStepper());
00367   this->UpdateLooping();
00368   this->UpdateDirection();
00369 }
00370 
00371 void QmitkMovieMaker::SetStepperWindow(int window)
00372 {
00373   // Set newly selected window / renderer as focused
00374   const mitk::RenderingManager::RenderWindowVector rwv =
00375       mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
00376 
00377   //Delete MultiStepper
00378   DeleteMStepper();
00379 
00380   int i;
00381   mitk::RenderingManager::RenderWindowVector::const_iterator iter;
00382   for (iter = rwv.begin(), i = 0; iter != rwv.end(); ++iter, ++i)
00383   {
00384     if (i == window)
00385     {
00386       mitk::GlobalInteraction::GetInstance()->GetFocusManager() ->SetFocused(
00387           mitk::BaseRenderer::GetInstance((*iter)));
00388       break;
00389     }
00390   }
00391 }
00392 
00393 void QmitkMovieMaker::SetRecordingWindow(int window)
00394 {
00395   // Set newly selected window for recording
00396   const mitk::RenderingManager::RenderWindowVector rwv =
00397       mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
00398 
00399   //Delete MultiStepper
00400   DeleteMStepper();
00401 
00402   int i;
00403   mitk::RenderingManager::RenderWindowVector::const_iterator iter;
00404   for (iter = rwv.begin(), i = 0; iter != rwv.end(); ++iter, ++i)
00405   {
00406     if (i == window)
00407     {
00408       m_RecordingRenderer = mitk::BaseRenderer::GetInstance((*iter));
00409       break;
00410     }
00411   }
00412 }
00413 
00414 void QmitkMovieMaker::UpdateLooping()
00415 {
00416   this->GetAspectStepper()->SetAutoRepeat(m_Looping);
00417 }
00418 
00419 void QmitkMovieMaker::UpdateDirection()
00420 {
00421   mitk::Stepper* stepper = this->GetAspectStepper();
00422 
00423   switch (m_Direction)
00424   {
00425   case 0:
00426     stepper->InverseDirectionOff();
00427     stepper->PingPongOff();
00428     break;
00429 
00430   case 1:
00431     stepper->InverseDirectionOn();
00432     stepper->PingPongOff();
00433     break;
00434 
00435   case 2:
00436     stepper->PingPongOn();
00437     break;
00438   }
00439 }
00440 
00441 mitk::Stepper* QmitkMovieMaker::GetAspectStepper()
00442 {
00443   if (m_Aspect == 0)
00444   {
00445     m_Stepper = NULL;
00446     return this->GetSpatialController()->GetSlice();
00447   }
00448   else if (m_Aspect == 1)
00449   {
00450     m_Stepper = NULL;
00451     return this->GetTemporalController()->GetTime();
00452   }
00453   else if (m_Aspect == 2)
00454   {   
00455     if (m_Stepper.IsNull())
00456     {
00457       int rel = m_Controls->spatialTimeRelation->value();
00458       int timeRepeat = 1;
00459       int sliceRepeat = 1;
00460       if (rel < 0)
00461       {
00462         sliceRepeat = -rel;
00463       }
00464       else if (rel > 0)
00465       {
00466         timeRepeat = rel;
00467       }
00468       m_Stepper = mitk::MultiStepper::New();
00469       m_Stepper->AddStepper(this->GetSpatialController()->GetSlice(), sliceRepeat);
00470       m_Stepper->AddStepper(this->GetTemporalController()->GetTime(), timeRepeat);
00471     }
00472 
00473     return m_Stepper.GetPointer();
00474   }
00475   else
00476   {
00477     // should never get here
00478     return 0;
00479   }
00480 }
00481 
00482 void QmitkMovieMaker::GenerateMovie()
00483 {
00484   emit StartBlockControls();
00485 
00486   // provide the movie generator with the stepper and rotate the camera each step
00487   if (m_movieGenerator.IsNotNull())
00488   {
00489     m_movieGenerator->SetStepper(this->GetAspectStepper());
00490     m_movieGenerator->SetRenderer(m_RecordingRenderer);
00491     m_movieGenerator->SetFrameRate(static_cast<unsigned int> (360
00492         / (m_Controls->spnDuration->value())));
00493 
00494     //    QString movieFileName = QFileDialog::getSaveFileName( QString::null, "Movie (*.avi)", 0, "movie file dialog", "Choose a file name" );
00495 
00496     QString movieFileName = QFileDialog::getSaveFileName(0, "Choose a file name", QString::null,
00497         "Movie (*.avi)", 0, 0);
00498 
00499     if (movieFileName.isEmpty() == false)
00500     {
00501       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00502       m_movieGenerator->SetFileName(movieFileName.toAscii());
00503       m_movieGenerator->WriteMovie();
00504     }
00505 
00506     emit EndBlockControls();
00507   }
00508   else
00509   {
00510     MITK_ERROR << "Either mitk::MovieGenerator is not implemented for your";
00511     MITK_ERROR << " platform or an error occurred during";
00512     MITK_ERROR << " mitk::MovieGenerator::New()";
00513 
00514     emit EndBlockControlsMovieDeactive();
00515   }
00516 }
00517 
00518 void QmitkMovieMaker::GenerateScreenshot()
00519 {
00520   emit StartBlockControls();
00521 
00522   QString fileName = QFileDialog::getSaveFileName(NULL, "Save screenshot to...", QDir::currentPath(), "JPEG file (*.jpg);;PNG file (*.png)");
00523   
00524   vtkRenderer* renderer = mitk::GlobalInteraction::GetInstance()->GetFocus()->GetVtkRenderer();
00525   if (renderer == NULL)
00526     return;
00527   this->TakeScreenshot(renderer, 1, fileName);
00528 
00529   if (m_movieGenerator.IsNotNull())
00530     emit EndBlockControls();
00531   else
00532     emit EndBlockControlsMovieDeactive();
00533 }
00534 
00535 void QmitkMovieMaker::GenerateHR3DScreenshot()
00536 {
00537   emit StartBlockControls();
00538 
00539   QString fileName = QFileDialog::getSaveFileName(NULL, "Save screenshot to...", QDir::currentPath(), "JPEG file (*.jpg);;PNG file (*.png)");
00540   
00541   // only works correctly for 3D RenderWindow
00542   vtkRenderer* renderer = m_MultiWidget->mitkWidget4->GetRenderer()->GetVtkRenderer();
00543   if (renderer == NULL)
00544     return;
00545   this->TakeScreenshot(renderer, 4, fileName);
00546 
00547   if (m_movieGenerator.IsNotNull())
00548     emit EndBlockControls();
00549   else
00550     emit EndBlockControlsMovieDeactive();
00551 }
00552 
00553 void QmitkMovieMaker::UpdateGUI()
00554 {
00555   int bla = this->GetTemporalController()->GetTime()->GetSteps();
00556   if (bla < 2)
00557   {
00558     m_Controls->rbtnTemporal->setEnabled(false);
00559     m_Controls->rbtnCombined->setEnabled(false);
00560     m_Controls->spatialTimeRelation->setEnabled(false);
00561   }
00562   else
00563   {
00564     m_Controls->rbtnTemporal->setEnabled(true);
00565     m_Controls->rbtnCombined->setEnabled(true);
00566     m_Controls->spatialTimeRelation->setEnabled(true);
00567   }
00568 
00569 }
00570 
00571 void QmitkMovieMaker::DataStorageChanged()
00572 {
00573   //  UpdateGUI();
00574 }
00575 
00576 void QmitkMovieMaker::CreateQtPartControl(QWidget *parent)
00577 {
00578   if (!m_Controls)
00579   {
00580     m_Controls = new Ui::QmitkMovieMakerControls;
00581     m_Controls->setupUi(parent);
00582 
00583     m_StepperAdapter = new QmitkStepperAdapter((QObject*) m_Controls->slidAngle,
00584         this->GetSpatialController()->GetSlice(), "AngleStepperToMovieMakerFunctionality");
00585 
00586     // Initialize "Selected Window" combo box
00587     const mitk::RenderingManager::RenderWindowVector rwv =
00588         mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
00589 
00590     mitk::RenderingManager::RenderWindowVector::const_iterator iter;
00591     unsigned int i = 0;
00592     for (iter = rwv.begin(); iter != rwv.end(); ++iter)
00593     {
00594       m_Controls->cmbSelectedStepperWindow->insertItem(i,
00595           mitk::BaseRenderer::GetInstance((*iter))->GetName());
00596       m_Controls->cmbSelectedRecordingWindow->insertItem(i++, mitk::BaseRenderer::GetInstance(
00597           (*iter))->GetName());
00598     }
00599 
00600     m_Controls->btnPause->setHidden(true);
00601     if (m_movieGenerator.IsNull())
00602       m_Controls->btnMovie->setEnabled(false);
00603   }
00604 
00605   this->CreateConnections();
00606 
00607 }
00608 
00609 void QmitkMovieMaker::StartPlaying()
00610 {
00611   m_Controls->slidAngle->setDisabled(true);
00612   m_Controls->btnMovie->setEnabled(false);
00613   m_Controls->btnPlay->setEnabled(false);
00614   m_Controls->btnScreenshot->setEnabled(false);
00615 
00616   // Restart timer with 5 msec interval - this should be fine-grained enough
00617   // even for high display refresh frequencies
00618   m_Timer->start(5);
00619 
00620   m_Time->restart();
00621 
00622   m_Controls->btnPlay->setHidden(true);
00623   m_Controls->btnPause->setHidden(false);
00624   if (m_movieGenerator.IsNull())
00625     m_Controls->btnMovie->setEnabled(false);
00626 
00627 }
00628 
00629 void QmitkMovieMaker::RBTNForward()
00630 {
00631   emit SwitchDirection(0);
00632 }
00633 
00634 void QmitkMovieMaker::RBTNBackward()
00635 {
00636   emit SwitchDirection(1);
00637 }
00638 
00639 void QmitkMovieMaker::RBTNPingPong()
00640 {
00641   emit SwitchDirection(2);
00642 }
00643 
00644 void QmitkMovieMaker::RBTNSpatial()
00645 {
00646   emit SwitchAspect(0);
00647 }
00648 
00649 void QmitkMovieMaker::RBTNTemporal()
00650 {
00651   emit SwitchAspect(1);
00652 }
00653 
00654 void QmitkMovieMaker::RBTNCombined()
00655 {
00656   emit SwitchAspect(2);
00657 }
00658 
00659 void QmitkMovieMaker::BlockControls()
00660 {
00661   BlockControls(true);
00662 }
00663 
00664 void QmitkMovieMaker::UnBlockControls()
00665 {
00666   BlockControls(false);
00667 }
00668 
00669 void QmitkMovieMaker::UnBlockControlsMovieDeactive()
00670 {
00671   BlockControls(false);
00672 
00673   m_Controls->btnMovie->setEnabled(false);
00674 }
00675 
00676 void QmitkMovieMaker::BlockControls(bool blocked)
00677 {
00678   m_Controls->slidAngle->setDisabled(blocked);
00679   m_Controls->spnDuration->setEnabled(!blocked);
00680   m_Controls->btnPlay->setEnabled(!blocked);
00681   m_Controls->btnMovie->setEnabled(!blocked);
00682   m_Controls->btnScreenshot->setEnabled(!blocked);
00683 }
00684 
00685 void QmitkMovieMaker::StdMultiWidgetAvailable(QmitkStdMultiWidget&  stdMultiWidget)
00686 {
00687   m_MultiWidget = &stdMultiWidget;
00688   m_Parent->setEnabled(true);
00689 }
00690 
00691 void QmitkMovieMaker::StdMultiWidgetNotAvailable()
00692 {
00693   m_MultiWidget = NULL;
00694   m_Parent->setEnabled(false);
00695 }
00696 
00697 void QmitkMovieMaker::TakeScreenshot(vtkRenderer* renderer, unsigned int magnificationFactor, QString fileName)
00698 {
00699   if ((renderer == NULL) ||(magnificationFactor < 1) || fileName.isEmpty())
00700     return;
00701 
00702   bool doubleBuffering( renderer->GetRenderWindow()->GetDoubleBuffer() );
00703   renderer->GetRenderWindow()->DoubleBufferOff();
00704 
00705   vtkImageWriter* fileWriter;
00706 
00707   QFileInfo fi(fileName);
00708   QString suffix = fi.suffix();
00709   if (suffix.compare("png", Qt::CaseInsensitive) == 0)
00710   {
00711     fileWriter = vtkPNGWriter::New();
00712   }
00713   else  // default is jpeg
00714   {
00715     vtkJPEGWriter* w = vtkJPEGWriter::New();
00716     w->SetQuality(100);
00717     w->ProgressiveOff();
00718     fileWriter = w;
00719   }
00720   vtkRenderLargeImage* magnifier = vtkRenderLargeImage::New();
00721   magnifier->SetInput(renderer);
00722   magnifier->SetMagnification(magnificationFactor);
00723   //magnifier->Update();
00724   fileWriter->SetInput(magnifier->GetOutput());
00725   fileWriter->SetFileName(fileName.toLatin1());
00726 
00727   // vtkRenderLargeImage has problems with different layers, therefore we have to 
00728   // temporarily deactivate all other layers.
00729   // we set the background to white, because it is nicer than black...
00730   double oldBackground[3];
00731   renderer->GetBackground(oldBackground);
00732   double white[] = {1.0, 1.0, 1.0};
00733   renderer->SetBackground(white);
00734   m_MultiWidget->DisableColoredRectangles();
00735   m_MultiWidget->DisableDepartmentLogo();
00736   m_MultiWidget->DisableGradientBackground();
00737 
00738   fileWriter->Write();  
00739   fileWriter->Delete();  
00740 
00741   m_MultiWidget->EnableColoredRectangles();
00742   m_MultiWidget->EnableDepartmentLogo();
00743   m_MultiWidget->EnableGradientBackground();
00744   renderer->SetBackground(oldBackground);
00745   
00746   renderer->GetRenderWindow()->SetDoubleBuffer(doubleBuffering);
00747 }
00748 
00749 void QmitkMovieMaker::DeleteMStepper()
00750 {
00751   m_Stepper = NULL;
00752   UpdateLooping();
00753 }