lib/cpPlugins/Interface/BaseMPRWindow.cxx

   1 #include <cpPlugins/Interface/BaseMPRWindow.h>
   2
   3 #ifdef cpPlugins_Interface_QT4
   4
   5 #ifdef _WIN32
   6 #  define PLUGIN_PREFIX ""
   7 #  define PLUGIN_EXT "dll"
   8 #  define PLUGIN_REGEX "Plugins file (*.dll);;All files (*)"
   9 #else // Linux
  10 #  define PLUGIN_PREFIX "lib"
  11 #  define PLUGIN_EXT "so"
  12 #  define PLUGIN_REGEX "Plugins file (*.so);;All files (*)"
  13 #endif // _WIN32
  14
  15 #include <fstream>
  16 #include <sstream>
  17
  18 #include <QFileDialog>
  19 #include <QMessageBox>
  20
  21 // -------------------------------------------------------------------------
  22 cpPlugins::Interface::BaseMPRWindow::
  23 BaseMPRWindow( QWidget* parent )
  24   : cpExtensions::QT::QuadSplitter( parent ),
  25     m_LastLoadedPlugin( "." )
  26 {
  27   // Configure splitter
  28   this->m_XVTK = new QVTKWidget( this );
  29   this->m_YVTK = new QVTKWidget( this );
  30   this->m_ZVTK = new QVTKWidget( this );
  31   this->m_WVTK = new QVTKWidget( this );
  32   this->addWidgets( this->m_YVTK, this->m_XVTK, this->m_ZVTK, this->m_WVTK );
  33
  34   // Create and associate vtk renderers
  35   this->m_MPRObjects = vtkSmartPointer< TMPRObjects >::New( );
  36   this->m_MPRObjects->SetRenderWindows(
  37     this->m_XVTK->GetRenderWindow( ),
  38     this->m_YVTK->GetRenderWindow( ),
  39     this->m_ZVTK->GetRenderWindow( ),
  40     this->m_WVTK->GetRenderWindow( )
  41     );
  42 }
  43
  44 // -------------------------------------------------------------------------
  45 cpPlugins::Interface::BaseMPRWindow::
  46 ~BaseMPRWindow( )
  47 {
  48   if( this->m_WVTK != NULL )
  49     delete this->m_WVTK;
  50   if( this->m_ZVTK != NULL )
  51     delete this->m_ZVTK;
  52   if( this->m_YVTK != NULL )
  53     delete this->m_YVTK;
  54   if( this->m_XVTK != NULL )
  55     delete this->m_XVTK;
  56 }
  57
  58 // -------------------------------------------------------------------------
  59 void cpPlugins::Interface::BaseMPRWindow::
  60 DialogLoadPlugins( )
  61 {
  62   // Show dialog and check if it was accepted
  63   QFileDialog dialog( this );
  64   dialog.setFileMode( QFileDialog::ExistingFile );
  65   dialog.setDirectory( this->m_LastLoadedPlugin.c_str( ) );
  66   dialog.setNameFilter( tr( PLUGIN_REGEX ) );
  67   dialog.setDefaultSuffix( tr( PLUGIN_EXT ) );
  68   if( !( dialog.exec( ) ) )
  69     return;
  70
  71   std::string fname = dialog.selectedFiles( ).at( 0 ).toStdString( );
  72   if( !( this->LoadPlugins( fname ) ) )
  73     QMessageBox::critical(
  74       this, tr( "Ignoring plugin" ), tr( fname.c_str( ) )
  75       );
  76 }
  77
  78 // -------------------------------------------------------------------------
  79 void cpPlugins::Interface::BaseMPRWindow::
  80 AssociatePluginsToMenu( QMenu* menu, QObject* obj, const char* slot )
  81 {
  82   std::map< std::string, std::set< std::string > >::const_iterator i;
  83   std::set< std::string >::const_iterator j;
  84
  85   menu->clear( );
  86   for( i = this->m_Filters.begin( ); i != this->m_Filters.end( ); i++ )
  87   {
  88     QMenu* newMenu = menu->addMenu( i->first.c_str( ) );
  89     for( j = i->second.begin( ); j != i->second.end( ); ++j )
  90     {
  91       QAction* a = newMenu->addAction( j->c_str( ) );
  92       QObject::connect( a, SIGNAL( triggered( ) ), obj, slot );
  93
  94     } // rof
  95
  96   } // rof
  97 }
  98
  99 // -------------------------------------------------------------------------
 100 bool cpPlugins::Interface::BaseMPRWindow::
 101 LoadPlugins( const std::string& fname )
 102 {
 103   this->Block( );
 104
 105   // Is it already loaded?
 106   if( this->m_LoadedPlugins.find( fname ) != this->m_LoadedPlugins.end( ) )
 107   {
 108     this->Unblock( );
 109     return( true );
 110
 111   } // fi
 112
 113   // Was it succesfully loaded?
 114   if( !( this->m_Interface.Load( fname ) ) )
 115   {
 116     this->Unblock( );
 117     return( false );
 118
 119   } // fi
 120
 121   // Update a simple track
 122   this->m_LoadedPlugins.insert( fname );
 123   this->m_LastLoadedPlugin = fname;
 124   this->_UpdatePlugins( );
 125
 126   this->Unblock( );
 127   return( true );
 128 }
 129
 130 // -------------------------------------------------------------------------
 131 void cpPlugins::Interface::BaseMPRWindow::
 132 LoadPlugins( )
 133 {
 134   // Load file into a char buffer
 135   std::ifstream in(
 136     "Plugins.cfg", std::ios::in | std::ios::binary | std::ios::ate
 137     );
 138   if( !in.is_open( ) )
 139     return;
 140   std::streampos size = in.tellg( );
 141   char* buffer = new char[ size ];
 142   in.seekg( 0, std::ios::beg );
 143   in.read( buffer, size );
 144   in.close( );
 145
 146   // Read stream
 147   std::stringstream in_stream( buffer );
 148   while( in_stream )
 149   {
 150     char line[ 2048 ];
 151     in_stream.getline( line, 2048 );
 152     this->LoadPlugins( line );
 153
 154   } // elihw
 155
 156   // Finish
 157   delete buffer;
 158 }
 159
 160 // -------------------------------------------------------------------------
 161 std::string cpPlugins::Interface::BaseMPRWindow::
 162 LoadImage( )
 163 {
 164   std::string msg = "";
 165   std::string ret = "";
 166   if( this->m_ImageReader.IsNull( ) )
 167     msg = "No valid image reader. Please load a valid plugin file.";
 168
 169   if( this->m_ImageReader->ExecConfigurationDialog( this ) )
 170   {
 171     this->Block( );
 172     msg = this->m_ImageReader->Update( );
 173     if( msg == "" )
 174     {
 175       TImage::Pointer image =
 176         this->m_ImageReader->GetOutput< TImage >( "Output" );
 177       if( this->m_Images.size( ) == 0 )
 178         ret = image->GetName( );
 179       else
 180         ret = "Segmentation";
 181       this->m_Images[ ret ] = image;
 182       this->m_ImageReader->DisconnectOutputs( );
 183       this->m_ImageReader->GetParameters( )->ClearStringList( "FileNames" );
 184       vtkImageData* vtk_id = image->GetVTK< vtkImageData >( );
 185       if( vtk_id != NULL )
 186       {
 187         this->m_MPRObjects->AddImage( vtk_id );
 188         /*
 189           MementoState(m_state, this->m_Image);
 190           this->m_state++;
 191         */
 192       }
 193       else
 194         msg = "Read image does not have a valid VTK converter.";
 195     }
 196     else
 197       ret = "";
 198
 199   } // fi
 200
 201   // Show errors and return
 202   this->Unblock( );
 203   if( msg != "" )
 204     QMessageBox::critical(
 205       this, tr( "Error reading image." ), tr( msg.c_str( ) )
 206       );
 207   return( ret );
 208 }
 209
 210 // -------------------------------------------------------------------------
 211 std::string cpPlugins::Interface::BaseMPRWindow::
 212 LoadMesh( )
 213 {
 214   return( "" );
 215 }
 216
 217 // -------------------------------------------------------------------------
 218 void cpPlugins::Interface::BaseMPRWindow::
 219 ExecuteFilter(
 220   const std::string& name,
 221   const std::string& input_id,
 222   const std::string& output_id
 223   )
 224 {
 225   TProcessObject::Pointer filter =
 226     this->m_Interface.CreateProcessObject( name );
 227   std::string category = filter->GetClassCategory( );
 228   if( category == "ImageToBinaryImageFilter" )
 229   {
 230     TImages::iterator iIt = this->m_Images.find( input_id );
 231     if( iIt != this->m_Images.end( ) )
 232     {
 233       filter->SetInput( "Input", this->m_Images[ input_id ] );
 234       bool dlg_ok = filter->ExecConfigurationDialog( NULL );
 235       if( !dlg_ok )
 236         return;
 237
 238       std::string err = filter->Update( );
 239       std::cout << "ERR: " << err << std::endl;
 240       if( err == "" )
 241       {
 242         this->m_Images[ "Segmentation" ] =
 243           filter->GetOutput< TImage >( "Output" );
 244         filter->DisconnectOutputs( );
 245
 246         vtkImageData* vtk_id =
 247           this->m_Images[ "Segmentation" ]->GetVTK< vtkImageData >( );
 248         if( vtk_id != NULL )
 249           this->m_MPRObjects->AddImage( vtk_id );
 250       }
 251       else
 252         QMessageBox::critical(
 253           this, tr( "Error with plugin" ), tr( err.c_str( ) )
 254           );
 255
 256     } // fi
 257
 258   } // fi
 259 }
 260
 261 // -------------------------------------------------------------------------
 262 void cpPlugins::Interface::BaseMPRWindow::
 263 AddImage( const std::string& name, TImage* image )
 264 {
 265   this->m_Images[ name ] = image;
 266   vtkImageData* vtk_id =
 267     this->m_Images[ name ]->GetVTK< vtkImageData >( );
 268   if( vtk_id != NULL )
 269     this->m_MPRObjects->AddImage( vtk_id );
 270 }
 271
 272 // -------------------------------------------------------------------------
 273 void cpPlugins::Interface::BaseMPRWindow::
 274 ClearAll( )
 275 {
 276   this->m_MPRObjects->ClearAll( );
 277   this->m_Images.clear( );
 278   this->m_Meshes.clear( );
 279 }
 280
 281 // -------------------------------------------------------------------------
 282 void cpPlugins::Interface::BaseMPRWindow::
 283 _UpdatePlugins( )
 284 {
 285   typedef TInterface::TClasses _C;
 286
 287   this->m_Filters.clear( );
 288   _C& classes = this->m_Interface.GetClasses( );
 289   for( _C::const_iterator i = classes.begin( ); i != classes.end( ); ++i )
 290   {
 291     TProcessObject::Pointer o =
 292       this->m_Interface.CreateProcessObject( i->first );
 293     std::string name = o->GetClassName( );
 294     std::string category = o->GetClassCategory( );
 295     if( category == "ImageReader" )
 296       this->m_ImageReader = o;
 297     else if( category == "ImageWriter" )
 298       this->m_ImageWriter = o;
 299     else if( category == "MeshReader" )
 300       this->m_MeshReader = o;
 301     else if( category == "MeshWriter" )
 302       this->m_MeshWriter = o;
 303     else
 304       this->m_Filters[ category ].insert( name );
 305
 306     /*
 307       if( category == "ImageReader" )
 308       this->m_ImageReaderClass = name;
 309       else if( category == "ImageWriter" )
 310       this->m_ImageWriterClass = name;
 311       else if( category == "MeshReader" )
 312       this->m_MeshReaderClass = name;
 313       else if( category == "MeshWriter" )
 314       this->m_MeshWriterClass = name;
 315       else if( category == "MeshToMeshFilter" )
 316       {
 317       if( name.find_last_of( "Cutter" ) != std::string::npos )
 318       this->m_MeshCutterClass = name;
 319       }
 320       else if( category == "ImageToImageFilter" )
 321       {
 322       QAction* action =
 323       this->m_UI->MenuImageToImage->addAction( QString( name.c_str( ) ) );
 324       QObject::connect(
 325       action, SIGNAL( triggered( ) ),
 326       this, SLOT( _triggered_actionImageToImage( ) )
 327       );
 328       }
 329       else if( category == "ImageToMeshFilter" )
 330       {
 331       QAction* action =
 332       this->m_UI->MenuImageToMesh->addAction( QString( name.c_str( ) ) );
 333       QObject::connect(
 334       action, SIGNAL( triggered( ) ),
 335       this, SLOT( _triggered_actionImageToMesh( ) )
 336       );
 337
 338       } // fi
 339     */
 340
 341   } // rof
 342 }
 343
 344 #endif // cpPlugins_Interface_QT4
 345
 346 // eof - $RCSfile$