#include "FloodFillImageFilter.h"
#include <cpPlugins/Interface/Image.h>
+#include <cpPlugins/Interface/PointList.h>
#include <itkFloodFilledImageFunctionConditionalConstIterator.h>
#include <itkImageFunction.h>
FloodFillImageFilter( )
: Superclass( )
{
- this->SetNumberOfInputs( 1 );
- this->SetNumberOfOutputs( 1 );
- this->_MakeOutput< cpPlugins::Interface::Image >( 0 );
-
- double seed[ 3 ] = { double( 0 ) };
- this->m_Parameters->ConfigureAsPoint( "Seed", 3, seed );
- this->m_Parameters->ConfigureAsUint( "InsideValue", 0 );
- this->m_Parameters->ConfigureAsUint( "OutsideValue", 255 );
+ /* TODO
+ this->_AddInput( "Input" );
+ this->_AddInput( "Seed" );
+ this->_AddOutput< cpPlugins::Interface::Image >( "Output" );
+
+ this->m_Parameters->ConfigureAsReal( "Window" );
+ this->m_Parameters->ConfigureAsReal( "Level" );
+ this->m_Parameters->ConfigureAsUint( "InsideValue" );
+ this->m_Parameters->ConfigureAsUint( "OutsideValue" );
+
+ this->m_Parameters->SetReal( "Window", 0 );
+ this->m_Parameters->SetReal( "Level", 0 );
+ this->m_Parameters->SetUint( "InsideValue", 0 );
+ this->m_Parameters->SetUint( "OutsideValue", 255 );
+ */
}
// -------------------------------------------------------------------------
std::string cpPlugins::BasicFilters::FloodFillImageFilter::
_GenerateData( )
{
+ /* TODO
cpPlugins::Interface::Image* image =
- this->GetInput< cpPlugins::Interface::Image >( 0 );
+ this->GetInput< cpPlugins::Interface::Image >( "Input" );
if( image == NULL )
return( "FloodFillImageFilter: No input image." );
else cpPlugins_Image_Demangle_AllScalarTypes( 3, image, itk_image, r, _GD0 );
else r = "FloodFillImageFilter: Input image type not supported.";
return( r );
+ */
+ return( "" );
}
// -------------------------------------------------------------------------
std::string cpPlugins::BasicFilters::FloodFillImageFilter::
_GD0( itk::DataObject* image )
{
+ /* TODO
return(
this->_RealGD< I, itk::Image< unsigned char, I::ImageDimension > >(
image
)
);
+ */
+ return( "" );
}
// -------------------------------------------------------------------------
+/* TODO
template< class I, class R = float >
class cpPlugins_BasicFilters_FloodFillImageFilter_Function
: public itk::ImageFunction< I, bool, R >
itkImageFunction
);
+ itkSetMacro( Window, double );
+ itkSetMacro( Level, double );
+
public:
virtual bool Evaluate( const TPoint& point ) const
{
}
virtual bool EvaluateAtIndex( const TIndex& index ) const
{
- return( true );
+ if( !( this->IsInsideBuffer( index ) ) )
+ return( false );
+
+ const I* image = this->GetInputImage( );
+ double w2 = this->m_Window / double( 2 );
+ double min = this->m_Level - w2;
+ double max = this->m_Level + w2;
+ unsigned char val = double( 0 );
+ double x = double( image->GetPixel( index ) );
+ double m = double( 100 ) / this->m_Window;
+ double b = ( this->m_Window - ( double( 2 ) * this->m_Level ) );
+ b *= double( 50 ) / this->m_Window;
+ if( x > min && x < max )
+ val = ( unsigned char )( ( m * x ) + b );
+
+ if( this->m_Start )
+ {
+ this->m_StartValue = val;
+ this->m_Start = false;
+ return( true );
+ }
+ else
+ return( std::abs( this->m_StartValue - val ) <= 2 );
}
virtual bool EvaluateAtContinuousIndex( const TCIndex& index ) const
{
protected:
cpPlugins_BasicFilters_FloodFillImageFilter_Function( )
- : Superclass( )
+ : Superclass( ),
+ m_Window( double( 0 ) ),
+ m_Level( double( 0 ) ),
+ m_Start( true )
{
}
virtual ~cpPlugins_BasicFilters_FloodFillImageFilter_Function( )
// Purposely not implemented
cpPlugins_BasicFilters_FloodFillImageFilter_Function( const Self& other );
Self& operator=( const Self& other );
+
+protected:
+ double m_Window;
+ double m_Level;
+ mutable unsigned char m_StartValue;
+ mutable bool m_Start;
};
+*/
// -------------------------------------------------------------------------
template< class I, class O >
inline std::string cpPlugins::BasicFilters::FloodFillImageFilter::
_RealGD( itk::DataObject* image )
{
+ /* TODO
typedef typename O::PixelType _OP;
typedef cpPlugins_BasicFilters_FloodFillImageFilter_Function< I > _F;
typedef itk::FloodFilledImageFunctionConditionalConstIterator< I, _F > _It;
pseed = this->m_Parameters->GetPoint< typename I::PointType >(
"Seed", I::ImageDimension
);
+ double window = this->m_Parameters->GetReal( "Window" );
+ double level = this->m_Parameters->GetReal( "Level" );
_OP in_val = _OP( this->m_Parameters->GetUint( "InsideValue" ) );
_OP out_val = _OP( this->m_Parameters->GetUint( "OutsideValue" ) );
out->FillBuffer( out_val );
typename _F::Pointer f = _F::New( );
+ f->SetInputImage( in );
+ f->SetWindow( window );
+ f->SetLevel( level );
_It i( in, f );
i.AddSeed( seed );
// Connect output
cpPlugins::Interface::Image* out_port =
- this->GetOutput< cpPlugins::Interface::Image >( 0 );
+ this->GetOutput< cpPlugins::Interface::Image >( "Output" );
if( out_port != NULL )
{
out_port->SetITK< O >( out );
}
else
return( "FloodFillImageFilter: output not correctly created." );
+ */
+ return( "" );
}
// eof - $RCSfile$