// =========================================================================
// @author Leonardo Florez Valencia
// @email florez-l@javeriana.edu.co
// =========================================================================
#ifndef __fpa__Common__Image__SkeletonWriter__hxx__
#define __fpa__Common__Image__SkeletonWriter__hxx__

#include <fstream>

// -------------------------------------------------------------------------
template< class _TSkeleton >
const _TSkeleton* fpa::Common::Image::SkeletonWriter< _TSkeleton >::
GetInput( ) const
{
  return(
    dynamic_cast< const TSkeleton* >(
      this->itk::ProcessObject::GetInput( 0 )
      )
    );
}

// -------------------------------------------------------------------------
template< class _TSkeleton >
void fpa::Common::Image::SkeletonWriter< _TSkeleton >::
SetInput( const _TSkeleton* skeleton )
{
  this->itk::ProcessObject::SetNthInput(
    0, const_cast< TSkeleton* >( skeleton )
    );
}

// -------------------------------------------------------------------------
template< class _TSkeleton >
void fpa::Common::Image::SkeletonWriter< _TSkeleton >::
Update( )
{
  TSkeleton* input = const_cast< TSkeleton* >( this->GetInput( ) );
  if( input != NULL )
  {
    input->UpdateOutputInformation( );
    input->UpdateOutputData( );
    this->GenerateData( );
    this->ReleaseInputs( );

  } // fi
}

// -------------------------------------------------------------------------
template< class _TSkeleton >
fpa::Common::Image::SkeletonWriter< _TSkeleton >::
SkeletonWriter( )
  : Superclass( ),
    m_FileName( "" )
{
  this->SetNumberOfRequiredInputs( 1 );
}

// -------------------------------------------------------------------------
template< class _TSkeleton >
fpa::Common::Image::SkeletonWriter< _TSkeleton >::
~SkeletonWriter( )
{
}

// -------------------------------------------------------------------------
template< class _TSkeleton >
void fpa::Common::Image::SkeletonWriter< _TSkeleton >::
GenerateData( )
{
  const TSkeleton* sk = this->GetInput( );
  typename TMatrix::const_iterator mIt = sk->BeginEdgesRows( );
  typename TMatrixRow::const_iterator rIt = mIt->second.begin( );
  typename TEdges::const_iterator eIt = rIt->second.begin( );
  const TPath* path = *eIt;

  // Write base information
  std::stringstream out1, out2;
  out1 << TSkeleton::Dimension << std::endl;
  typename TPath::TSpacing spa = path->GetSpacing( );
  for( unsigned int d = 0; d < TSkeleton::Dimension; ++d )
    out1 << spa[ d ] << " ";
  out1 << std::endl;
  typename TPath::TDirection dir = path->GetDirection( );
  for( unsigned int d = 0; d < TSkeleton::Dimension; ++d )
    for( unsigned int e = 0; e < TSkeleton::Dimension; ++e )
      out1 << dir[ d ][ e ] << " ";
  out1 << std::endl;
  typename TPath::TPoint ori = path->GetOrigin( );
  for( unsigned int d = 0; d < TSkeleton::Dimension; ++d )
    out1 << ori[ d ] << " ";
  out1 << std::endl;

  // End points
  std::vector< TVertex > end_points = sk->GetEndPoints( );
  out1 << end_points.size( ) << std::endl;
  typename std::vector< TVertex >::const_iterator epIt = end_points.begin( );
  for( ; epIt != end_points.end( ); ++epIt )
  {
    for( unsigned int d = 0; d < TSkeleton::Dimension; ++d )
      out1 << ( *epIt )[ d ] << " ";
    out1 << std::endl;

  } // rof

  // Bifurcations
  std::vector< TVertex > bifurcations = sk->GetBifurcations( );
  out1 << bifurcations.size( ) << std::endl;
  typename std::vector< TVertex >::const_iterator bIt = bifurcations.begin( );
  for( ; bIt != bifurcations.end( ); ++bIt )
  {
    for( unsigned int d = 0; d < TSkeleton::Dimension; ++d )
      out1 << ( *bIt )[ d ] << " ";
    out1 << std::endl;

  } // rof

  // Write paths
  unsigned long pathCount = 0;
  mIt = sk->BeginEdgesRows( );
  for( ; mIt != sk->EndEdgesRows( ); ++mIt )
  {
    typename TMatrixRow::const_iterator rIt = mIt->second.begin( );
    for( ; rIt != mIt->second.end( ); ++rIt )
    {
      typename TEdges::const_iterator eIt = rIt->second.begin( );
      for( ; eIt != rIt->second.end( ); ++eIt )
      {
        TPath* path = *eIt;
        pathCount++;
        unsigned int size = path->GetSize( );
        out2 << size << std::endl;
        for( unsigned int i = 0; i < path->GetSize( ); ++i )
        {
          TVertex v = path->GetVertex( i );
          for( unsigned int d = 0; d < TSkeleton::Dimension; ++d )
            out2 << v[ d ] << " ";

        } // rof
        out2 << std::endl;

      } // rof

    } // rof

  } // rof
  out1 << pathCount << std::endl << out2.str( );

  // Real write
  std::ofstream file_stream( this->m_FileName.c_str( ), std::ofstream::binary );
  if( !file_stream )
    itkExceptionMacro(
      << "Unable to write skeleton to \""
      << this->m_FileName
      << "\""
      );
  file_stream.write( out1.str( ).c_str( ), out1.str( ).size( ) );
}

#endif // __fpa__Common__Image__SkeletonWriter__hxx__

// eof - $RCSfile$