#ifndef __FPA__IO__MINIMUMSPANNINGTREEREADER__HXX__
#define __FPA__IO__MINIMUMSPANNINGTREEREADER__HXX__

#include <fstream>
#include <sstream>
#include <itkMacro.h>
#include <itkOffset.h>

// -------------------------------------------------------------------------
template< class _TTree >
_TTree* fpa::IO::MinimumSpanningTreeReader< _TTree >::
GetOutput( )
{
  return(
    dynamic_cast< _TTree* >( this->itk::ProcessObject::GetOutput( 0 ) )
    );
}

// -------------------------------------------------------------------------
template< class _TTree >
void fpa::IO::MinimumSpanningTreeReader< _TTree >::
Update( )
{
  this->GenerateData( );
}

// -------------------------------------------------------------------------
template< class _TTree >
fpa::IO::MinimumSpanningTreeReader< _TTree >::
MinimumSpanningTreeReader( )
  : Superclass( ),
    m_FileName( "" )
{
  this->SetNumberOfRequiredInputs( 0 );
  this->SetNumberOfRequiredOutputs( 0 );
  typename _TTree::Pointer out = _TTree::New( );
  this->itk::ProcessObject::SetNthOutput( 0, out.GetPointer( ) );
}

// -------------------------------------------------------------------------
template< class _TTree >
fpa::IO::MinimumSpanningTreeReader< _TTree >::
~MinimumSpanningTreeReader( )
{
}

// -------------------------------------------------------------------------
template< class _TTree >
void fpa::IO::MinimumSpanningTreeReader< _TTree >::
GenerateData( )
{
  _TTree* tree = this->GetOutput( );

  char* buff = NULL;
  std::ifstream file(
    this->m_FileName.c_str( ),
    std::ios::in | std::ios::binary | std::ios::ate
    );
  if( !file )
  {
    itkExceptionMacro(
      << "Error opening file to read a minimum spanning tree: \""
      << this->m_FileName
      << "\""
      );
    return;

  } // fi

  // Put all file into a memory buffer
  auto size = file.tellg( );
  buff = new char[ size ];
  file.seekg( 0, std::ios::beg );
  file.read ( buff, size );
  file.close( );
  std::istringstream in( buff );

  // Read basic data
  unsigned int dim, fill_queue;
  in >> dim >> fill_queue;
  tree->SetFillNodeQueue( fill_queue == 1 );

  // Read regions
  typename _TTree::IndexType li, ri, bi;
  typename _TTree::SizeType ls, rs, bs;
  li.Fill( 0 );
  ri = bi = li;
  ls.Fill( 0 );
  rs = bs = ls;
  for( unsigned int d = 0; d < dim; ++d )
    if( d < _TTree::ImageDimension )
      in >> li[ d ] >> ls[ d ];
  for( unsigned int d = 0; d < dim; ++d )
    if( d < _TTree::ImageDimension )
      in >> ri[ d ] >> rs[ d ];
  for( unsigned int d = 0; d < dim; ++d )
    if( d < _TTree::ImageDimension )
      in >> bi[ d ] >> bs[ d ];
  typename _TTree::RegionType lr, rr, br;
  lr.SetIndex( li ); lr.SetSize( ls );
  rr.SetIndex( ri ); rr.SetSize( rs );
  br.SetIndex( bi ); br.SetSize( bs );

  // Read spatial information
  typename _TTree::SpacingType   spc;
  typename _TTree::PointType     ori;
  typename _TTree::DirectionType dir;
  for( unsigned int d = 0; d < dim; ++d )
    if( d < _TTree::ImageDimension )
      in >> ori[ d ];
  for( unsigned int d = 0; d < dim; ++d )
    if( d < _TTree::ImageDimension )
      in >> spc[ d ];
  for( unsigned int d = 0; d < dim; ++d )
  {
    if( d < _TTree::ImageDimension )
    {
      for( unsigned int e = 0; e < dim; ++e )
        if( e < _TTree::ImageDimension )
          in >> dir[ d ][ e ];

    } // fi

  } // rof

  // Allocate memory and prepare it
  tree->SetLargestPossibleRegion( lr );
  tree->SetRequestedRegion( rr );
  tree->SetBufferedRegion( br );
  tree->SetOrigin( ori );
  tree->SetSpacing( spc );
  tree->SetDirection( dir );
  tree->Allocate( );
  tree->Clear( );

  // Read collisions
  typedef typename _TTree::TCollision     _TCollision;
  typedef typename _TTree::TCollisionsRow _TCollisionsRow;
  typename _TTree::TCollisions coll;
  unsigned long coll_size;
  in >> coll_size;
  for( unsigned long i = 0; i < coll_size; ++i )
  {
    coll.push_back( _TCollisionsRow( ) );

    unsigned long row_size;
    in >> row_size;
    for( unsigned long j = 0; j < row_size; ++j )
    {
      typename _TTree::IndexType v;
      for( unsigned int d = 0; d < dim; ++d )
        if( d < _TTree::ImageDimension )
          in >> v[ d ];
      unsigned int b;
      in >> b;
      coll[ i ].push_back( _TCollision( v, b == 1 ) );
      
    } // rof

  } // rof
  tree->SetCollisions( coll );

  // Read vertices
  while( !in.eof( ) )
  {
    short fid;
    double cost;
    typename _TTree::IndexType v;
    typename _TTree::IndexType::OffsetType p;
    in >> fid >> cost;
    for( unsigned int d = 0; d < dim; ++d )
      if( d < _TTree::ImageDimension )
        in >> v[ d ];
    for( unsigned int d = 0; d < dim; ++d )
      if( d < _TTree::ImageDimension )
        in >> p[ d ];
    tree->SetNode( v, v + p, fid, cost );

  } // elihw

  // Free buffer
  delete [] buff;
}

#endif // __FPA__IO__MINIMUMSPANNINGTREEREADER__HXX__

// eof - $RCSfile$