// =========================================================================
// @author Leonardo Florez Valencia
// @email florez-l@javeriana.edu.co
// =========================================================================

#ifndef __fpa__Image__Algorithm__hxx__
#define __fpa__Image__Algorithm__hxx__

// -------------------------------------------------------------------------
template< class _TTraits >
typename fpa::Image::Algorithm< _TTraits >::TMarks*
fpa::Image::Algorithm< _TTraits >::
GetMarks( )
{
  return(
    dynamic_cast< TMarks* >(
      this->itk::ProcessObject::GetOutput( this->m_MarksIdx )
      )
    );
}

// -------------------------------------------------------------------------
template< class _TTraits >
const typename fpa::Image::Algorithm< _TTraits >::TMarks*
fpa::Image::Algorithm< _TTraits >::
GetMarks( ) const
{
  return(
    dynamic_cast< const TMarks* >(
      this->itk::ProcessObject::GetOutput( this->m_MarksIdx )
      )
    );
}

// -------------------------------------------------------------------------
template< class _TTraits >
fpa::Image::Algorithm< _TTraits >::
Algorithm( )
  : Superclass( ),
    m_NeigborhoodOrder( 1 )
{
  this->m_MarksIdx = this->GetNumberOfRequiredOutputs( );
  this->itk::ProcessObject::SetNumberOfRequiredOutputs( this->m_MarksIdx + 1 );
  this->SetNthOutput( this->m_MarksIdx, TMarks::New( ) );
}

// -------------------------------------------------------------------------
template< class _TTraits >
fpa::Image::Algorithm< _TTraits >::
~Algorithm( )
{
}

// -------------------------------------------------------------------------
template< class _TTraits >
typename fpa::Image::Algorithm< _TTraits >::TNodes
fpa::Image::Algorithm< _TTraits >::
_UnifySeeds( )
{
  const TInputImage* input = this->GetInput( );
  typename TInputImage::RegionType region = input->GetRequestedRegion( );
  TSeeds& seeds = this->GetSeeds( );
  TNodes nodes;

  typename TSeeds::iterator sIt = seeds.begin( );
  for( ; sIt != seeds.end( ); ++sIt )
  {
    TNode node;
    if( sIt->IsPoint )
      input->TransformPhysicalPointToIndex( sIt->Point, sIt->Vertex );
    else
      input->TransformIndexToPhysicalPoint( sIt->Vertex, sIt->Point );
    if( region.IsInside( sIt->Vertex ) )
    {
      sIt->IsUnified = true;
      node.Vertex = sIt->Vertex;
      node.Parent = node.Vertex;
      if( sIt->FrontId == 0 )
        node.FrontId = nodes.size( ) + 1;
      else
        node.FrontId = sIt->FrontId;
      nodes.insert( node );
    }
    else
      sIt->IsUnified = false;

  } // rof

  return( nodes );
}

// -------------------------------------------------------------------------
template< class _TTraits >
void fpa::Image::Algorithm< _TTraits >::
_ConfigureOutput( const TOutputValue& v )
{
  const TInputImage* in = this->GetInput( );

  TOutputImage* out = this->GetOutput( );
  out->SetLargestPossibleRegion( in->GetLargestPossibleRegion( ) );
  out->SetRequestedRegion( in->GetRequestedRegion( ) );
  out->SetBufferedRegion( in->GetBufferedRegion( ) );
  out->SetSpacing( in->GetSpacing( ) );
  out->SetOrigin( in->GetOrigin( ) );
  out->SetDirection( in->GetDirection( ) );
  out->Allocate( );
  out->FillBuffer( v );

  TMarks* marks = this->GetMarks( );
  marks->SetLargestPossibleRegion( in->GetLargestPossibleRegion( ) );
  marks->SetRequestedRegion( in->GetRequestedRegion( ) );
  marks->SetBufferedRegion( in->GetBufferedRegion( ) );
  marks->SetSpacing( in->GetSpacing( ) );
  marks->SetOrigin( in->GetOrigin( ) );
  marks->SetDirection( in->GetDirection( ) );
  marks->Allocate( );
  marks->FillBuffer( TFrontId( 0 ) );
}

// -------------------------------------------------------------------------
template< class _TTraits >
typename fpa::Image::Algorithm< _TTraits >::TNeighborhood
fpa::Image::Algorithm< _TTraits >::
_GetNeighbors( const TVertex& v ) const
{
  typename TInputImage::RegionType region =
    this->GetInput( )->GetRequestedRegion( );
  TNeighborhood neighborhood;
  if( this->m_NeigborhoodOrder != 1 )
  {
    // TODO
  }
  else
  {
    for( unsigned int d = 0; d < TInputImage::ImageDimension; ++d )
    {
      for( int s = -1; s <= 1; s += 2 )
      {
        TVertex n = v;
        n[ d ] += s;
        if( region.IsInside( n ) )
          neighborhood.push_back( n );

      } // rof

    } // rof

  } // fi
  return( neighborhood );
}

// -------------------------------------------------------------------------
template< class _TTraits >
typename fpa::Image::Algorithm< _TTraits >::TInputValue
fpa::Image::Algorithm< _TTraits >::
_GetInputValue( const TVertex& v ) const
{
  return( this->GetInput( )->GetPixel( v ) );
}

// -------------------------------------------------------------------------
template< class _TTraits >
typename fpa::Image::Algorithm< _TTraits >::TOutputValue
fpa::Image::Algorithm< _TTraits >::
_GetOutputValue( const TVertex& v ) const
{
  return( this->GetOutput( )->GetPixel( v ) );
}

// -------------------------------------------------------------------------
template< class _TTraits >
void fpa::Image::Algorithm< _TTraits >::
_UpdateOutputValue( TNode& n )
{
  this->GetOutput( )->SetPixel( n.Vertex, n.Value );
}

// -------------------------------------------------------------------------
template< class _TTraits >
bool fpa::Image::Algorithm< _TTraits >::
_IsMarked( const TVertex& v ) const
{
  return( this->GetMarks( )->GetPixel( v ) > 0 );
}

// -------------------------------------------------------------------------
template< class _TTraits >
unsigned long fpa::Image::Algorithm< _TTraits >::
_GetMark( const TVertex& v ) const
{
  return( ( unsigned long )( this->GetMarks( )->GetPixel( v ) ) );
}

// -------------------------------------------------------------------------
template< class _TTraits >
void fpa::Image::Algorithm< _TTraits >::
_Mark( const TVertex& v, unsigned long frontId )
{
  this->GetMarks( )->SetPixel( v, TFrontId( frontId ) );
}

#endif // __fpa__Image__Algorithm__hxx__

// eof - $RCSfile$