writer->SetInput( "Input", reader->GetOutput( "Output" ) );
// Execute filters
- std::string err = writer->Update( );
- if( err != "" )
+ try
+ {
+ writer->Update( );
+ }
+ catch( itk::ExceptionObject& err )
{
std::cout << "Error caught: " << err << std::endl;
ret = 1;
writer_params->SetSaveFileName( "FileName", argv[ argc - 1 ] );
// Execute
- std::string err = workspace.Execute( );
- if( err != "" )
+ try
+ {
+ workspace.Execute( );
+ }
+ catch( itk::ExceptionObject& err )
{
std::cout << "Error caught: " << err << std::endl;
ret = 1;
_ExecFilter( const std::string& filter_name )
{
this->_Block( );
- std::string err = this->m_Workspace.Execute( filter_name );
- this->_UnBlock( );
- if( err != "" )
+ try
+ {
+ this->m_Workspace.Execute( filter_name );
+ this->_UnBlock( );
+ }
+ catch( itk::ExceptionObject& err1 )
+ {
QMessageBox::critical(
this,
QMessageBox::tr( "Error executing filter" ),
- QMessageBox::tr( err.c_str( ) )
+ QMessageBox::tr( err1.GetDescription( ) )
);
+ this->_UnBlock( );
+ }
+ catch( std::exception& err2 )
+ {
+ QMessageBox::critical(
+ this,
+ QMessageBox::tr( "Error executing filter" ),
+ QMessageBox::tr( err2.what( ) )
+ );
+ this->_UnBlock( );
+ }
+ catch( ... )
+ {
+ QMessageBox::critical(
+ this,
+ QMessageBox::tr( "Error executing filter" ),
+ QMessageBox::tr( "Unknown error" )
+ );
+ this->_UnBlock( );
+
+ } // yrt
}
// eof - $RCSfile$
* Demangle macros
* =========================================================================
*/
-#define cpPlugin_Image_Demangle_Dim( FUNC, INPUT, D ) \
- this->FUNC( INPUT->GetITK< itk::ImageBase< D > >( ) )
-
-#define cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, PIXEL, D ) \
- this->FUNC( dynamic_cast< itk::Image< PIXEL, D >* >( INPUT ) )
-
-#define cpPlugin_Image_Demangle_VectorPixel_Dim( FUNC, INPUT, VECTOR, PIXEL, D ) \
- this->FUNC( dynamic_cast< itk::Image< VECTOR< PIXEL, D >, D >* >( INPUT ) )
-
-#define cpPlugin_Image_Demangle_Pixel_AllInts( r, FUNC, INPUT, D ) \
- r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, char, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, short, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, int, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, long, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, unsigned char, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, unsigned short, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, unsigned int, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, unsigned long, D )
-
-#define cpPlugin_Image_Demangle_Pixel_AllScalars( r, FUNC, INPUT, D ) \
- r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, char, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, short, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, int, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, long, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, float, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, double, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, unsigned char, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, unsigned short, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, unsigned int, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, unsigned long, D )
-
-#define cpPlugin_Image_Demangle_Pixel_AllColor( r, FUNC, INPUT, D ) \
- r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< char >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< short >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< int >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< long >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< float >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< double >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< unsigned char >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< unsigned short >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< unsigned int >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< unsigned long >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< char >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< short >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< int >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< long >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< float >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< double >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< unsigned char >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< unsigned short >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< unsigned int >, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< unsigned long >, D )
-
-#define cpPlugin_Image_Demangle_VectorPixel_AllFloats( r, FUNC, INPUT, VECTOR, D ) \
- r = cpPlugin_Image_Demangle_VectorPixel_Dim( FUNC, INPUT, VECTOR, float, D ); \
- if( r != "" ) r = cpPlugin_Image_Demangle_VectorPixel_Dim( FUNC, INPUT, VECTOR, double, D )
-
+#define cpPlugins_Image_Demangle_Dim( F, I, D ) \
+ if( dynamic_cast< itk::ImageBase< D >* >( I ) != NULL ) \
+ this->F( dynamic_cast< itk::ImageBase< D >* >( I ) )
+
+#define cpPlugins_Image_Demangle_Pixel_Dim( F, I, P, D ) \
+ if( dynamic_cast< itk::Image< P, D >* >( I ) != NULL ) \
+ this->F( dynamic_cast< itk::Image< P, D >* >( I ) )
+
+#define cpPlugins_Image_Demangle_ColorPixel_Dim( F, I, C, P, D ) \
+ if( dynamic_cast< itk::Image< itk::C##Pixel< P >, D >* >( I ) != NULL ) \
+ this->F( dynamic_cast< itk::Image< itk::C##Pixel< P >, D >* >( I ) )
+
+#define cpPlugins_Image_Demangle_VectorPixel_Dim( F, I, V, P, D ) \
+ if( dynamic_cast< itk::Image< V< P, D >, D >* >( I ) != NULL ) \
+ this->F( dynamic_cast< itk::Image< V< P, D >, D >* >( I ) )
+
+#define cpPlugins_Image_Demangle_Pixel_AllInts( F, I, D ) \
+ cpPlugins_Image_Demangle_Pixel_Dim ( F, I, char, D ); \
+ else cpPlugins_Image_Demangle_Pixel_Dim( F, I, short, D ); \
+ else cpPlugins_Image_Demangle_Pixel_Dim( F, I, int, D ); \
+ else cpPlugins_Image_Demangle_Pixel_Dim( F, I, long, D )
+
+#define cpPlugins_Image_Demangle_Pixel_AllUInts( F, I, D ) \
+ cpPlugins_Image_Demangle_Pixel_Dim ( F, I, unsigned char, D ); \
+ else cpPlugins_Image_Demangle_Pixel_Dim( F, I, unsigned short, D ); \
+ else cpPlugins_Image_Demangle_Pixel_Dim( F, I, unsigned int, D ); \
+ else cpPlugins_Image_Demangle_Pixel_Dim( F, I, unsigned long, D )
+
+#define cpPlugins_Image_Demangle_Pixel_AllFloats( F, I, D ) \
+ cpPlugins_Image_Demangle_Pixel_Dim ( F, I, float, D ); \
+ else cpPlugins_Image_Demangle_Pixel_Dim( F, I, double, D )
+
+#define cpPlugins_Image_Demangle_Pixel_AllScalars( F, I, D ) \
+ cpPlugins_Image_Demangle_Pixel_AllInts ( F, I, D ); \
+ else cpPlugins_Image_Demangle_Pixel_AllUInts( F, I, D ); \
+ else cpPlugins_Image_Demangle_Pixel_AllInts ( F, I, D )
+
+#define cpPlugins_Image_Demangle_ColorPixel_AllInts( F, I, C, D ) \
+ cpPlugins_Image_Demangle_ColorPixel_Dim ( F, I, C, char, D ); \
+ else cpPlugins_Image_Demangle_ColorPixel_Dim( F, I, C, short, D ); \
+ else cpPlugins_Image_Demangle_ColorPixel_Dim( F, I, C, int, D ); \
+ else cpPlugins_Image_Demangle_ColorPixel_Dim( F, I, C, long, D )
+
+#define cpPlugins_Image_Demangle_ColorPixel_AllUInts( F, I, C, D ) \
+ cpPlugins_Image_Demangle_ColorPixel_Dim ( F, I, C, unsigned char, D ); \
+ else cpPlugins_Image_Demangle_ColorPixel_Dim( F, I, C, unsigned short, D ); \
+ else cpPlugins_Image_Demangle_ColorPixel_Dim( F, I, C, unsigned int, D ); \
+ else cpPlugins_Image_Demangle_ColorPixel_Dim( F, I, C, unsigned long, D )
+
+#define cpPlugins_Image_Demangle_ColorPixel_AllFloats( F, I, C, D ) \
+ cpPlugins_Image_Demangle_ColorPixel_Dim ( F, I, C, float, D ); \
+ else cpPlugins_Image_Demangle_ColorPixel_Dim( F, I, C, double, D )
+
+#define cpPlugins_Image_Demangle_ColorPixel_AllScalars( F, I, C, D ) \
+ cpPlugins_Image_Demangle_ColorPixel_AllInts ( F, I, C, D ); \
+ else cpPlugins_Image_Demangle_ColorPixel_AllUInts( F, I, C, D ); \
+ else cpPlugins_Image_Demangle_ColorPixel_AllInts ( F, I, C, D )
+
+/* TODO
+ #define cpPlugins_Image_Demangle_Pixel_AllColor( r, FUNC, INPUT, D ) \
+ r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< char >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< short >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< int >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< long >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< float >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< double >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< unsigned char >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< unsigned short >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< unsigned int >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBPixel< unsigned long >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< char >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< short >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< int >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< long >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< float >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< double >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< unsigned char >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< unsigned short >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< unsigned int >, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_Pixel_Dim( FUNC, INPUT, itk::RGBAPixel< unsigned long >, D )
+
+ #define cpPlugins_Image_Demangle_VectorPixel_AllFloats( r, FUNC, INPUT, VECTOR, D ) \
+ r = cpPlugins_Image_Demangle_VectorPixel_Dim( FUNC, INPUT, VECTOR, float, D ); \
+ if( r != "" ) r = cpPlugins_Image_Demangle_VectorPixel_Dim( FUNC, INPUT, VECTOR, double, D )
+*/
#endif // __CPPLUGINS__IMAGE__HXX__
// eof - $RCSfile$
#include <cpPlugins/ProcessObject.h>
#include <cpPlugins/ParametersQtDialog.h>
#include <itkProcessObject.h>
-
+#include <itkExceptionObject.h>
+#include <iostream>
// -------------------------------------------------------------------------
cpPlugins::Parameters* cpPlugins::ProcessObject::
GetParameters( )
this->DisconnectOutputs( );
}
+// -------------------------------------------------------------------------
+void cpPlugins::ProcessObject::
+Modified( ) const
+{
+ this->Superclass::Modified( );
+ this->m_LastExecutionSpan = -1;
+}
+
// -------------------------------------------------------------------------
itk::ModifiedTimeType cpPlugins::ProcessObject::
GetMTime( ) const
}
// -------------------------------------------------------------------------
-std::string cpPlugins::ProcessObject::
+void cpPlugins::ProcessObject::
Update( )
{
- std::string r = "";
-
// Force upstream updates
auto i = this->m_Inputs.begin( );
bool need_to_update = false;
- for( ; i != this->m_Inputs.end( ) && r == ""; ++i )
+ for( ; i != this->m_Inputs.end( ); ++i )
{
bool iv = i->second.IsValid( );
bool ir = i->second.IsRequired( );
if( !iv && ir )
- r =
- "ProcessObject: Required input \"" +
- i->first + "@" + this->GetClassName( ) +
- "\" is not valid (=NULL).";
- if( iv && r == "" )
+ this->_Error(
+ std::string( "Required input \"" ) + i->first +
+ std::string( "\" is not valid." )
+ );
+ if( iv )
{
Self* src = dynamic_cast< Self* >( i->second->GetSource( ) );
if( src != NULL )
{
need_to_update |= ( this->m_LastExecutionTime < src->GetMTime( ) );
- r = src->Update( );
+ src->Update( );
} // fi
} // rof
// Current update
- if( r == "" )
+ if( this->m_LastExecutionTime < this->GetMTime( ) || need_to_update )
{
- if( this->m_LastExecutionTime < this->GetMTime( ) || need_to_update )
+ if( this->m_PrintExecution && this->m_PrintExecutionStream != NULL )
{
- std::cout
+ *( this->m_PrintExecutionStream )
<< "cpPlugins: Updating \""
- << this->GetClassName( ) << ":" << this->GetClassCategory( )
+ << this->GetClassCategory( ) << ":" << this->GetClassName( )
<< "\"... ";
- std::cout.flush( );
- this->m_LastExecutionSpan = cpPlugins_CHRONO;
- r = this->_GenerateData( );
- this->m_LastExecutionSpan = cpPlugins_CHRONO - this->m_LastExecutionSpan;
- this->m_LastExecutionTime = this->GetMTime( );
- std::cout << "done in " << ( double( this->m_LastExecutionSpan ) / double( 1000 ) ) << "s!" << std::endl;
+ this->m_PrintExecutionStream->flush( );
} // fi
- } // fi
+ this->m_LastExecutionSpan = cpPlugins_CHRONO;
+ this->_GenerateData( );
+ this->m_LastExecutionSpan = cpPlugins_CHRONO - this->m_LastExecutionSpan;
+ this->m_LastExecutionTime = this->GetMTime( );
+
+ if( this->m_PrintExecution && this->m_PrintExecutionStream != NULL )
+ {
+ *( this->m_PrintExecutionStream )
+ << "done in "
+ << this->m_LastExecutionSpan
+ << " ms." << std::endl;
- // Return error description, if any
- return( r );
+ } // fi
+
+ } // fi
}
// -------------------------------------------------------------------------
cpPlugins::ProcessObject::
ProcessObject( )
: Superclass( ),
- m_LastExecutionTime( 0 )
+ m_LastExecutionTime( 0 ),
+ m_LastExecutionSpan( -1 ),
+ m_PrintExecution( false ),
+ m_PrintExecutionStream( &( std::cout ) )
{
}
} // fi
}
+// -------------------------------------------------------------------------
+void cpPlugins::ProcessObject::
+_Error( const std::string& error )
+{
+ if( error != "" )
+ {
+ itkExceptionMacro(
+ "Error: \"" << this->GetClassCategory( ) << "::" <<
+ this->GetClassName( ) << "\": " << error
+ );
+
+ } // fi
+}
+
// eof - $RCSfile$
itkTypeMacro( ProcessObject, Object );
cpPlugins_Id_Macro( ProcessObject, Object );
+ itkBooleanMacro( PrintExecution );
+ itkGetConstMacro( LastExecutionSpan, long );
+ itkGetConstMacro( PrintExecution, bool );
+ itkSetMacro( PrintExecution, bool );
+ itkSetObjectMacro( PrintExecutionStream, std::ofstream );
+
public:
Parameters* GetParameters( );
const Parameters* GetParameters( ) const;
void Disconnect( );
// Pipeline execution
+ virtual void Modified( ) const ITK_OVERRIDE;
virtual itk::ModifiedTimeType GetMTime( ) const ITK_OVERRIDE;
- virtual std::string Update( );
+ virtual void Update( );
// Qt dialog creation
virtual ParametersQtDialog* CreateQtDialog( );
virtual ~ProcessObject( );
void _AddInput( const std::string& name, bool required = true );
+ void _Error( const std::string& error );
template< class O >
inline void _AddOutput( const std::string& name );
template< class F >
inline F* _CreateVTK( );
- virtual std::string _GenerateData( ) = 0;
+ virtual void _GenerateData( ) = 0;
private:
// Purposely not implemented
_TOutputs m_Outputs;
itk::ModifiedTimeType m_LastExecutionTime;
- long m_LastExecutionSpan;
+ mutable long m_LastExecutionSpan;
+
+ bool m_PrintExecution;
+ std::ostream* m_PrintExecutionStream;
};
} // ecapseman
}
// -------------------------------------------------------------------------
-std::string cpPlugins::Workspace::
+void cpPlugins::Workspace::
Execute( )
{
// Find sinks
std::set< std::string > sinks = this->m_Graph->GetSinks( );
// Update sinks
- std::string err = "";
for( auto sIt = sinks.begin( ); sIt != sinks.end( ); ++sIt )
- {
- std::string lerr = this->Execute( *sIt );
- if( lerr != "" )
- err += lerr + std::string( "\n" );
-
- } // rof
- return( err );
+ this->Execute( *sIt );
}
// -------------------------------------------------------------------------
-std::string cpPlugins::Workspace::
+void cpPlugins::Workspace::
Execute( const std::string& name )
{
// Get filter
ProcessObject* f = this->GetFilter( name );
if( f == NULL )
- return(
- std::string( "cpPlugins::Workspace: Vertex \"" ) +
- name + std::string( "\" is not a filter." )
+ {
+ itkGenericExceptionMacro(
+ "cpPlugins::Workspace: Vertex \"" << name << "\" is not a filter."
);
- // Execute and return
- return( f->Update( ) );
+ } // fi
+
+ // Execute
+ f->Update( );
}
// eof - $RCSfile$
const OutputPort& GetExposedOutput( const std::string& name ) const;
// Pipeline execution
- std::string Execute( );
- std::string Execute( const std::string& name );
+ void Execute( );
+ void Execute( const std::string& name );
protected:
// Plugins interface
}
// -------------------------------------------------------------------------
-std::string cpPluginsGenericFilters::JoinBoundingBoxes::
+void cpPluginsGenericFilters::JoinBoundingBoxes::
_GenerateData( )
{
typedef cpPlugins::DataObject _TDO;
} // fi
} // rof
- return( "" );
}
// eof - $RCSfile$
JoinBoundingBoxes( );
virtual ~JoinBoundingBoxes( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsIO::DataReproducer::
+void cpPluginsIO::DataReproducer::
_GenerateData( )
{
auto i = this->m_Inputs.find( "Input" );
auto o = this->m_Outputs.find( "Output" );
if( i == this->m_Inputs.end( ) || o == this->m_Outputs.end( ) )
- return( "IO::DataReproducer: No input/output ports." );
+ this->_Error( "No input/output ports." );
o->second->SetITK( i->second->GetITK< itk::LightObject >( ) );
o->second->SetVTK( i->second->GetVTK< vtkObjectBase >( ) );
- return( "" );
}
// eof - $RCSfile$
DataReproducer( );
virtual ~DataReproducer( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsIO::ImageReader::
+void cpPluginsIO::ImageReader::
_GenerateData( )
{
// Get filenames
auto fnames = this->m_Parameters.GetOpenFileNameList( "FileNames" );
- std::string r = "";
if( fnames.size( ) >= 1 )
{
// Guess image properties
switch( io->GetNumberOfDimensions( ) )
{
// TODO: case 1: r = this->_GD0< 1 >( io ); break;
- case 2: r = this->_GD0< 2 >( io ); break;
- case 3: r = this->_GD0< 3 >( io ); break;
+ case 2: this->_GD0< 2 >( io ); break;
+ case 3: this->_GD0< 3 >( io ); break;
// TODO: case 4: r = this->_GD0< 4 >( io ); break;
default:
- r = "IO::ImageReader: Image dimension not supported.";
+ this->_Error( "Image dimension not supported." );
break;
} // hctiws
} // fi
}
else
- r =
- "IO::ImageReader: Could not CreateImageIO for \"" +
+ this->_Error(
+ std::string( "Could not create an ImageIO for \"" ) +
fnames[ 0 ] +
- "\"";
+ std::string( "\"" )
+ );
}
else
- r = "IO::ImageReader: No image(s) given";
- return( r );
+ this->_Error( "No image(s) given" );
}
// -------------------------------------------------------------------------
template< unsigned int _Dim >
-std::string cpPluginsIO::ImageReader::
+void cpPluginsIO::ImageReader::
_GD0( itk::ImageIOBase* io )
{
typedef unsigned char uchar;
itk::ImageIOBase::IOComponentType ct = io->GetComponentType( );
itk::ImageIOBase::IOPixelType pt = io->GetPixelType( );
- std::string r = "";
if( pt == itk::ImageIOBase::SCALAR )
{
switch( ct )
{
- case itk::ImageIOBase::CHAR : r = this->_GD1< char, _Dim >( io ); break;
- case itk::ImageIOBase::SHORT : r = this->_GD1< short, _Dim >( io ); break;
- case itk::ImageIOBase::INT : r = this->_GD1< int, _Dim >( io ); break;
- case itk::ImageIOBase::LONG : r = this->_GD1< long, _Dim >( io ); break;
- case itk::ImageIOBase::FLOAT : r = this->_GD1< float, _Dim >( io ); break;
- case itk::ImageIOBase::DOUBLE : r = this->_GD1< double, _Dim >( io ); break;
- case itk::ImageIOBase::UCHAR : r = this->_GD1< uchar, _Dim >( io ); break;
- case itk::ImageIOBase::USHORT : r = this->_GD1< ushort, _Dim >( io ); break;
- case itk::ImageIOBase::UINT : r = this->_GD1< uint, _Dim >( io ); break;
- case itk::ImageIOBase::ULONG : r = this->_GD1< ulong, _Dim >( io ); break;
- default:
- r = "IO::ImageReader: Scalar pixel type not supported.";
- break;
+ case itk::ImageIOBase::CHAR : this->_GD1< char, _Dim >( io ); break;
+ case itk::ImageIOBase::SHORT : this->_GD1< short, _Dim >( io ); break;
+ case itk::ImageIOBase::INT : this->_GD1< int, _Dim >( io ); break;
+ case itk::ImageIOBase::LONG : this->_GD1< long, _Dim >( io ); break;
+ case itk::ImageIOBase::FLOAT : this->_GD1< float, _Dim >( io ); break;
+ case itk::ImageIOBase::DOUBLE : this->_GD1< double, _Dim >( io ); break;
+ case itk::ImageIOBase::UCHAR : this->_GD1< uchar, _Dim >( io ); break;
+ case itk::ImageIOBase::USHORT : this->_GD1< ushort, _Dim >( io ); break;
+ case itk::ImageIOBase::UINT : this->_GD1< uint, _Dim >( io ); break;
+ case itk::ImageIOBase::ULONG : this->_GD1< ulong, _Dim >( io ); break;
+ default: this->_Error( "Scalar pixel type not supported." ); break;
} // hctiws
}
else if( pt == itk::ImageIOBase::RGB )
{
switch( ct )
{
- case itk::ImageIOBase::CHAR : r = this->_GD1< itk::RGBPixel< char >, _Dim >( io ); break;
- case itk::ImageIOBase::SHORT : r = this->_GD1< itk::RGBPixel< short >, _Dim >( io ); break;
- case itk::ImageIOBase::INT : r = this->_GD1< itk::RGBPixel< int >, _Dim >( io ); break;
- case itk::ImageIOBase::LONG : r = this->_GD1< itk::RGBPixel< long >, _Dim >( io ); break;
- case itk::ImageIOBase::FLOAT : r = this->_GD1< itk::RGBPixel< float >, _Dim >( io ); break;
- case itk::ImageIOBase::DOUBLE : r = this->_GD1< itk::RGBPixel< double >, _Dim >( io ); break;
- case itk::ImageIOBase::UCHAR : r = this->_GD1< itk::RGBPixel< uchar >, _Dim >( io ); break;
- case itk::ImageIOBase::USHORT : r = this->_GD1< itk::RGBPixel< ushort >, _Dim >( io ); break;
- case itk::ImageIOBase::UINT : r = this->_GD1< itk::RGBPixel< uint >, _Dim >( io ); break;
- case itk::ImageIOBase::ULONG : r = this->_GD1< itk::RGBPixel< ulong >, _Dim >( io ); break;
- default:
- r = "IO::ImageReader: RGB pixel type not supported.";
- break;
+ case itk::ImageIOBase::CHAR : this->_GD1< itk::RGBPixel< char >, _Dim >( io ); break;
+ case itk::ImageIOBase::SHORT : this->_GD1< itk::RGBPixel< short >, _Dim >( io ); break;
+ case itk::ImageIOBase::INT : this->_GD1< itk::RGBPixel< int >, _Dim >( io ); break;
+ case itk::ImageIOBase::LONG : this->_GD1< itk::RGBPixel< long >, _Dim >( io ); break;
+ case itk::ImageIOBase::FLOAT : this->_GD1< itk::RGBPixel< float >, _Dim >( io ); break;
+ case itk::ImageIOBase::DOUBLE : this->_GD1< itk::RGBPixel< double >, _Dim >( io ); break;
+ case itk::ImageIOBase::UCHAR : this->_GD1< itk::RGBPixel< uchar >, _Dim >( io ); break;
+ case itk::ImageIOBase::USHORT : this->_GD1< itk::RGBPixel< ushort >, _Dim >( io ); break;
+ case itk::ImageIOBase::UINT : this->_GD1< itk::RGBPixel< uint >, _Dim >( io ); break;
+ case itk::ImageIOBase::ULONG : this->_GD1< itk::RGBPixel< ulong >, _Dim >( io ); break;
+ default: this->_Error( "RGB pixel type not supported." ); break;
} // hctiws
}
else if( pt == itk::ImageIOBase::RGBA )
{
switch( ct )
{
- case itk::ImageIOBase::CHAR : r = this->_GD1< itk::RGBAPixel< char >, _Dim >( io ); break;
- case itk::ImageIOBase::SHORT : r = this->_GD1< itk::RGBAPixel< short >, _Dim >( io ); break;
- case itk::ImageIOBase::INT : r = this->_GD1< itk::RGBAPixel< int >, _Dim >( io ); break;
- case itk::ImageIOBase::LONG : r = this->_GD1< itk::RGBAPixel< long >, _Dim >( io ); break;
- case itk::ImageIOBase::FLOAT : r = this->_GD1< itk::RGBAPixel< float >, _Dim >( io ); break;
- case itk::ImageIOBase::DOUBLE : r = this->_GD1< itk::RGBAPixel< double >, _Dim >( io ); break;
- case itk::ImageIOBase::UCHAR : r = this->_GD1< itk::RGBAPixel< uchar >, _Dim >( io ); break;
- case itk::ImageIOBase::USHORT : r = this->_GD1< itk::RGBAPixel< ushort >, _Dim >( io ); break;
- case itk::ImageIOBase::UINT : r = this->_GD1< itk::RGBAPixel< uint >, _Dim >( io ); break;
- case itk::ImageIOBase::ULONG : r = this->_GD1< itk::RGBAPixel< ulong >, _Dim >( io ); break;
- default:
- r = "IO::ImageReader: RGBA pixel type not supported.";
- break;
+ case itk::ImageIOBase::CHAR : this->_GD1< itk::RGBAPixel< char >, _Dim >( io ); break;
+ case itk::ImageIOBase::SHORT : this->_GD1< itk::RGBAPixel< short >, _Dim >( io ); break;
+ case itk::ImageIOBase::INT : this->_GD1< itk::RGBAPixel< int >, _Dim >( io ); break;
+ case itk::ImageIOBase::LONG : this->_GD1< itk::RGBAPixel< long >, _Dim >( io ); break;
+ case itk::ImageIOBase::FLOAT : this->_GD1< itk::RGBAPixel< float >, _Dim >( io ); break;
+ case itk::ImageIOBase::DOUBLE : this->_GD1< itk::RGBAPixel< double >, _Dim >( io ); break;
+ case itk::ImageIOBase::UCHAR : this->_GD1< itk::RGBAPixel< uchar >, _Dim >( io ); break;
+ case itk::ImageIOBase::USHORT : this->_GD1< itk::RGBAPixel< ushort >, _Dim >( io ); break;
+ case itk::ImageIOBase::UINT : this->_GD1< itk::RGBAPixel< uint >, _Dim >( io ); break;
+ case itk::ImageIOBase::ULONG : this->_GD1< itk::RGBAPixel< ulong >, _Dim >( io ); break;
+ default: this->_Error( "RGBA pixel type not supported." ); break;
} // hctiws
}
else if( pt == itk::ImageIOBase::COMPLEX )
{
switch( ct )
{
- case itk::ImageIOBase::FLOAT : r = this->_GD1< std::complex< float >, _Dim >( io ); break;
- case itk::ImageIOBase::DOUBLE : r = this->_GD1< std::complex< double >, _Dim >( io ); break;
- default:
- r = "IO::ImageReader: complex pixel type not supported.";
- break;
+ case itk::ImageIOBase::FLOAT : this->_GD1< std::complex< float >, _Dim >( io ); break;
+ case itk::ImageIOBase::DOUBLE : this->_GD1< std::complex< double >, _Dim >( io ); break;
+ default: this->_Error( "Complex pixel type not supported." ); break;
} // hctiws
}
/* TODO
}
*/
else
- r = "IO::ImageReader: Image pixel type not yet supported.";
- return( r );
+ this->_Error( "Image pixel type not yet supported." );
}
// -------------------------------------------------------------------------
template< class _TPixel, unsigned int _Dim >
-std::string cpPluginsIO::ImageReader::
+void cpPluginsIO::ImageReader::
_GD1( itk::ImageIOBase* io )
{
typedef itk::Image< _TPixel, _Dim > _TImage;
// Get filenames
- std::string r = "";
auto fnames = this->m_Parameters.GetOpenFileNameList( "FileNames" );
if( fnames.size( ) == 1 )
{
}
catch( itk::ExceptionObject& err )
{
- r = "IO::ImageReader: " + std::string( err.GetDescription( ) );
+ this->_Error( err.GetDescription( ) );
}
}
else // if( fnames.size( ) > 1 )
}
catch( itk::ExceptionObject& err )
{
- r = "IO::ImageReader: " + std::string( err.GetDescription( ) );
+ this->_Error( err.GetDescription( ) );
}
} // fi
- return( r );
}
// eof - $RCSfile$
ImageReader( );
virtual ~ImageReader( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
template< unsigned int _Dim >
- inline std::string _GD0( itk::ImageIOBase* io );
+ inline void _GD0( itk::ImageIOBase* io );
template< class _TPixel, unsigned int _Dim >
- inline std::string _GD1( itk::ImageIOBase* io );
+ inline void _GD1( itk::ImageIOBase* io );
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsIO::ImageWriter::
+void cpPluginsIO::ImageWriter::
_GenerateData( )
{
- auto input = this->GetInputData( "Input" );
- try
- {
- std::string r = cpPlugin_Image_Demangle_Dim( _GD0, input, 3 );
- if( r != "" ) r = cpPlugin_Image_Demangle_Dim( _GD0, input, 2 );
- /* TODO
- if( r != "" ) r = cpPlugin_Image_Demangle_Dim( _GD0, input, 4 );
- if( r != "" ) r = cpPlugin_Image_Demangle_Dim( _GD0, input, 1 );
- */
- return( r );
- }
- catch( itk::ExceptionObject& err )
- {
- return( "IO::ImageWriter: " + std::string( err.GetDescription( ) ) );
- }
+ auto image = this->GetInputData( "Input" )->GetITK< itk::DataObject >( );
+ cpPlugins_Image_Demangle_Dim ( _GD0, image, 2 );
+ else cpPlugins_Image_Demangle_Dim( _GD0, image, 3 );
+ else this->_Error( "No valid input image dimension" );
}
// -------------------------------------------------------------------------
-template< class _TInput >
-std::string cpPluginsIO::ImageWriter::
-_GD0( _TInput* image )
+template< class _TImage >
+void cpPluginsIO::ImageWriter::
+_GD0( _TImage* image )
{
- static const unsigned int D = _TInput::ImageDimension;
- if( image == NULL )
- return( "IO::ImageWriter: Invalid image dimension." );
-
- std::string cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD1, image, D );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllColor( r, _GD1, image, D );
- return( r );
+ static const unsigned int D = _TImage::ImageDimension;
+ cpPlugins_Image_Demangle_Pixel_AllScalars ( _GD1, image, D );
+ else cpPlugins_Image_Demangle_ColorPixel_AllScalars( _GD1, image, RGB, D );
+ else cpPlugins_Image_Demangle_ColorPixel_AllScalars( _GD1, image, RGBA, D );
}
// -------------------------------------------------------------------------
-template< class _TInput >
-std::string cpPluginsIO::ImageWriter::
-_GD1( _TInput* image )
+template< class _TImage >
+void cpPluginsIO::ImageWriter::
+_GD1( _TImage* image )
{
- typedef itk::ImageFileWriter< _TInput > _TFilter;
-
- if( image == NULL )
- return( "IO::ImageWriter: Invalid pixel type." );
+ typedef itk::ImageFileWriter< _TImage > _TFilter;
auto f = this->_CreateITK< _TFilter >( );
f->SetFileName( this->m_Parameters.GetSaveFileName( "FileName" ) );
f->SetInput( image );
- f->Update( );
- return( "" );
+ try
+ {
+ f->Update( );
+ }
+ catch( itk::ExceptionObject& err )
+ {
+ this->_Error( err.GetDescription( ) );
+
+ } // yrt
}
// eof - $RCSfile$
ImageWriter( );
virtual ~ImageWriter( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
- template< class _TInput >
- inline std::string _GD0( _TInput* image );
+ template< class _TImage >
+ inline void _GD0( _TImage* image );
- template< class _TInput >
- inline std::string _GD1( _TInput* image );
+ template< class _TImage >
+ inline void _GD1( _TImage* image );
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsIO::MeshReader::
+void cpPluginsIO::MeshReader::
_GenerateData( )
{
- auto dim = this->m_Parameters.GetUint( "Dimension" );
- if ( dim == 2 ) return( this->_GD0< 2 >( ) );
- else if( dim == 3 ) return( this->_GD0< 3 >( ) );
- else return( "MeshReader: Mesh dimension not supported." );
+ auto d = this->m_Parameters.GetUint( "Dimension" );
+ if ( d == 2 ) this->_GD0< 2 >( );
+ else if( d == 3 ) this->_GD0< 3 >( );
+ else this->_Error( "Mesh dimension not supported." );
}
// -------------------------------------------------------------------------
template< unsigned int _Dim >
-std::string cpPluginsIO::MeshReader::
+void cpPluginsIO::MeshReader::
_GD0( )
{
- auto st = this->m_Parameters.GetSelectedChoice( "ScalarType" );
- if ( st == "float" ) return( this->_GD1< float, _Dim >( ) );
- else if( st == "double" ) return( this->_GD1< double, _Dim >( ) );
- else return( "MeshReader: Mesh type not supported." );
+ auto s = this->m_Parameters.GetSelectedChoice( "ScalarType" );
+ if ( s == "float" ) this->_GD1< float, _Dim >( );
+ else if( s == "double" ) this->_GD1< double, _Dim >( );
+ else this->_Error( "Mesh type not supported." );
}
// -------------------------------------------------------------------------
template< class _TScalar, unsigned int _Dim >
-std::string cpPluginsIO::MeshReader::
+void cpPluginsIO::MeshReader::
_GD1( )
{
auto fname = this->m_Parameters.GetOpenFileName( "FileName" );
stlr->Update( );
this->GetOutputData( "Output" )->SetVTK( stlr->GetOutput( ) );
- return( "" );
}
else if( ext == "obj" )
{
objr->Update( );
this->GetOutputData( "Output" )->SetVTK( objr->GetOutput( ) );
- return( "" );
}
else if( ext == "vtk" )
{
pdr->Update( );
this->GetOutputData( "Output" )->SetVTK( pdr->GetOutput( ) );
- return( "" );
}
else
- return( "MeshReader: Input file format not recognized." );
+ this->_Error( "Input file format not recognized." );
}
// eof - $RCSfile$
MeshReader( );
virtual ~MeshReader( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
template< unsigned int _Dim >
- inline std::string _GD0( );
+ inline void _GD0( );
template< class _TScalar, unsigned int _Dim >
- inline std::string _GD1( );
+ inline void _GD1( );
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsIO::MeshWriter::
+void cpPluginsIO::MeshWriter::
_GenerateData( )
{
auto mesh = this->GetInputData( "Input" )->GetVTK< vtkPolyData >( );
if( mesh == NULL )
- return( "MeshWriter: No suitable input." );
+ this->_Error( "No suitable input." );
// Get file extension
auto fname = this->m_Parameters.GetSaveFileName( "FileName" );
stlw->SetFileName( fname.c_str( ) );
stlw->Update( );
if( stlw->GetErrorCode( ) != 0 )
- return( "MeshWriter: someting wrong happened." );
- else
- return( "" );
+ this->_Error( "Someting wrong happened." );
}
else if( ext == "vtk" )
{
pdw->SetFileName( fname.c_str( ) );
pdw->Update( );
if( pdw->GetErrorCode( ) != 0 )
- return( "MeshWriter: someting wrong happened." );
- else
- return( "" );
+ this->_Error( "Someting wrong happened." );
}
else
- return( "MeshWriter: Input file format not recognized." );
+ this->_Error( "Input file format not recognized." );
}
// eof - $RCSfile$
MeshWriter( );
virtual ~MeshWriter( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsImageFilters::AndImageFilter::
+void cpPluginsImageFilters::AndImageFilter::
_GenerateData( )
{
auto image = this->GetInputData( "Input0" )->GetITK< itk::DataObject >( );
- std::string cpPlugin_Image_Demangle_Pixel_AllInts( r, _GD0, image, 2 );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllInts( r, _GD0, image, 3 );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllInts( r, _GD0, image, 1 );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllInts( r, _GD0, image, 4 );
- return( r );
+ cpPlugins_Image_Demangle_Pixel_AllInts ( _GD0, image, 1 );
+ else cpPlugins_Image_Demangle_Pixel_AllInts ( _GD0, image, 2 );
+ else cpPlugins_Image_Demangle_Pixel_AllInts ( _GD0, image, 3 );
+ else cpPlugins_Image_Demangle_Pixel_AllInts ( _GD0, image, 4 );
+ else cpPlugins_Image_Demangle_Pixel_AllUInts( _GD0, image, 1 );
+ else cpPlugins_Image_Demangle_Pixel_AllUInts( _GD0, image, 2 );
+ else cpPlugins_Image_Demangle_Pixel_AllUInts( _GD0, image, 3 );
+ else cpPlugins_Image_Demangle_Pixel_AllUInts( _GD0, image, 4 );
+ else this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage >
-std::string cpPluginsImageFilters::AndImageFilter::
+void cpPluginsImageFilters::AndImageFilter::
_GD0( _TImage* image0 )
{
typedef itk::AndImageFilter< _TImage, _TImage > _TFilter;
// Connect output
this->GetOutputData( "Output" )->SetITK( filter->GetOutput( ) );
- return( "" );
}
else
- return(
- "ImageFilters::AndImageFilter: No valid second input image."
- );
+ this->_Error( "No valid second input image." );
}
else
- return(
- "ImageFilters::AndImageFilter: No valid first input image."
- );
+ this->_Error( "No valid first input image." );
}
// eof - $RCSfile$
AndImageFilter( );
virtual ~AndImageFilter( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
template< class _TImage >
- inline std::string _GD0( _TImage* image0 );
+ inline void _GD0( _TImage* image0 );
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsImageFilters::BinaryContourImageFilter::
+void cpPluginsImageFilters::BinaryContourImageFilter::
_GenerateData( )
{
auto image = this->GetInputData( "Input" )->GetITK< itk::DataObject >( );
- std::string cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 2 );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 3 );
- return( r );
+ cpPlugins_Image_Demangle_Pixel_AllScalars ( _GD0, image, 2 );
+ else cpPlugins_Image_Demangle_Pixel_AllScalars( _GD0, image, 3 );
+ else this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage >
-std::string cpPluginsImageFilters::BinaryContourImageFilter::
+void cpPluginsImageFilters::BinaryContourImageFilter::
_GD0( _TImage* image )
{
+ static const unsigned int D = _TImage::ImageDimension;
if( image != NULL )
{
std::string out_res =
this->m_Parameters.GetSelectedChoice( "OutputResolution" );
if( out_res == "float" )
- return(
- this->_GD1< _TImage, itk::Image< float, _TImage::ImageDimension > >(
- image
- )
- );
+ this->_GD1< _TImage, itk::Image< float, D > >( image );
else // if( out_res == "double" )
- return(
- this->_GD1< _TImage, itk::Image< double, _TImage::ImageDimension > >(
- image
- )
- );
+ this->_GD1< _TImage, itk::Image< double, D > >( image );
}
else
- return(
- "ImageFilters::BinaryContourImageFilter: No valid input image."
- );
+ this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage, class _TContourImage >
-std::string cpPluginsImageFilters::BinaryContourImageFilter::
+void cpPluginsImageFilters::BinaryContourImageFilter::
_GD1( _TImage* image )
{
typedef itk::BinaryContourImageFilter< _TImage, _TContourImage > _F;
// Connect output
this->GetOutputData( "Output" )->SetITK( filter->GetOutput( ) );
- return( "" );
}
// eof - $RCSfile$
BinaryContourImageFilter( );
virtual ~BinaryContourImageFilter( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
template< class _TImage >
- inline std::string _GD0( _TImage* image );
+ inline void _GD0( _TImage* image );
template< class _TImage, class _TContourImage >
- inline std::string _GD1( _TImage* image );
+ inline void _GD1( _TImage* image );
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsImageFilters::BinaryThresholdImageFilter::
+void cpPluginsImageFilters::BinaryThresholdImageFilter::
_GenerateData( )
{
auto image = this->GetInputData( "Input" )->GetITK< itk::DataObject >( );
- std::string cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 2 );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 3 );
- /* TODO
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 1 );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 4 );
- */
- return( r );
+ cpPlugins_Image_Demangle_Pixel_AllScalars ( _GD0, image, 2 );
+ else cpPlugins_Image_Demangle_Pixel_AllScalars( _GD0, image, 3 );
+ else this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage >
-std::string cpPluginsImageFilters::BinaryThresholdImageFilter::
+void cpPluginsImageFilters::BinaryThresholdImageFilter::
_GD0( _TImage* image )
{
if( image != NULL )
- return( this->_GD1< _TImage, unsigned char >( image ) );
+ this->_GD1< _TImage, unsigned char >( image );
else
- return(
- "ImageFilters::BinaryThresholdImageFilter: No valid input image."
- );
+ this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage, class _TBinaryPixel >
-std::string cpPluginsImageFilters::BinaryThresholdImageFilter::
+void cpPluginsImageFilters::BinaryThresholdImageFilter::
_GD1( _TImage* image )
{
typedef itk::Image< _TBinaryPixel, _TImage::ImageDimension > _TBinaryImage;
// Connect output
this->GetOutputData( "Output" )->SetITK( filter->GetOutput( ) );
- return( "" );
}
// eof - $RCSfile$
BinaryThresholdImageFilter( );
virtual ~BinaryThresholdImageFilter( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
template< class _TImage >
- inline std::string _GD0( _TImage* image );
+ inline void _GD0( _TImage* image );
template< class _TImage, class _TBinaryPixel >
- inline std::string _GD1( _TImage* image );
+ inline void _GD1( _TImage* image );
private:
// Purposely not implemented
#include <cpPlugins/Image.h>
#include <cpPlugins_Instances/GaussianImageFilters.h>
-/*
- #include <cpExtensions/Algorithms/MultiScaleGaussianImageFilter.h>
- #include <cpExtensions/Algorithms/MultiScaleGaussianImageFilter.hxx>
- #include <itkGradientRecursiveGaussianImageFilter.hxx>
- #include <itkImageAdaptor.hxx>
- #include <itkImageToImageFilter.hxx>
- #include <itkInPlaceImageFilter.hxx>
- #include <itkUnaryFunctorImageFilter.hxx>
- #include <itkRecursiveGaussianImageFilter.hxx>
- #include <itkImageConstIteratorWithIndex.hxx>
- #include <itkRecursiveSeparableImageFilter.hxx>
- #include <itkBinaryFunctorImageFilter.hxx>
- #include <itkImageRegionConstIterator.hxx>
- #include <itkImageScanlineIterator.hxx>
- #include <itkImageSource.hxx>
- #include <itkImageRegionIteratorWithIndex.hxx>
- #include <itkImageScanlineConstIterator.hxx>
- #include <itkImageRegionIterator.hxx>
- #include <itkSimpleDataObjectDecorator.hxx>
- #include <itkImageRegionConstIteratorWithIndex.hxx>
- #include <itkNthElementPixelAccessor.h>
- #include <itkImageBase.hxx>
-*/
-
// -------------------------------------------------------------------------
cpPluginsImageFilters::MultiScaleGaussianImageFilter::
MultiScaleGaussianImageFilter( )
}
// -------------------------------------------------------------------------
-std::string cpPluginsImageFilters::MultiScaleGaussianImageFilter::
+void cpPluginsImageFilters::MultiScaleGaussianImageFilter::
_GenerateData( )
{
auto image = this->GetInputData( "Input" )->GetITK< itk::DataObject >( );
- std::string cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 2 );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 3 );
- return( r );
+ cpPlugins_Image_Demangle_Pixel_AllScalars ( _GD0, image, 2 );
+ else cpPlugins_Image_Demangle_Pixel_AllScalars( _GD0, image, 3 );
+ else this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage >
-std::string cpPluginsImageFilters::MultiScaleGaussianImageFilter::
+void cpPluginsImageFilters::MultiScaleGaussianImageFilter::
_GD0( _TImage* image )
{
if( image != NULL )
{
auto choice = this->m_Parameters.GetSelectedChoice( "ScalarType" );
- if( choice == "float" )
- return( this->_GD1< _TImage, float >( image ) );
- else if( choice == "double" )
- return( this->_GD1< _TImage, double >( image ) );
- else return( "MultiScaleGaussianImageFilter: no valid scalar type." );
+ if ( choice == "float" ) this->_GD1< _TImage, float >( image );
+ else if( choice == "double" ) this->_GD1< _TImage, double >( image );
+ else this->_Error( "No valid scalar type." );
}
else
- return(
- "MultiScaleGaussianImageFilter: No valid input image."
- );
+ this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage, class _TScalar >
-std::string cpPluginsImageFilters::MultiScaleGaussianImageFilter::
+void cpPluginsImageFilters::MultiScaleGaussianImageFilter::
_GD1( _TImage* image )
{
typedef itk::CovariantVector< _TScalar, _TImage::ImageDimension > _TVector;
auto sigmas = this->m_Parameters.GetRealList( "Sigmas" );
if( sigmas.size( ) == 0 )
- return(
- "MultiScaleGaussianImageFilter: No given sigmas."
- );
+ this->_Error( "No given sigmas." );
// Configure filter
_TFilter* filter = this->_CreateITK< _TFilter >( );
// Connect output
this->GetOutputData( "Output" )->SetITK( filter->GetOutput( ) );
- return( "" );
}
// eof - $RCSfile$
MultiScaleGaussianImageFilter( );
virtual ~MultiScaleGaussianImageFilter( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
template< class _TImage >
- inline std::string _GD0( _TImage* image );
+ inline void _GD0( _TImage* image );
template< class _TImage, class _TScalar >
- inline std::string _GD1( _TImage* image );
+ inline void _GD1( _TImage* image );
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsImageFilters::OrImageFilter::
+void cpPluginsImageFilters::OrImageFilter::
_GenerateData( )
{
auto image = this->GetInputData( "Input0" )->GetITK< itk::DataObject >( );
- std::string cpPlugin_Image_Demangle_Pixel_AllInts( r, _GD0, image, 2 );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllInts( r, _GD0, image, 3 );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllInts( r, _GD0, image, 1 );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllInts( r, _GD0, image, 4 );
- return( r );
+ cpPlugins_Image_Demangle_Pixel_AllInts ( _GD0, image, 1 );
+ else cpPlugins_Image_Demangle_Pixel_AllInts ( _GD0, image, 2 );
+ else cpPlugins_Image_Demangle_Pixel_AllInts ( _GD0, image, 3 );
+ else cpPlugins_Image_Demangle_Pixel_AllInts ( _GD0, image, 4 );
+ else cpPlugins_Image_Demangle_Pixel_AllUInts( _GD0, image, 1 );
+ else cpPlugins_Image_Demangle_Pixel_AllUInts( _GD0, image, 2 );
+ else cpPlugins_Image_Demangle_Pixel_AllUInts( _GD0, image, 3 );
+ else cpPlugins_Image_Demangle_Pixel_AllUInts( _GD0, image, 4 );
+ else this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage >
-std::string cpPluginsImageFilters::OrImageFilter::
+void cpPluginsImageFilters::OrImageFilter::
_GD0( _TImage* image0 )
{
typedef itk::OrImageFilter< _TImage, _TImage > _TFilter;
// Connect output
this->GetOutputData( "Output" )->SetITK( filter->GetOutput( ) );
- return( "" );
}
else
- return(
- "ImageFilters::OrImageFilter: No valid second input image."
- );
+ this->_Error( "No valid second input image." );
}
else
- return(
- "ImageFilters::OrImageFilter: No valid first input image."
- );
+ this->_Error( "No valid first input image." );
}
// eof - $RCSfile$
OrImageFilter( );
virtual ~OrImageFilter( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
template< class _TImage >
- inline std::string _GD0( _TImage* image0 );
+ inline void _GD0( _TImage* image0 );
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsImageFilters::ResampleImageFilter::
+void cpPluginsImageFilters::ResampleImageFilter::
_GenerateData( )
{
auto image = this->GetInputData( "Input" )->GetITK< itk::DataObject >( );
- std::string cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 2 );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 3 );
- /* TODO
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 1 );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 4 );
- */
- return( r );
+ cpPlugins_Image_Demangle_Pixel_AllScalars ( _GD0, image, 2 );
+ else cpPlugins_Image_Demangle_Pixel_AllScalars( _GD0, image, 3 );
+ else this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage >
-std::string cpPluginsImageFilters::ResampleImageFilter::
+void cpPluginsImageFilters::ResampleImageFilter::
_GD0( _TImage* image )
{
if( image != NULL )
{
auto choice = this->m_Parameters.GetSelectedChoice( "OutputResolution" );
if( choice == "float" )
- return( this->_GD1< _TImage, float >( image ) );
+ this->_GD1< _TImage, float >( image );
else if( choice == "double" )
- return( this->_GD1< _TImage, double >( image ) );
- else return( "ResampleImageFilter: no valid scalar type." );
+ this->_GD1< _TImage, double >( image );
+ else this->_Error( "No valid scalar type." );
}
else
- return(
- "ResampleImageFilter: No valid input image."
- );
+ this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage, class _TScalar >
-std::string cpPluginsImageFilters::ResampleImageFilter::
+void cpPluginsImageFilters::ResampleImageFilter::
_GD1( _TImage* image )
{
typedef
_TFilter;
if( image == NULL )
- return(
- "ImageFilters::ResampleImageFilter: No valid input image."
- );
+ this->_Error( "No valid input image." );
// Configure filter
_TFilter* filter = this->_CreateITK< _TFilter >( );
// Connect output
this->GetOutputData( "Output" )->SetITK( filter->GetOutput( ) );
- return( "" );
}
// eof - $RCSfile$
ResampleImageFilter( );
virtual ~ResampleImageFilter( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
template< class _TImage >
- inline std::string _GD0( _TImage* image );
+ inline void _GD0( _TImage* image );
template< class _TImage, class _TScalar >
- inline std::string _GD1( _TImage* image );
+ inline void _GD1( _TImage* image );
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsImageFilters::SignedMaurerDistanceMapImageFilter::
+void cpPluginsImageFilters::SignedMaurerDistanceMapImageFilter::
_GenerateData( )
{
auto image = this->GetInputData( "Input" )->GetITK< itk::DataObject >( );
- std::string cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 2 );
- if( r != "" ) cpPlugin_Image_Demangle_Pixel_AllScalars( r, _GD0, image, 3 );
- return( r );
+ cpPlugins_Image_Demangle_Pixel_AllScalars ( _GD0, image, 2 );
+ else cpPlugins_Image_Demangle_Pixel_AllScalars( _GD0, image, 3 );
+ else this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage >
-std::string cpPluginsImageFilters::SignedMaurerDistanceMapImageFilter::
+void cpPluginsImageFilters::SignedMaurerDistanceMapImageFilter::
_GD0( _TImage* image )
{
+ static const unsigned int D = _TImage::ImageDimension;
if( image != NULL )
{
std::string out_res =
this->m_Parameters.GetSelectedChoice( "OutputResolution" );
if( out_res == "float" )
- return(
- this->_GD1< _TImage, itk::Image< float, _TImage::ImageDimension > >( image )
- );
- else if( out_res == "double" )
- return(
- this->_GD1< _TImage, itk::Image< double, _TImage::ImageDimension > >( image )
- );
- else
- return( "ImageFilters::SignedMaurerDistanceMapImageFilter: Output resolution not supported." );
+ this->_GD1< _TImage, itk::Image< float, D > >( image );
+ else if( out_res == "double" )
+ this->_GD1< _TImage, itk::Image< double, D > >( image );
+ else
+ this->_Error( "Output resolution not supported." );
}
else
- return(
- "ImageFilters::SignedMaurerDistanceMapImageFilter: No valid input image."
- );
+ this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage, class _TDMap >
-std::string cpPluginsImageFilters::SignedMaurerDistanceMapImageFilter::
+void cpPluginsImageFilters::SignedMaurerDistanceMapImageFilter::
_GD1( _TImage* image )
{
typedef itk::SignedMaurerDistanceMapImageFilter< _TImage, _TDMap > _F;
// Connect output
this->GetOutputData( "Output" )->SetITK( filter->GetOutput( ) );
- return( "" );
}
// eof - $RCSfile$
SignedMaurerDistanceMapImageFilter( );
virtual ~SignedMaurerDistanceMapImageFilter( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
template< class _TImage >
- inline std::string _GD0( _TImage* image );
+ inline void _GD0( _TImage* image );
template< class _TImage, class _TDMap >
- inline std::string _GD1( _TImage* image );
+ inline void _GD1( _TImage* image );
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsImageMeshFilters::MarchingCubes::
+void cpPluginsImageMeshFilters::MarchingCubes::
_GenerateData( )
{
// Get input
auto image = this->GetInputData( "Input" );
vtkImageData* vtk_image = image->GetVTK< vtkImageData >( );
if( vtk_image == NULL )
- return( "MarchingCubes: Input does not have a valid VTK conversion." );
+ this->_Error( "Input does not have a valid VTK conversion." );
std::vector< double > values =
this->m_Parameters.GetRealList( "Thresholds" );
pd = mc->GetOutput( );
}
else
- return( "MarchingCubes: Input data does not have a valid dimension." );
+ this->_Error( "Input data does not have a valid dimension." );
// Connect output
this->GetOutputData( "Output" )->SetVTK( pd );
- return( "" );
}
// eof - $RCSfile$
MarchingCubes( );
virtual ~MarchingCubes( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsImageMeshFilters::TriangleMeshToBinaryImageFilter::
+void cpPluginsImageMeshFilters::TriangleMeshToBinaryImageFilter::
_GenerateData( )
{
typedef itk::Mesh< float, 3 > _3F;
auto _3f = this->GetInputData( "Input" )->GetITK< _3F >( );
auto _3d = this->GetInputData( "Input" )->GetITK< _3D >( );
- if ( _3f != NULL ) return( this->_GD0( _3f ) );
- else if( _3d != NULL ) return( this->_GD0( _3d ) );
- else
- return( "TriangleMeshToBinaryImageFilter: No valid input itk mesh." );
+ if ( _3f != NULL ) this->_GD0( _3f );
+ else if( _3d != NULL ) this->_GD0( _3d );
+ else this->_Error( "No valid input mesh." );
}
// -------------------------------------------------------------------------
template< class _TMesh >
-std::string cpPluginsImageMeshFilters::TriangleMeshToBinaryImageFilter::
+void cpPluginsImageMeshFilters::TriangleMeshToBinaryImageFilter::
_GD0( _TMesh* mesh )
{
- return( this->_GD1< _TMesh, unsigned char >( mesh ) );
+ this->_GD1< _TMesh, unsigned char >( mesh );
}
// -------------------------------------------------------------------------
template< class _TMesh, class _TPixel >
-std::string cpPluginsImageMeshFilters::TriangleMeshToBinaryImageFilter::
+void cpPluginsImageMeshFilters::TriangleMeshToBinaryImageFilter::
_GD1( _TMesh* mesh )
{
typedef cpPlugins::BoundingBox _TBB;
// Connect output
auto out = this->GetOutputData( "Output" );
out->SetITK( filter->GetOutput( ) );
- return( "" );
-
}
// eof - $RCSfile$
TriangleMeshToBinaryImageFilter( );
virtual ~TriangleMeshToBinaryImageFilter( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
template< class _TMesh >
- inline std::string _GD0( _TMesh* mesh );
+ inline void _GD0( _TMesh* mesh );
template< class _TMesh, class _TPixel >
- inline std::string _GD1( _TMesh* mesh );
+ inline void _GD1( _TMesh* mesh );
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsMeshFilters::AppendMeshesFilter::
+void cpPluginsMeshFilters::AppendMeshesFilter::
_GenerateData( )
{
auto m0 = this->GetInputData( "Input0" )->GetVTK< vtkPolyData >( );
auto m4 = this->GetInputData( "Input4" );
auto m5 = this->GetInputData( "Input5" );
+ if( m0 == NULL || m1 == NULL )
+ this->_Error( "Invalid inputs." );
+
auto filter = this->_CreateVTK< vtkAppendPolyData >( );
filter->AddInputData( m0 );
filter->AddInputData( m1 );
filter->Update( );
this->GetOutputData( "Output" )->SetVTK( filter->GetOutput( ) );
- return( "" );
}
// eof - $RCSfile$
AppendMeshesFilter( );
virtual ~AppendMeshesFilter( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsWidgets::NoInteractiveSeedWidget::
+void cpPluginsWidgets::NoInteractiveSeedWidget::
_GenerateData( )
{
auto image = this->GetInputData( "ReferenceImage" );
- std::string r = cpPlugin_Image_Demangle_Dim( _GD0, image, 3 );
- if( r != "" ) r = cpPlugin_Image_Demangle_Dim( _GD0, image, 2 );
- return( r );
+ cpPlugins_Image_Demangle_Dim ( _GD0, image, 2 );
+ else cpPlugins_Image_Demangle_Dim( _GD0, image, 3 );
+ else this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage >
-std::string cpPluginsWidgets::NoInteractiveSeedWidget::
+void cpPluginsWidgets::NoInteractiveSeedWidget::
_GD0( _TImage* image )
{
typedef
container->Get( ).push_back( idx );
container->SetReferenceImage( image );
this->GetOutputData( "Output" )->SetITK( container );
- return( "" );
}
else
- return( "Widgets::NoInteractiveSeedWidget: Input image dimension not supported." );
+ this->_Error( "Input image dimension not supported." );
}
// eof - $RCSfile$
NoInteractiveSeedWidget( );
virtual ~NoInteractiveSeedWidget( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
template< class _TImage >
- inline std::string _GD0( _TImage* image );
+ inline void _GD0( _TImage* image );
private:
// Purposely not implemented
}
// -------------------------------------------------------------------------
-std::string cpPluginsWidgets::SeedWidget::
+void cpPluginsWidgets::SeedWidget::
_GenerateData( )
{
auto image = this->GetInputData( "ReferenceImage" );
- std::string r = cpPlugin_Image_Demangle_Dim( _GD0, image, 3 );
- if( r != "" ) r = cpPlugin_Image_Demangle_Dim( _GD0, image, 2 );
- return( r );
+ cpPlugins_Image_Demangle_Dim ( _GD0, image, 2 );
+ else cpPlugins_Image_Demangle_Dim( _GD0, image, 3 );
+ else this->_Error( "No valid input image." );
}
// -------------------------------------------------------------------------
template< class _TImage >
-std::string cpPluginsWidgets::SeedWidget::
+void cpPluginsWidgets::SeedWidget::
_GD0( _TImage* image )
{
typedef
this->m_Configured = true;
container->SetReferenceImage( image );
this->GetOutputData( "Output" )->SetITK( container );
- return( "" );
}
else
- return( "Widgets::SeedWidget: Input image dimension not supported." );
+ this->_Error( "Input image dimension not supported." );
}
// eof - $RCSfile$
SeedWidget( );
virtual ~SeedWidget( );
- virtual std::string _GenerateData( ) ITK_OVERRIDE;
+ virtual void _GenerateData( ) ITK_OVERRIDE;
template< class _TImage >
- inline std::string _GD0( _TImage* image );
+ inline void _GD0( _TImage* image );
private:
// Purposely not implemented
git://git.creatis.insa-lyon.fr / cpPlugins.git / commitdiff