appli/ImageMPR/ImageMPR.cxx

   1 #include "ImageMPR.h"
   2 #include "ui_ImageMPR.h"
   3
   4 #include <QFileInfo>
   5 #include <QMessageBox>
   6
   7 // -------------------------------------------------------------------------
   8 #define ImageMPR_ConnectAction( ACTION )                \
   9   QObject::connect(                                     \
  10     this->m_UI->a##ACTION, SIGNAL( triggered( ) ),      \
  11     this, SLOT( _a##ACTION( ) )                         \
  12     )
  13
  14 // -------------------------------------------------------------------------
  15 ImageMPR::
  16 ImageMPR( QWidget* parent )
  17   : QMainWindow( parent ),
  18     m_UI( new Ui::ImageMPR )
  19 {
  20   this->m_UI->setupUi( this );
  21   this->m_Plugins.SetWidget( this );
  22   this->m_Plugins.SetApplication( this );
  23
  24   // Connect actions
  25   ImageMPR_ConnectAction( OpenImage );
  26   ImageMPR_ConnectAction( OpenDICOMSeries );
  27   ImageMPR_ConnectAction( OpenSegmentation );
  28   ImageMPR_ConnectAction( OpenPolyData );
  29   ImageMPR_ConnectAction( SaveImage );
  30   ImageMPR_ConnectAction( SaveSegmentation );
  31   ImageMPR_ConnectAction( SavePolyData );
  32   ImageMPR_ConnectAction( Undo );
  33   ImageMPR_ConnectAction( Redo );
  34   ImageMPR_ConnectAction( LoadPlugins );
  35   ImageMPR_ConnectAction( ShowPlugins );
  36
  37   // Associate model with view
  38   for( unsigned int i = 0; i < 4; ++i )
  39     this->m_Plugins.AddInteractor( this->m_UI->MPR->GetInteractor( i ) );
  40
  41   // Try to load default plugins
  42   QStringList args = QApplication::arguments( );
  43   QFileInfo info( args.at( 0 ) );
  44   this->m_Plugins.LoadPluginsPath(
  45     info.absolutePath( ).toStdString( ), true
  46     );
  47
  48   // Put loaded plugins into menu
  49   this->_AssociatePluginsToMenu( );
  50 }
  51
  52 // -------------------------------------------------------------------------
  53 ImageMPR::
  54 ~ImageMPR( )
  55 {
  56   delete this->m_UI;
  57 }
  58
  59 // -------------------------------------------------------------------------
  60 void ImageMPR::
  61 UpdateActualFilter( )
  62 {
  63   if( !( this->m_Plugins.HasActiveFilter( ) ) )
  64     return;
  65
  66   // Update filter
  67   TPlugins::TStringContainer outputs;
  68   if(
  69     !(
  70       this->m_Plugins.UpdateActiveFilter(
  71         outputs, this->m_ActiveFilterMainInput
  72         )
  73       )
  74     )
  75     return;
  76
  77   // Show outputs
  78   for( auto oIt = outputs.begin( ); oIt != outputs.end( ); ++oIt )
  79     std::cout << *oIt << std::endl;
  80
  81   /* TODO
  82      std::vector< std::string > outputs;
  83      std::string err = this->m_Plugins->UpdateActiveFilter( outputs );
  84      if( err == "" )
  85      {
  86      for( auto oIt = outputs.begin( ); oIt != outputs.end( ); ++oIt )
  87      {
  88      TPlugins::TImage* image = this->m_Plugins->GetImage( *oIt );
  89      if( image != NULL )
  90      {
  91      vtkImageData* vimage = image->GetVTK< vtkImageData >( );
  92      if( vimage != NULL )
  93      {
  94      this->m_UI->MPR->AddImage(
  95      vimage, *oIt, this->m_Plugins->GetParent( *oIt )
  96      );
  97      this->m_UI->MPR->ShowData( *oIt );
  98
  99      } // fi
 100      continue;
 101
 102      } // fi
 103
 104      TPlugins::TMesh* mesh = this->m_Plugins->GetMesh( *oIt );
 105      if( mesh != NULL )
 106      {
 107      this->m_Plugins->BlockWidget( );
 108      this->m_UI->MPR->AddMesh(
 109      mesh->GetVTK< vtkPolyData >( ),
 110      *oIt,
 111      this->m_Plugins->GetParent( *oIt )
 112      );
 113      this->m_UI->MPR->ShowData( *oIt );
 114      this->m_Plugins->UnblockWidget( );
 115
 116      } // fi
 117
 118      } // rof
 119      }
 120      else
 121      {
 122      QMessageBox::critical(
 123      this,
 124      tr( "Error executing filter" ),
 125      tr( ( std::string( "Error caught: " ) + err ).c_str( ) )
 126      );
 127      return;
 128
 129      } // fi
 130   */
 131 }
 132
 133 // -------------------------------------------------------------------------
 134 void ImageMPR::
 135 _AssociatePluginsToMenu( )
 136 {
 137   this->m_UI->MenuFilters->clear( );
 138
 139   TPlugins::TStringContainer categories;
 140   this->m_Plugins.GetLoadedCategories( categories );
 141   for( auto cIt = categories.begin( ); cIt != categories.end( ); ++cIt )
 142   {
 143     QMenu* category = this->m_UI->MenuFilters->addMenu( cIt->c_str( ) );
 144     const TPlugins::TStringContainer& filters =
 145       this->m_Plugins.GetLoadedFilters( *cIt );
 146     for( auto fIt = filters.begin( ); fIt != filters.end( ); ++fIt )
 147     {
 148       QAction* filter = category->addAction( fIt->c_str( ) );
 149       this->connect(
 150         filter, SIGNAL( triggered( ) ),
 151         this, SLOT( _execPlugin( ) )
 152         );
 153
 154     } // rof
 155
 156   } // rof
 157 }
 158
 159 // -------------------------------------------------------------------------
 160 #define ImageMPR_ReadImage( F )                                         \
 161   this->m_UI->MPR->DeleteAllData( );                                    \
 162   this->m_Plugins.ClearDataObjects( );                                  \
 163   try                                                                   \
 164   {                                                                     \
 165     std::string name = this->m_Plugins.Read##F( "" );                   \
 166     if( name == "" )                                                    \
 167       return;                                                           \
 168     TImage* image = this->m_Plugins.GetData< TImage >( name );          \
 169     vtkImageData* vimage = image->GetVTK< vtkImageData >( );            \
 170     if( vimage != NULL )                                                \
 171     {                                                                   \
 172       this->m_UI->MPR->AddImage( vimage, name );                        \
 173       this->m_UI->MPR->ShowData( name );                                \
 174     }                                                                   \
 175     else                                                                \
 176       QMessageBox::critical(                                            \
 177         this,                                                           \
 178         QMessageBox::tr( "Error showing image." ),                      \
 179         QMessageBox::tr( "Image read, but no valid VTK conversion found." ) \
 180         );                                                              \
 181   }                                                                     \
 182   catch( std::exception& err )                                          \
 183   {                                                                     \
 184     QMessageBox::critical(                                              \
 185       this,                                                             \
 186       QMessageBox::tr( "Error reading image." ),                        \
 187       QMessageBox::tr( err.what( ) )                                    \
 188       );                                                                \
 189   }
 190
 191 void ImageMPR::_aOpenImage( )       { ImageMPR_ReadImage( Image ) }
 192 void ImageMPR::_aOpenDICOMSeries( ) { ImageMPR_ReadImage( DicomSeries ) }
 193
 194 // -------------------------------------------------------------------------
 195 void ImageMPR::
 196 _aOpenSegmentation( )
 197 {
 198   /*
 199     if( this->m_ImageLoaded != "" )
 200     this->m_ImageLoaded = this->m_UI->MPR->LoadImage( );
 201   */
 202 }
 203
 204 // -------------------------------------------------------------------------
 205 void ImageMPR::
 206 _aOpenPolyData( )
 207 {
 208 }
 209
 210 // -------------------------------------------------------------------------
 211 void ImageMPR::
 212 _aSaveImage( )
 213 {
 214   /*
 215     std::string data_name = this->m_UI->MPR->GetSelectedData( );
 216     this->m_Plugins->WriteImage( data_name );
 217   */
 218 }
 219
 220 // -------------------------------------------------------------------------
 221 void ImageMPR::
 222 _aSaveSegmentation( )
 223 {
 224 }
 225
 226 // -------------------------------------------------------------------------
 227 void ImageMPR::
 228 _aSavePolyData( )
 229 {
 230 }
 231
 232 // -------------------------------------------------------------------------
 233 void ImageMPR::
 234 _aUndo( )
 235 {
 236 }
 237
 238 // -------------------------------------------------------------------------
 239 void ImageMPR::
 240 _aRedo( )
 241 {
 242 }
 243
 244 // -------------------------------------------------------------------------
 245 void ImageMPR::
 246 _aLoadPlugins( )
 247 {
 248   this->m_Plugins.DialogLoadPlugins( );
 249   this->_AssociatePluginsToMenu( );
 250 }
 251
 252 // -------------------------------------------------------------------------
 253 void ImageMPR::
 254 _aShowPlugins( )
 255 {
 256 }
 257
 258 // -------------------------------------------------------------------------
 259 void ImageMPR::
 260 _execPlugin( )
 261 {
 262   // Get filter's name
 263   QAction* action = dynamic_cast< QAction* >( this->sender( ) );
 264   if( action == NULL )
 265     return;
 266   std::string filter_name = action->text( ).toStdString( );
 267
 268   // Activate filter
 269   if( !( this->m_Plugins.ActivateFilter( filter_name ) ) )
 270     return;
 271
 272   // Get IO names
 273   TPlugins::TStringContainer inputs;
 274   this->m_Plugins.GetActiveFilterInputsNames( inputs );
 275
 276   // Configure inputs
 277   if( inputs.size( ) > 1 )
 278   {
 279     // TODO
 280   }
 281   else if( inputs.size( ) == 1 )
 282   {
 283     this->m_ActiveFilterMainInput = this->m_UI->MPR->GetSelectedData( );
 284     this->m_Plugins.ConnectInputInActiveFilter(
 285       this->m_ActiveFilterMainInput, *( inputs.begin( ) )
 286       );
 287
 288   } // fi
 289
 290   // Configure paramereters
 291   auto dlg_res = this->m_Plugins.ConfigureActiveFilter( );
 292   if( dlg_res == TPlugins::TProcessObject::DialogResult_Cancel )
 293   {
 294     // Just deactivate filter, since it was canceled
 295     this->m_Plugins.DeactivateFilter( );
 296     return;
 297   }
 298   else if( dlg_res == TPlugins::TProcessObject::DialogResult_NoModal )
 299   {
 300     // Execute automatic filter and associate outputs
 301     this->UpdateActualFilter( );
 302     this->m_Plugins.DeactivateFilter( );
 303
 304   } // fi
 305 }
 306
 307 // -------------------------------------------------------------------------
 308 /* TODO
 309    void ImageMPR::
 310    _CursorCommand( double* pos, int axis, void* data )
 311    {
 312    Self* app = reinterpret_cast< Self* >( data );
 313    if( app == NULL )
 314    return;
 315    if( !( app->m_Flooding ) )
 316    return;
 317
 318    cpPlugins::Interface::ProcessObject::Pointer filter =
 319    app->m_UI->MPR->CreateFilter(
 320    "cpPlugins::BasicFilters::FloodFillImageFilter"
 321    );
 322    if( filter.IsNull( ) )
 323    return;
 324
 325    cpPlugins::Interface::Parameters* params = filter->GetParameters( );
 326    params->SetPoint( "Seed", 3, pos );
 327    params->SetReal( "Window", app->m_UI->MPR->GetWindow( ) );
 328    params->SetReal( "Level", app->m_UI->MPR->GetLevel( ) );
 329    params->SetUint( "InsideValue", 1 );
 330    params->SetUint( "OutsideValue", 0 );
 331    filter->SetInput( "Input", app->m_UI->MPR->GetImage( app->m_ImageLoaded ) );
 332    app->m_UI->MPR->Block( );
 333    std::string err = filter->Update( );
 334    cpPlugins::Interface::BaseMPRWindow::TImage::Pointer image = filter->GetOutput< cpPlugins::Interface::BaseMPRWindow::TImage >( "Output" );
 335    filter->DisconnectOutputs( );
 336    app->m_UI->MPR->AddImage( "Segmentation", image );
 337    app->m_UI->MPR->Unblock( );
 338
 339    std::cout
 340    << "CursorCommand ==> "
 341    << pos[ 0 ] << " "
 342    << pos[ 1 ] << " "
 343    << pos[ 2 ] << " : "
 344    << axis << " "
 345    << data << std::endl;
 346    }
 347 */
 348
 349 /*
 350 #include "MementoState.h"
 351
 352 #include <vtkProperty.h>
 353 #include <vtkRenderWindow.h>
 354 #include <vtkMetaImageReader.h>
 355
 356 #include <QFileDialog>
 357 #include <QMessageBox>
 358
 359 #ifdef _WIN32
 360 #  define PLUGIN_PREFIX ""
 361 #  define PLUGIN_EXT "dll"
 362 #  define PLUGIN_REGEX "Plugins file (*.dll);;All files (*)"
 363 #else
 364 #  define PLUGIN_PREFIX "lib"
 365 #  define PLUGIN_EXT "so"
 366 #  define PLUGIN_REGEX "Plugins file (*.so);;All files (*)"
 367 #endif // _WIN32
 368
 369 // -------------------------------------------------------------------------
 370 ImageMPR::ImageMPR( QWidget* parent )
 371   : QMainWindow( parent ),
 372     m_UI( new Ui::ImageMPR ),
 373     m_ImageReaderClass( "" ),
 374     m_ImageWriterClass( "" ),
 375     m_MeshReaderClass( "" ),
 376     m_MeshWriterClass( "" ),
 377     m_MeshCutterClass( "" ),
 378     m_Image( NULL ),
 379         m_state(0),
 380         m_max_state(0)
 381 {
 382   this->m_UI->setupUi( this );
 383
 384   // Create and associate renderers
 385   this->m_MPRObjects = vtkSmartPointer< TMPRObjects >::New( );
 386   this->m_MPRObjects->SetRenderWindows(
 387     this->m_UI->m_XPlaneVTK->GetRenderWindow( ),
 388     this->m_UI->m_YPlaneVTK->GetRenderWindow( ),
 389     this->m_UI->m_ZPlaneVTK->GetRenderWindow( ),
 390     this->m_UI->m_3DVTK->GetRenderWindow( )
 391     );
 392
 393   // signals <-> slots
 394   QObject::connect(
 395     this->m_UI->actionOpenPlugins, SIGNAL( triggered( ) ),
 396     this, SLOT( _triggered_actionOpenPlugins( ) )
 397     );
 398   QObject::connect(
 399     this->m_UI->actionOpenInputImage, SIGNAL( triggered( ) ),
 400     this, SLOT( _triggered_actionOpenInputImage( ) )
 401     );
 402   QObject::connect(
 403     this->m_UI->actionOpenSegmentation, SIGNAL( triggered( ) ),
 404     this, SLOT( _triggered_actionOpenSegmentation( ) )
 405     );
 406   QObject::connect(
 407     this->m_UI->actionOpenInputPolyData, SIGNAL( triggered( ) ),
 408     this, SLOT( _triggered_actionOpenInputPolyData( ) )
 409     );
 410   QObject::connect(
 411         this->m_UI->actionUndo, SIGNAL(triggered()),
 412         this, SLOT(_triggered_actionUndo())
 413         );
 414   QObject::connect(
 415         this->m_UI->actionRedo, SIGNAL(triggered()),
 416         this, SLOT(_triggered_actionRedo())
 417         );
 418
 419   // Start: load all disponible plugins
 420   this->_LoadPlugins(
 421     std::string( PLUGIN_PREFIX ) +
 422     std::string( "cpPluginsIO." ) +
 423     std::string( PLUGIN_EXT )
 424     );
 425   this->_LoadPlugins(
 426     std::string( PLUGIN_PREFIX ) +
 427     std::string( "cpPluginsBasicFilters." ) +
 428     std::string( PLUGIN_EXT )
 429     );
 430 }
 431
 432 // -------------------------------------------------------------------------
 433 ImageMPR::
 434 ~ImageMPR( )
 435 {
 436   // Close all connections
 437   this->m_Plugins.UnloadAll( );
 438
 439   // Delete objects
 440   delete this->m_UI;
 441 }
 442
 443 // -------------------------------------------------------------------------
 444 bool ImageMPR::
 445 _LoadPlugins( const std::string& filename )
 446 {
 447   QApplication::setOverrideCursor( Qt::WaitCursor );
 448   this->setEnabled( false );
 449
 450   this->m_ImageReaderClass = "";
 451   this->m_ImageWriterClass = "";
 452   this->m_MeshReaderClass = "";
 453   this->m_MeshWriterClass = "";
 454   this->m_MeshCutterClass = "";
 455   this->m_UI->MenuImageToImage->clear( );
 456   this->m_UI->MenuImageToMesh->clear( );
 457
 458   if( !( this->m_Plugins.Load( filename ) ) )
 459     return( false );
 460
 461   typedef TPluginsInterface::TClasses _TClasses;
 462   _TClasses::const_iterator cIt = this->m_Plugins.GetClasses( ).begin( );
 463   for( ; cIt != this->m_Plugins.GetClasses( ).end( ); ++cIt )
 464   {
 465     TPluginFilter::Pointer o =
 466       this->m_Plugins.CreateProcessObject( cIt->first );
 467     std::string name = o->GetClassName( );
 468     std::string category = o->GetClassCategory( );
 469     if( category == "ImageReader" )
 470       this->m_ImageReaderClass = name;
 471     else if( category == "ImageWriter" )
 472       this->m_ImageWriterClass = name;
 473     else if( category == "MeshReader" )
 474       this->m_MeshReaderClass = name;
 475     else if( category == "MeshWriter" )
 476       this->m_MeshWriterClass = name;
 477     else if( category == "MeshToMeshFilter" )
 478     {
 479       if( name.find_last_of( "Cutter" ) != std::string::npos )
 480         this->m_MeshCutterClass = name;
 481     }
 482     else if( category == "ImageToImageFilter" )
 483     {
 484       QAction* action =
 485         this->m_UI->MenuImageToImage->addAction( QString( name.c_str( ) ) );
 486       QObject::connect(
 487         action, SIGNAL( triggered( ) ),
 488         this, SLOT( _triggered_actionImageToImage( ) )
 489         );
 490     }
 491     else if( category == "ImageToMeshFilter" )
 492     {
 493       QAction* action =
 494         this->m_UI->MenuImageToMesh->addAction( QString( name.c_str( ) ) );
 495       QObject::connect(
 496         action, SIGNAL( triggered( ) ),
 497         this, SLOT( _triggered_actionImageToMesh( ) )
 498         );
 499
 500     } // fi
 501
 502   } // rof
 503   QApplication::restoreOverrideCursor( );
 504   this->setEnabled( true );
 505
 506   return( true );
 507 }
 508
 509 // -------------------------------------------------------------------------
 510 std::string ImageMPR::
 511 _LoadImage( TPluginImage::Pointer& image )
 512 {
 513   std::string ret = "";
 514   image = NULL;
 515
 516   // Get a reader from loaded plugins
 517   TPluginFilter::Pointer reader =
 518     this->m_Plugins.CreateProcessObject( this->m_ImageReaderClass );
 519   if( reader.IsNotNull( ) )
 520   {
 521     if( reader->ExecConfigurationDialog( this ) )
 522     {
 523       // Block application
 524       QApplication::setOverrideCursor( Qt::WaitCursor );
 525       this->setEnabled( false );
 526
 527       // Execute and get error message, if any
 528       ret = reader->Update( );
 529
 530       // Assign fresh image, if any
 531       if( ret == "" )
 532       {
 533         image = reader->GetOutput< TPluginImage >( 0 );
 534         reader->DisconnectOutputs( );
 535
 536       } // fi
 537
 538       // Unblock application
 539       QApplication::restoreOverrideCursor( );
 540       this->setEnabled( true );
 541
 542     } // fi
 543   }
 544   else
 545     ret = "No suitable reader object found in loaded plugins.";
 546
 547   return( ret );
 548 }
 549
 550 // -------------------------------------------------------------------------
 551 std::string ImageMPR::
 552 _ConfigureMeshActors( )
 553 {
 554   if( this->m_Mesh.IsNull( ) )
 555     return( "Valid mesh not found." );
 556
 557   this->m_Mesh->CreateVTKActor( );
 558   vtkActor* vtk_actor = this->m_Mesh->GetVTKActor( );
 559   if( vtk_actor != NULL )
 560   {
 561     this->m_MPRObjects->Get3DRenderer( )->AddActor( vtk_actor );
 562     this->m_MPRObjects->Render( 4 );
 563
 564   } // fi
 565
 566   TMPRObjects::TMPRActors* mprActors = this->m_MPRObjects->GetMPRActors( );
 567
 568   std::string err = "";
 569   for( unsigned int i = 0; i < 3; ++i )
 570   {
 571     this->m_Cutters[ i ] = this->m_Plugins.CreateProcessObject( this->m_MeshCutterClass );
 572     this->m_Planes[ i ] = TPluginImplicitFunction::New( );
 573     this->m_Planes[ i ]->SetFunction( mprActors->GetSliceActors( i )->GetPlaneFunction( ) );
 574     this->m_Cutters[ i ]->SetInput( 0, this->m_Mesh );
 575     this->m_Cutters[ i ]->SetInput( 1, this->m_Planes[ i ] );
 576     std::string lerr = this->m_Cutters[ i ]->Update( );
 577     if( lerr == "" )
 578     {
 579       this->m_Cutters[ i ]->GetOutput< TPluginMesh >( 0 )->CreateVTKActor( );
 580       vtkActor* actor = this->m_Cutters[ i ]->GetOutput< TPluginMesh >( 0 )->GetVTKActor( );
 581       mprActors->GetSliceActors( i )->AddActor( this->m_Cutters[ i ]->GetVTK< vtkAlgorithm >( ), actor );
 582       if( i == 0 )
 583         this->m_MPRObjects->GetXRenderer( )->AddActor( actor );
 584       else if( i == 1 )
 585         this->m_MPRObjects->GetYRenderer( )->AddActor( actor );
 586       else if( i == 2 )
 587         this->m_MPRObjects->GetZRenderer( )->AddActor( actor );
 588
 589     } // fi
 590     err += lerr;
 591
 592   } // rof
 593   this->m_MPRObjects->RenderAll( );
 594   return( err );
 595 }
 596
 597 // -------------------------------------------------------------------------
 598 void ImageMPR::
 599 _triggered_actionOpenPlugins( )
 600 {
 601   // Show dialog and check if it was accepted
 602   QFileDialog dialog( this );
 603   dialog.setFileMode( QFileDialog::ExistingFile );
 604   dialog.setDirectory( "." );
 605   dialog.setNameFilter( tr( PLUGIN_REGEX ) );
 606   dialog.setDefaultSuffix( tr( PLUGIN_EXT ) );
 607   if( !( dialog.exec( ) ) )
 608     return;
 609
 610   std::string fname = dialog.selectedFiles( ).at( 0 ).toStdString( );
 611   if( !( _LoadPlugins( fname ) ) )
 612     QMessageBox::critical(
 613       this,
 614       tr( "Ignoring plugin" ),
 615       tr( fname.c_str( ) )
 616       );
 617 }
 618
 619 // -------------------------------------------------------------------------
 620 void ImageMPR::
 621 _triggered_actionOpenInputImage( )
 622 {
 623   // Read image
 624   std::string err = this->_LoadImage( this->m_Image );
 625   if( err == "" )
 626   {
 627     vtkImageData* vtk_id = this->m_Image->GetVTK< vtkImageData >( );
 628     if( vtk_id != NULL )
 629     {
 630       this->m_MPRObjects->SetImage( vtk_id );
 631       this->m_MPRObjects->ActivateInteractors( );
 632       this->m_MPRObjects->ResetCameras( );
 633       this->m_MPRObjects->RenderAll( );
 634
 635           MementoState(m_state, this->m_Image);
 636           this->m_state++;
 637     }
 638     else
 639       QMessageBox::critical(
 640         this,
 641         tr( "Error message" ),
 642         tr( "Read image does not have a valid VTK converter." )
 643         );
 644   }
 645   else
 646     QMessageBox::critical(
 647       this,
 648       tr( "Error reading single image" ),
 649       tr( err.c_str( ) )
 650       );
 651 }
 652
 653 // -------------------------------------------------------------------------
 654 void ImageMPR::
 655 _triggered_actionOpenSegmentation( )
 656 {
 657   if( this->m_Image.IsNull( ) )
 658   {
 659     QMessageBox::critical(
 660       this,
 661       tr( "Error message" ),
 662       tr( "Before reading a segmentation, first load a raw image." )
 663       );
 664     return;
 665
 666   } // fi
 667
 668   // Read image
 669   std::string err = this->_LoadImage( this->m_Segmentation );
 670   if( err == "" )
 671   {
 672     vtkImageData* vtk_id = this->m_Segmentation->GetVTK< vtkImageData >( );
 673     if( vtk_id != NULL )
 674     {
 675       this->m_MPRObjects->AddAuxiliaryImage( vtk_id );
 676       this->m_MPRObjects->RenderAll( );
 677     }
 678     else
 679       QMessageBox::critical(
 680         this,
 681         tr( "Error message" ),
 682         tr( "Read image does not have a valid VTK converter." )
 683         );
 684   }
 685   else
 686     QMessageBox::critical(
 687       this,
 688       tr( "Error reading single image" ),
 689       tr( err.c_str( ) )
 690       );
 691 }
 692
 693 // -------------------------------------------------------------------------
 694 void ImageMPR::
 695 _triggered_actionOpenInputPolyData( )
 696 {
 697   this->m_Mesh = NULL;
 698
 699   // Get a reader from plugins
 700   TPluginFilter::Pointer reader =
 701     this->m_Plugins.CreateProcessObject( this->m_MeshReaderClass );
 702
 703   if( reader.IsNotNull( ) )
 704   {
 705     // Configure reader
 706     if( reader->ExecConfigurationDialog( this ) )
 707     {
 708       // Execute and get error message, if any
 709       QApplication::setOverrideCursor( Qt::WaitCursor );
 710       this->setEnabled( false );
 711       std::string err = reader->Update( );
 712       QApplication::restoreOverrideCursor( );
 713       this->setEnabled( true );
 714
 715       // Assign fresh mesh, if any
 716       if( err == "" )
 717       {
 718         this->m_Mesh = reader->GetOutput< TPluginMesh >( 0 );
 719         reader->DisconnectOutputs( );
 720         err = this->_ConfigureMeshActors( );
 721         if( err != "" )
 722           QMessageBox::critical(
 723             this,
 724             tr( "Error message" ),
 725             tr( err.c_str( ) )
 726             );
 727       }
 728       else
 729         QMessageBox::critical(
 730           this,
 731           tr( "Error reading mesh" ),
 732           tr( err.c_str( ) )
 733           );
 734
 735     } // fi
 736   }
 737   else
 738     QMessageBox::critical(
 739       this,
 740       tr( "Error reading single mesh" ),
 741       tr( "No suitable mesh reader found in loaded plugins." )
 742       );
 743 }
 744
 745 // -------------------------------------------------------------------------
 746 void ImageMPR::
 747 _triggered_actionImageToImage( )
 748 {
 749   if( this->m_Image.IsNull( ) )
 750     return;
 751
 752   // Get filter name
 753   QAction* action = dynamic_cast< QAction* >( this->sender( ) );
 754   if( action == NULL )
 755     return;
 756   std::string name = action->text( ).toStdString( );
 757
 758   // Configure filter
 759   TPluginFilter::Pointer filter =
 760     this->m_Plugins.CreateProcessObject( name );
 761   bool dlg_ok = filter->ExecConfigurationDialog( NULL );
 762   if( !dlg_ok )
 763     return;
 764
 765   // Execute filter
 766   QApplication::setOverrideCursor( Qt::WaitCursor );
 767   this->setEnabled( false );
 768   filter->SetInput( 0, this->m_Image );
 769   std::string err = filter->Update( );
 770   QApplication::restoreOverrideCursor( );
 771   this->setEnabled( true );
 772
 773   // Update image
 774   if( err == "" )
 775   {
 776     TPluginImage* result = filter->GetOutput< TPluginImage >( 0 );
 777     result->DisconnectPipeline( );
 778     this->m_Image = result;
 779     if( this->m_Image.IsNotNull( ) )
 780       this->m_MPRObjects->SetImage(
 781         this->m_Image->GetVTK< vtkImageData >( )
 782
 783                 );
 784
 785
 786         MementoState(this->m_state, this->m_Image);
 787         this->m_state++;
 788         if (this->m_state > this->m_max_state)
 789         {
 790                 this->m_max_state = this->m_state;
 791         }
 792   }
 793   else
 794     QMessageBox::critical(
 795       this,
 796       tr( "Error executing filter" ),
 797       tr( err.c_str( ) )
 798       );
 799 }
 800
 801 // -------------------------------------------------------------------------
 802 void ImageMPR::
 803 _triggered_actionImageToMesh( )
 804 {
 805   if( this->m_Image.IsNull( ) )
 806     return;
 807
 808   // Get filter name
 809   QAction* action = dynamic_cast< QAction* >( this->sender( ) );
 810   if( action == NULL )
 811     return;
 812   std::string name = action->text( ).toStdString( );
 813
 814   // Configure filter
 815   TPluginFilter::Pointer filter =
 816     this->m_Plugins.CreateProcessObject( name );
 817   bool dlg_ok = filter->ExecConfigurationDialog( NULL );
 818   if( !dlg_ok )
 819     return;
 820
 821   // Execute filter
 822   QApplication::setOverrideCursor( Qt::WaitCursor );
 823   this->setEnabled( false );
 824   filter->SetInput( 0, this->m_Image );
 825   std::string err = filter->Update( );
 826   QApplication::restoreOverrideCursor( );
 827   this->setEnabled( true );
 828
 829   // Update image
 830   if( err == "" )
 831   {
 832     TPluginMesh* result = filter->GetOutput< TPluginMesh >( 0 );
 833     result->DisconnectPipeline( );
 834     this->m_Mesh = result;
 835     err = this->_ConfigureMeshActors( );
 836     if( err != "" )
 837       QMessageBox::critical(
 838         this,
 839         tr( "Error message" ),
 840         tr( err.c_str( ) )
 841         );
 842   }
 843   else
 844     QMessageBox::critical(
 845       this,
 846       tr( "Error executing filter" ),
 847       tr( err.c_str( ) )
 848       );
 849 }
 850
 851 // -------------------------------------------------------------------------
 852 void ImageMPR::
 853 _triggered_actionUndo()
 854 {
 855         MementoState memento = MementoState();
 856
 857         if (this->m_state>1)
 858         {
 859                 this->m_state--;
 860                 this->m_MPRObjects->SetImage(
 861                         memento.getMemento(this->m_state)->GetOutput()
 862                         );
 863         } else
 864         {
 865                 QMessageBox::warning(
 866                         this,
 867                         tr("message"),
 868                         tr("No history to undo")
 869                         );
 870         }
 871
 872 }
 873
 874 // -------------------------------------------------------------------------
 875 void ImageMPR::
 876 _triggered_actionRedo()
 877 {
 878         MementoState memento = MementoState();
 879                 if (this->m_state + 1 <= m_max_state)
 880                 {
 881                         this->m_state++;
 882                         this->m_MPRObjects->SetImage(
 883                                 memento.getMemento(this->m_state)->GetOutput()
 884                                 );
 885                 } else
 886                 {
 887                         QMessageBox::warning(
 888                                 this,
 889                                 tr("message"),
 890                                 tr("No history to redo")
 891                                 );
 892                 }
 893
 894 }
 895
 896 */
 897
 898 // eof - $RCSfile$