mitk: QmitkImageStatisticsView.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date: 2009-05-22 11:00:35 +0200 (Fr, 22 Mai 2009) $
00006 Version:   $Revision: 10185 $
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 "QmitkImageStatisticsView.h"
00019 
00020 #include <limits>
00021 
00022 #include <qlabel.h>
00023 #include <qspinbox.h>
00024 #include <qpushbutton.h>
00025 #include <qcheckbox.h>
00026 #include <qgroupbox.h>
00027 #include <qradiobutton.h>
00028 #include <qlineedit.h>
00029 #include <qclipboard.h>
00030 #include <qfiledialog.h>
00031 
00032 #include <berryIEditorPart.h>
00033 #include <berryIWorkbenchPage.h>
00034 #include <berryPlatform.h>
00035 
00036 
00037 #include "QmitkStdMultiWidget.h"
00038 #include "QmitkSliderNavigatorWidget.h"
00039 
00040 #include "mitkNodePredicateDataType.h"
00041 #include "mitkImageTimeSelector.h"
00042 #include "mitkProperties.h"
00043 
00044 #include "mitkProgressBar.h"
00045 
00046 // Includes for image processing
00047 #include "mitkImageCast.h"
00048 #include "mitkITKImageImport.h"
00049 
00050 #include "mitkDataNodeObject.h"
00051 #include "mitkNodePredicateData.h"
00052 #include "mitkPlanarFigureInteractor.h"
00053 
00054 #include <itkVectorImage.h>
00055 
00056 class QmitkRequestStatisticsUpdateEvent : public QEvent
00057 {
00058 public:
00059   enum Type
00060   {
00061     StatisticsUpdateRequest = QEvent::MaxUser - 1025
00062   };
00063 
00064   QmitkRequestStatisticsUpdateEvent()
00065     : QEvent( (QEvent::Type) StatisticsUpdateRequest ) {};
00066 };
00067 
00068 
00069 
00070 typedef itk::Image<short, 3>                 ImageType;
00071 typedef itk::Image<float, 3>                 FloatImageType;
00072 typedef itk::Image<itk::Vector<float,3>, 3>  VectorImageType;
00073 
00074 inline bool my_isnan(float x)
00075  {
00076    volatile float d = x;
00077 
00078    if(d!=d)
00079      return true;
00080 
00081    if(d==d)
00082      return false;
00083    return d != d;
00084 
00085  }
00086 
00087 QmitkImageStatistics::QmitkImageStatistics(QObject* /*parent*/, const char* /*name*/)
00088 : QmitkFunctionality(),
00089   m_Controls( NULL ),
00090   m_TimeStepperAdapter( NULL ),
00091   m_SelectedImageNode( NULL ),
00092   m_SelectedImage( NULL ),
00093   m_SelectedMaskNode( NULL ),
00094   m_SelectedImageMask( NULL ),
00095   m_SelectedPlanarFigure( NULL ),
00096   m_ImageObserverTag( -1 ),
00097   m_ImageMaskObserverTag( -1 ),
00098   m_PlanarFigureObserverTag( -1 ),
00099   m_CurrentStatisticsValid( false ),
00100   m_StatisticsUpdatePending( false )
00101 {
00102 }
00103 
00104 
00105 QmitkImageStatistics::~QmitkImageStatistics()
00106 {
00107   if ( m_SelectedImage != NULL )
00108     m_SelectedImage->RemoveObserver( m_ImageObserverTag );
00109   if ( m_SelectedImageMask != NULL )
00110     m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
00111   if ( m_SelectedPlanarFigure != NULL )
00112     m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
00113 }
00114 
00115 
00116 void QmitkImageStatistics::CreateQtPartControl(QWidget *parent)
00117 {
00118   if (m_Controls == NULL)
00119   {
00120     m_Controls = new Ui::QmitkImageStatisticsViewControls;
00121     m_Controls->setupUi(parent);
00122     this->CreateConnections();
00123 
00124     m_Controls->m_ErrorMessageLabel->hide();
00125 
00126     m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
00127     m_Controls->m_LineProfileWidget->SetPathModeToPlanarFigure();
00128   }
00129 }
00130 
00131 
00132 
00133 void QmitkImageStatistics::CreateConnections()
00134 {
00135   if ( m_Controls )
00136   {
00137     connect( (QObject*)(m_Controls->m_ButtonCopyHistogramToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(ClipboardHistogramButtonClicked()));
00138     connect( (QObject*)(m_Controls->m_ButtonCopyStatisticsToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(ClipboardStatisticsButtonClicked()));
00139   }
00140 }
00141 
00142 
00143 void QmitkImageStatistics::StdMultiWidgetAvailable( QmitkStdMultiWidget& stdMultiWidget )
00144 {
00145   QmitkFunctionality::StdMultiWidgetAvailable(stdMultiWidget);
00146 }
00147 
00148 
00149 void QmitkImageStatistics::ClipboardHistogramButtonClicked()
00150 {
00151   if ( m_CurrentStatisticsValid && (m_CurrentStatisticsCalculator.IsNotNull()) )
00152   {
00153     typedef mitk::ImageStatisticsCalculator::HistogramType HistogramType;
00154     const HistogramType *histogram = m_CurrentStatisticsCalculator->GetHistogram();
00155 
00156     QString clipboard( "Measurement \t Frequency\n" );
00157     for ( HistogramType::ConstIterator it = histogram->Begin();
00158           it != histogram->End();
00159           ++it )
00160     {
00161       clipboard = clipboard.append( "%L1 \t %L2\n" )
00162         .arg( it.GetMeasurementVector()[0], 0, 'f', 2 )
00163         .arg( it.GetFrequency() );
00164     }
00165 
00166     QApplication::clipboard()->setText(
00167       clipboard, QClipboard::Clipboard );
00168   }
00169   else
00170   {
00171     QApplication::clipboard()->clear();
00172   }
00173 }
00174 
00175 
00176 void QmitkImageStatistics::ClipboardStatisticsButtonClicked()
00177 {
00178   if ( m_CurrentStatisticsValid && (m_CurrentStatisticsCalculator.IsNotNull()) )
00179   {
00180     const mitk::ImageStatisticsCalculator::Statistics &statistics =
00181       m_CurrentStatisticsCalculator->GetStatistics();
00182 
00183     // Copy statistics to clipboard ("%Ln" will use the default locale for
00184     // number formatting)
00185     QString clipboard( "Mean \t StdDev \t RMS \t Max \t Min \t N\n" );
00186     clipboard = clipboard.append( "%L1 \t %L2 \t %L3 \t %L4 \t %L5 \t %L6" )
00187       .arg( statistics.Mean, 0, 'f', 10 )
00188       .arg( statistics.Sigma, 0, 'f', 10 )
00189       .arg( statistics.RMS, 0, 'f', 10 )
00190       .arg( statistics.Max, 0, 'f', 10 )
00191       .arg( statistics.Min, 0, 'f', 10 )
00192       .arg( statistics.N );
00193 
00194     QApplication::clipboard()->setText(
00195       clipboard, QClipboard::Clipboard );
00196   }
00197   else
00198   {
00199     QApplication::clipboard()->clear();
00200   }
00201 }
00202 
00203 
00204 void QmitkImageStatistics::FillStatisticsTableView(
00205   const mitk::ImageStatisticsCalculator::Statistics &s,
00206   const mitk::Image *image )
00207 {
00208   m_Controls->m_StatisticsTable->setItem( 0, 0, new QTableWidgetItem(
00209     QString("%1").arg(s.Mean, 0, 'f', 2) ) );
00210 
00211   m_Controls->m_StatisticsTable->setItem( 0, 1, new QTableWidgetItem(
00212     QString("%1").arg(s.Sigma, 0, 'f', 2) ) );
00213 
00214   m_Controls->m_StatisticsTable->setItem( 0, 2, new QTableWidgetItem(
00215     QString("%1").arg(s.RMS, 0, 'f', 2) ) );
00216 
00217   m_Controls->m_StatisticsTable->setItem( 0, 3, new QTableWidgetItem(
00218     QString("%1").arg(s.Max, 0, 'f', 2) ) );
00219 
00220   m_Controls->m_StatisticsTable->setItem( 0, 4, new QTableWidgetItem(
00221     QString("%1").arg(s.Min, 0, 'f', 2) ) );
00222 
00223   m_Controls->m_StatisticsTable->setItem( 0, 5, new QTableWidgetItem(
00224     QString("%1").arg(s.N) ) );
00225 
00226   const mitk::Geometry3D *geometry = image->GetGeometry();
00227   if ( geometry != NULL )
00228   {
00229     const mitk::Vector3D &spacing = image->GetGeometry()->GetSpacing();
00230     double volume = spacing[0] * spacing[1] * spacing[2] * (double) s.N;
00231     m_Controls->m_StatisticsTable->setItem( 0, 6, new QTableWidgetItem(
00232       QString("%1").arg(volume, 0, 'f', 2) ) );
00233   }
00234   else
00235   {
00236     m_Controls->m_StatisticsTable->setItem( 0, 6, new QTableWidgetItem(
00237       "NA" ) );
00238   }
00239 }
00240 
00241 
00242 void QmitkImageStatistics::InvalidateStatisticsTableView()
00243 {
00244   for ( unsigned int i = 0; i < 7; ++i )
00245   {
00246     m_Controls->m_StatisticsTable->setItem( 0, i, new QTableWidgetItem( "NA" ) );
00247   }
00248 }
00249 
00250 
00251 void QmitkImageStatistics::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
00252 {
00253   // Clear any unreferenced images
00254   this->RemoveOrphanImages();
00255 
00256   if ( !this->IsVisible() )
00257   {
00258     return;
00259   }
00260 
00261   // Check if selection makeup consists only of valid nodes:
00262   // One image, segmentation or planarFigure
00263   // One image and one of the other two
00264   bool tooManyNodes( true );
00265   bool invalidNodes( true );
00266 
00267   if ( nodes.size() < 3 )
00268   {
00269     tooManyNodes = false;
00270   }
00271 
00272   if( !tooManyNodes )
00273   {
00274     unsigned int numberImages = 0;
00275     unsigned int numberSegmentations = 0;
00276     unsigned int numberPlanarFigures = 0;
00277 
00278     for ( unsigned int index = 0; index < nodes.size(); index++ )
00279     {
00280       m_SelectedImageMask = dynamic_cast< mitk::Image * >( nodes[ index ]->GetData() );
00281       m_SelectedPlanarFigure = dynamic_cast< mitk::PlanarFigure * >( nodes[ index ]->GetData() );
00282 
00283       if ( m_SelectedImageMask != NULL )
00284       {
00285         bool isMask( false );
00286         nodes[ index ]->GetPropertyValue("binary", isMask);
00287         if ( !isMask )
00288         {
00289           numberImages++;
00290         }
00291         else
00292         {
00293           numberSegmentations++;
00294           if ( numberImages != 0 ) // image should be last element
00295           {
00296             std::swap( nodes[ index ], nodes[ index - 1 ] );
00297           }
00298         }
00299       }
00300       else if ( m_SelectedPlanarFigure != NULL )
00301       {
00302         numberPlanarFigures++;
00303         if ( numberImages != 0 ) // image should be last element
00304         {
00305           std::swap( nodes[ index ], nodes[ index - 1 ] );
00306         }
00307       }
00308     }
00309 
00310     if ( ( numberPlanarFigures + numberSegmentations + numberImages ) == nodes.size() && //No invalid nodes
00311       ( numberPlanarFigures + numberSegmentations ) < 2 && numberImages < 2 
00312       // maximum of one image and/or one of either planar figure or segmentation
00313       )
00314     {
00315       invalidNodes = false;
00316     }
00317   }
00318 
00319   if ( nodes.empty() || tooManyNodes || invalidNodes )
00320   {
00321     // Nothing to do: invalidate image, clear statistics, histogram, and GUI
00322     m_SelectedImage = NULL;
00323     this->InvalidateStatisticsTableView() ;
00324     m_Controls->m_HistogramWidget->ClearItemModel();
00325     m_Controls->m_LineProfileWidget->ClearItemModel();
00326 
00327     m_CurrentStatisticsValid = false;
00328     m_Controls->m_ErrorMessageLabel->hide();
00329     m_Controls->m_SelectedMaskLabel->setText( "None" );
00330     return;
00331   }
00332 
00333   // Get selected element
00334 
00335   mitk::DataNode *selectedNode = nodes.front();
00336   mitk::Image *selectedImage = dynamic_cast< mitk::Image * >( selectedNode->GetData() );
00337 
00338   // Find the next parent/grand-parent node containing an image, if any
00339   mitk::DataStorage::SetOfObjects::ConstPointer parentObjects;
00340   mitk::DataNode *parentNode = NULL;
00341   mitk::Image *parentImage = NULL;
00342 
00343   // Possibly previous change listeners
00344   if ( (m_SelectedPlanarFigure != NULL) && (m_PlanarFigureObserverTag >= 0) )
00345   {
00346     m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
00347     m_PlanarFigureObserverTag = -1;
00348   }
00349   if ( (m_SelectedImage != NULL) && (m_ImageObserverTag >= 0) )
00350   {
00351     m_SelectedImage->RemoveObserver( m_ImageObserverTag );
00352     m_ImageObserverTag = -1;
00353   }
00354   if ( (m_SelectedImageMask != NULL) && (m_ImageMaskObserverTag >= 0) )
00355   {
00356     m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
00357     m_ImageMaskObserverTag = -1;
00358   }
00359 
00360   // Deselect all images and masks by default
00361   m_SelectedImageNode = NULL;
00362   m_SelectedImage = NULL;
00363   m_SelectedMaskNode = NULL;
00364   m_SelectedImageMask = NULL;
00365   m_SelectedPlanarFigure = NULL;
00366 
00367   {
00368     unsigned int parentObjectIndex = 0;
00369     parentObjects = this->GetDefaultDataStorage()->GetSources( selectedNode );
00370     while( parentObjectIndex < parentObjects->Size() )
00371     {
00372       // Use first parent object (if multiple parents are present)
00373       parentNode = parentObjects->ElementAt( parentObjectIndex );
00374       parentImage = dynamic_cast< mitk::Image * >( parentNode->GetData() );
00375       if( parentImage != NULL )
00376       {
00377         break;
00378       }
00379       parentObjectIndex++;
00380     }
00381   }
00382 
00383   if ( nodes.size() == 2 )
00384   {
00385     parentNode = nodes.back();
00386     parentImage = dynamic_cast< mitk::Image * >( parentNode->GetData() );
00387   }
00388 
00389   if ( parentImage != NULL )
00390   {
00391     m_SelectedImageNode = parentNode;
00392     m_SelectedImage = parentImage;
00393 
00394     // Check if a valid mask has been selected (Image or PlanarFigure)
00395     m_SelectedImageMask = dynamic_cast< mitk::Image * >( selectedNode->GetData() );
00396     m_SelectedPlanarFigure = dynamic_cast< mitk::PlanarFigure * >( selectedNode->GetData() );
00397 
00398     // Check whether ImageMask is a binary segmentation
00399 
00400     if ( (m_SelectedImageMask != NULL) )
00401     {
00402       bool isMask( false );
00403       selectedNode->GetPropertyValue("binary", isMask);
00404       if ( !isMask )
00405       {
00406         m_SelectedImageNode = selectedNode;
00407         m_SelectedImage = selectedImage;
00408         m_SelectedImageMask = NULL;
00409       }
00410       else
00411       {
00412         m_SelectedMaskNode = selectedNode;
00413       }
00414     }
00415     else if ( (m_SelectedPlanarFigure != NULL) )
00416     {
00417       m_SelectedMaskNode = selectedNode;
00418     }
00419   }
00420   else if ( selectedImage != NULL )
00421   {
00422     m_SelectedImageNode = selectedNode;
00423     m_SelectedImage = selectedImage;
00424   }
00425 
00426 
00427   typedef itk::SimpleMemberCommand< QmitkImageStatistics > ITKCommandType;
00428   ITKCommandType::Pointer changeListener;
00429   changeListener = ITKCommandType::New();
00430   changeListener->SetCallbackFunction( this, &QmitkImageStatistics::RequestStatisticsUpdate );
00431 
00432   // Add change listeners to selected objects
00433   if ( m_SelectedImage != NULL )
00434   {
00435     m_ImageObserverTag = m_SelectedImage->AddObserver(
00436       itk::ModifiedEvent(), changeListener );
00437   }
00438 
00439   if ( m_SelectedImageMask != NULL )
00440   {
00441     m_ImageMaskObserverTag = m_SelectedImageMask->AddObserver(
00442       itk::ModifiedEvent(), changeListener );
00443   }
00444 
00445   if ( m_SelectedPlanarFigure != NULL )
00446   {
00447     m_PlanarFigureObserverTag = m_SelectedPlanarFigure->AddObserver(
00448       mitk::EndInteractionPlanarFigureEvent(), changeListener );
00449   }
00450 
00451 
00452   // Clear statistics / histogram GUI if nothing is selected
00453   if ( m_SelectedImage == NULL )
00454   {
00455     // Clear statistics, histogram, and GUI
00456     this->InvalidateStatisticsTableView();
00457     m_Controls->m_HistogramWidget->ClearItemModel();
00458     m_Controls->m_LineProfileWidget->ClearItemModel();
00459     m_CurrentStatisticsValid = false;
00460     m_Controls->m_ErrorMessageLabel->hide();
00461     m_Controls->m_SelectedMaskLabel->setText( "None" );
00462   }
00463   else
00464   {
00465     // Else, request statistics and GUI update
00466     this->RequestStatisticsUpdate();
00467   }
00468 }
00469 
00470 
00471 void QmitkImageStatistics::UpdateStatistics()
00472 {
00473   // Remove any cached images that are no longer referenced elsewhere
00474   this->RemoveOrphanImages();
00475 
00476   QmitkStdMultiWidget *multiWidget = this->GetActiveStdMultiWidget();
00477   if ( multiWidget == NULL )
00478   {
00479     return;
00480   }
00481 
00482   unsigned int timeStep = multiWidget->GetTimeNavigationController()->GetTime()->GetPos();
00483 
00484   if ( m_SelectedImage != NULL )
00485   {
00486     // Check if a the selected image is a multi-channel image. If yes, statistics
00487     // cannot be calculated currently.
00488     if ( m_SelectedImage->GetPixelType().GetNumberOfComponents() > 1 )
00489     {
00490       std::stringstream message;
00491       message << "<font color='red'>Multi-component images not supported.</font>";
00492       m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
00493       m_Controls->m_ErrorMessageLabel->show();
00494 
00495       this->InvalidateStatisticsTableView();
00496       m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
00497       m_Controls->m_HistogramWidget->ClearItemModel();
00498       m_CurrentStatisticsValid = false;
00499       return;
00500     }
00501 
00502     // Retrieve ImageStatisticsCalculator from has map (or create a new one
00503     // for this image if non-existant)
00504     ImageStatisticsMapType::iterator it =
00505       m_ImageStatisticsMap.find( m_SelectedImage );
00506 
00507     if ( it != m_ImageStatisticsMap.end() )
00508     {
00509       m_CurrentStatisticsCalculator = it->second;
00510       MITK_INFO << "Retrieving StatisticsCalculator";
00511     }
00512     else
00513     {
00514       m_CurrentStatisticsCalculator = mitk::ImageStatisticsCalculator::New();
00515       m_CurrentStatisticsCalculator->SetImage( m_SelectedImage );
00516       m_ImageStatisticsMap[m_SelectedImage] = m_CurrentStatisticsCalculator;
00517       MITK_INFO << "Creating StatisticsCalculator";
00518     }
00519 
00520     std::string maskName;
00521     std::string maskType;
00522     unsigned int maskDimension;
00523 
00524     if ( m_SelectedImageMask != NULL )
00525     {
00526       m_CurrentStatisticsCalculator->SetImageMask( m_SelectedImageMask );
00527       m_CurrentStatisticsCalculator->SetMaskingModeToImage();
00528 
00529       maskName = m_SelectedMaskNode->GetName();
00530       maskType = m_SelectedImageMask->GetNameOfClass();
00531       maskDimension = 3;
00532     }
00533     else if ( m_SelectedPlanarFigure != NULL )
00534     {
00535       m_CurrentStatisticsCalculator->SetPlanarFigure( m_SelectedPlanarFigure );
00536       m_CurrentStatisticsCalculator->SetMaskingModeToPlanarFigure();
00537 
00538       maskName = m_SelectedMaskNode->GetName();
00539       maskType = m_SelectedPlanarFigure->GetNameOfClass();
00540       maskDimension = 2;
00541     }
00542     else
00543     {
00544       m_CurrentStatisticsCalculator->SetMaskingModeToNone();
00545 
00546       maskName = "None";
00547       maskType = "";
00548       maskDimension = 0;
00549     }
00550 
00551     std::stringstream maskLabel;
00552     maskLabel << maskName;
00553     if ( maskDimension > 0 )
00554     {
00555       maskLabel << "  [" << maskDimension << "D " << maskType << "]";
00556     }
00557 
00558     m_Controls->m_SelectedMaskLabel->setText( maskLabel.str().c_str() );
00559 
00560     bool statisticsChanged = false;
00561     bool statisticsCalculationSuccessful = false;
00562 
00563     // Initialize progress bar
00564     mitk::ProgressBar::GetInstance()->AddStepsToDo( 100 );
00565 
00566     // Install listener for progress events and initialize progress bar
00567     typedef itk::SimpleMemberCommand< QmitkImageStatistics > ITKCommandType;
00568     ITKCommandType::Pointer progressListener;
00569     progressListener = ITKCommandType::New();
00570     progressListener->SetCallbackFunction( this, &QmitkImageStatistics::UpdateProgressBar );
00571     unsigned long progressObserverTag = m_CurrentStatisticsCalculator
00572       ->AddObserver( itk::ProgressEvent(), progressListener );
00573 
00574     // show wait cursor
00575     this->WaitCursorOn();
00576 
00577     try
00578     {
00579       // Compute statistics
00580       statisticsChanged =
00581         m_CurrentStatisticsCalculator->ComputeStatistics( timeStep );
00582 
00583       statisticsCalculationSuccessful = true;
00584     }
00585     catch ( const std::runtime_error &e )
00586     {
00587       // In case of exception, print error message on GUI
00588       std::stringstream message;
00589       message << "<font color='red'>" << e.what() << "</font>";
00590       m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
00591       m_Controls->m_ErrorMessageLabel->show();
00592     }
00593     catch ( const std::exception &e )
00594     {
00595       MITK_ERROR << "Caught exception: " << e.what();
00596 
00597       // In case of exception, print error message on GUI
00598       std::stringstream message;
00599       message << "<font color='red'>Error in calculating histogram</font>";
00600       m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
00601       m_Controls->m_ErrorMessageLabel->show();
00602     }
00603 
00604     m_CurrentStatisticsCalculator->RemoveObserver( progressObserverTag );
00605 
00606     // Make sure that progress bar closes
00607     mitk::ProgressBar::GetInstance()->Progress( 100 );
00608 
00609     // remove wait cursor
00610     this->WaitCursorOff();
00611 
00612     if ( statisticsCalculationSuccessful )
00613     {
00614       if ( statisticsChanged )
00615       {
00616         // Do not show any error messages
00617         m_Controls->m_ErrorMessageLabel->hide();
00618 
00619         m_CurrentStatisticsValid = true;
00620       }
00621 
00622       m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
00623       m_Controls->m_HistogramWidget->SetHistogramModeToDirectHistogram();
00624       m_Controls->m_HistogramWidget->SetHistogram(
00625         m_CurrentStatisticsCalculator->GetHistogram( timeStep ) );
00626       m_Controls->m_HistogramWidget->UpdateItemModelFromHistogram();
00627 
00628       MITK_INFO << "UpdateItemModelFromHistogram()";
00629 
00630       this->FillStatisticsTableView(
00631         m_CurrentStatisticsCalculator->GetStatistics( timeStep ),
00632         m_SelectedImage );
00633     }
00634     else
00635     {
00636       m_Controls->m_SelectedMaskLabel->setText( "None" );
00637 
00638       // Clear statistics and histogram
00639       this->InvalidateStatisticsTableView();
00640       m_Controls->m_HistogramWidget->ClearItemModel();
00641       m_CurrentStatisticsValid = false;
00642 
00643 
00644       // If a (non-closed) PlanarFigure is selected, display a line profile widget
00645       if ( m_SelectedPlanarFigure != NULL )
00646       {
00647         // check whether PlanarFigure is initialized
00648         const mitk::Geometry2D *planarFigureGeometry2D = m_SelectedPlanarFigure->GetGeometry2D();
00649         if ( planarFigureGeometry2D == NULL )
00650         {
00651           // Clear statistics, histogram, and GUI
00652           this->InvalidateStatisticsTableView();
00653           m_Controls->m_HistogramWidget->ClearItemModel();
00654           m_Controls->m_LineProfileWidget->ClearItemModel();
00655           m_CurrentStatisticsValid = false;
00656           m_Controls->m_ErrorMessageLabel->hide();
00657           m_Controls->m_SelectedMaskLabel->setText( "None" );
00658           return;
00659         }
00660         // TODO: enable line profile widget
00661         m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 1 );       
00662         m_Controls->m_LineProfileWidget->SetImage( m_SelectedImage );
00663         m_Controls->m_LineProfileWidget->SetPlanarFigure( m_SelectedPlanarFigure );
00664         m_Controls->m_LineProfileWidget->UpdateItemModelFromPath();
00665       }
00666     }
00667   }
00668 }
00669 
00670 void QmitkImageStatistics::UpdateProgressBar()
00671 {
00672   mitk::ProgressBar::GetInstance()->Progress();
00673 }
00674 
00675 
00676 void QmitkImageStatistics::RequestStatisticsUpdate()
00677 {
00678   if ( !m_StatisticsUpdatePending )
00679   {
00680     QApplication::postEvent( this, new QmitkRequestStatisticsUpdateEvent );
00681     m_StatisticsUpdatePending = true;
00682   }
00683 }
00684 
00685 
00686 void QmitkImageStatistics::RemoveOrphanImages()
00687 {
00688   ImageStatisticsMapType::iterator it = m_ImageStatisticsMap.begin();
00689 
00690   while ( it != m_ImageStatisticsMap.end() )
00691   {
00692     mitk::Image *image = it->first;
00693     mitk::ImageStatisticsCalculator *calculator = it->second;
00694     ++it;
00695 
00696     mitk::NodePredicateData::Pointer hasImage = mitk::NodePredicateData::New( image );
00697     if ( this->GetDefaultDataStorage()->GetNode( hasImage ) == NULL )
00698     {
00699       if ( m_SelectedImage == image )
00700       {
00701         m_SelectedImage = NULL;
00702         m_SelectedImageNode = NULL;
00703       }
00704       if ( m_CurrentStatisticsCalculator == calculator )
00705       {
00706         m_CurrentStatisticsCalculator = NULL;
00707       }
00708       m_ImageStatisticsMap.erase( image );
00709       it = m_ImageStatisticsMap.begin();
00710     }
00711   }
00712 }
00713 
00714 
00715 bool QmitkImageStatistics::event( QEvent *event )
00716 {
00717   if ( event->type() == (QEvent::Type) QmitkRequestStatisticsUpdateEvent::StatisticsUpdateRequest )
00718   {
00719     // Update statistics
00720 
00721     m_StatisticsUpdatePending = false;
00722 
00723     this->UpdateStatistics();
00724     return true;
00725   }
00726 
00727   return false;
00728 }
00729 
00730 void QmitkImageStatistics::ComputeIntensityProfile( mitk::PlanarLine* line )
00731 {
00732   double sampling = 300;
00733   QmitkVtkHistogramWidget::HistogramType::Pointer histogram = QmitkVtkHistogramWidget::HistogramType::New();
00734   itk::Size<1> siz;
00735   siz[0] = sampling;
00736   itk::FixedArray<double,1> lower, higher;
00737   lower.Fill(0);
00738     mitk::Point3D begin = line->GetWorldControlPoint(0);
00739   mitk::Point3D end = line->GetWorldControlPoint(1);
00740   itk::Vector<double,3> direction = (end - begin);
00741   higher.Fill(direction.GetNorm());
00742   histogram->Initialize(siz, lower, higher);
00743   for(int i = 0; i < sampling; i++)
00744   {
00745     mitk::Point3D location = begin + double(i)/sampling * direction;
00746     double d = m_SelectedImage->GetPixelValueByWorldCoordinate(begin + double(i)/sampling * direction);
00747     histogram->SetFrequency(i,d);
00748   }
00749   m_Controls->m_HistogramWidget->SetHistogramModeToDirectHistogram();
00750   m_Controls->m_HistogramWidget->SetHistogram( histogram );
00751   m_Controls->m_HistogramWidget->UpdateItemModelFromHistogram();
00752 
00753 }
00754 
00755 bool QmitkImageStatistics::IsExclusiveFunctionality() const
00756 {
00757   return false;
00758 }
00759 
00760 void QmitkImageStatistics::Visible()
00761 {
00762   this->OnSelectionChanged( this->GetDataManagerSelection() );
00763 }