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 );
+ this->_AddInput( "Input" );
+ this->_MakeOutput< cpPlugins::Interface::Image >( "Output" );
+
+ this->m_Parameters->ConfigureAsPoint( "Seed" );
+ 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 );
}
// -------------------------------------------------------------------------
_GenerateData( )
{
cpPlugins::Interface::Image* image =
- this->GetInput< cpPlugins::Interface::Image >( 0 );
+ this->GetInput< cpPlugins::Interface::Image >( "Input" );
if( image == NULL )
return( "FloodFillImageFilter: No input image." );
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;
};
// -------------------------------------------------------------------------
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 );