#include <RegionGrowFunctors/BinaryThreshold.h>
#include <cpInstances/DataObjects/Image.h>

#include <fpa/Image/Functors/RegionGrow/BinaryThreshold.h>
#include <itkConstNeighborhoodIterator.h>
#include <vtkPolyData.h>

// -------------------------------------------------------------------------
fpaPluginsRegionGrowFunctors::BinaryThreshold::
BinaryThreshold( )
  : Superclass( )
{
  typedef cpPlugins::Pipeline::DataObject _TData;
  typedef cpInstances::DataObjects::Image _TImage;

  this->_ConfigureInput< _TImage >( "Input", true, false );
  this->_ConfigureInput< _TData >( "Seeds", false, false );
  this->_ConfigureOutput< _TData >( "Output" );

  this->m_Parameters.ConfigureAsUint( "Radius", 1 );
  this->m_Parameters.ConfigureAsReal( "Lower", 0 );
  this->m_Parameters.ConfigureAsReal( "Upper", 0 );
}

// -------------------------------------------------------------------------
fpaPluginsRegionGrowFunctors::BinaryThreshold::
~BinaryThreshold( )
{
}

// -------------------------------------------------------------------------
void fpaPluginsRegionGrowFunctors::BinaryThreshold::
_GenerateData( )
{
  auto o = this->GetInputData( "Input" );
  cpPlugins_Demangle_Image_ScalarPixels_AllDims_1( o, _GD0 )
    this->_Error( "Invalid input image." );
}

// -------------------------------------------------------------------------
template< class _TImage >
void fpaPluginsRegionGrowFunctors::BinaryThreshold::
_GD0( _TImage* image )
{
  /* TODO
     typedef itk::ConstNeighborhoodIterator< _TImage > _TInIt;
     typedef
     fpa::Image::Functors::RegionGrow::BinaryThreshold< _TImage >
     _TFunctor;
     auto out = this->GetOutput( "Output" );
     auto f = out->GetITK< _TFunctor >( );
     if( f == NULL )
     {
     typename _TFunctor::Pointer ptr_f = _TFunctor::New( );
     f = ptr_f.GetPointer( );
     out->SetITK( f );

     } // fi

     // Compute thresholds from seeds
     auto seeds = this->GetInputData< vtkPolyData >( "Seeds" );
     if( seeds != NULL )
     {
     std::vector< typename _TImage::IndexType > indices;
     typename _TImage::PointType pnt;
     typename _TImage::IndexType idx;
     unsigned int dim =
     ( _TImage::ImageDimension < 3 )? _TImage::ImageDimension: 3;

     for( int i = 0; i < seeds->GetNumberOfPoints( ); ++i )
     {
     double buf[ 3 ];
     seeds->GetPoint( i, buf );
     pnt.Fill( 0 );
     for( unsigned int d = 0; d < dim; ++d )
     pnt[ d ] = buf[ d ];
     if( image->TransformPhysicalPointToIndex( pnt, idx ) )
     indices.push_back( idx );

     } // rof

     typename _TImage::SizeType r;
     r.Fill( this->m_Parameters.GetUint( "Radius" ) );

     _TInIt iIt( r, image, image->GetRequestedRegion( ) );
     double v_s1 = double( 0 );
     double v_s2 = double( 0 );
     double v_n = double( 0 );
     double v_min = std::numeric_limits< double >::max( );
     double v_max = -v_min;
     for( auto idxIt = indices.begin( ); idxIt != indices.end( ); ++idxIt )
     {
     iIt.SetLocation( *idxIt );
     for( unsigned int i = 0; i < iIt.Size( ); ++i )
     {
     double v = double( iIt.GetPixel( i ) );
     v_s1 += v;
     v_s2 += v * v;
     v_n += double( 1 );
     v_min = ( v < v_min )? v: v_min;
     v_max = ( v_max < v )? v: v_max;

     } // rof

     } // rof
     double m = v_s1 / v_n;
     double s = ( v_s2 - ( ( v_s1 * v_s1 ) / v_n ) ) / ( v_n - double( 1 ) );
     s = std::sqrt( s );
     v_min = m - s;
     v_max = m + s;
     f->SetLower( v_min );
     f->SetUpper( v_max );
     this->m_Parameters.SetReal( "Lower", f->GetLower( ) );
     this->m_Parameters.SetReal( "Upper", f->GetUpper( ) );
     }
     else
     {
     f->SetLower( this->m_Parameters.GetReal( "Lower" ) );
     f->SetUpper( this->m_Parameters.GetReal( "Upper" ) );

     } // fi
  */
}

// eof - $RCSfile$