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

#ifndef __fpa__tests__image__BaseFunctions__h__
#define __fpa__tests__image__BaseFunctions__h__

#include <cstdarg>
#include <string>

#include <itkImageFileReader.h>
#include <itkImageFileWriter.h>

#include <fpa/Config.h>
/* TODO
   #ifdef USE_ivq
   #  include <itkImageToVTKImageFilter.h>
   #  include <itkVTKImageToImageFilter.h>
   #  include <vtkSmartPointer.h>
   #  include <vtkRenderWindow.h>
   #  include <ivq/VTK/ImageViewer.h>
   #  include <ivq/VTK/BrushWidget.h>
   #  include <ivq/VTK/SeedWidgetOverImageActor.h>
   #  include <fpa/Image/VisualDebugger2D.h>
   #endif // USE_ivq
*/

namespace fpa
{
  namespace tests
  {
    namespace image
    {
      // -------------------------------------------------------------------
      template< class _TPointer >
      void CreateImage(
        _TPointer& img,
        const typename _TPointer::ObjectType::PixelType& zero,
        ...
        )
      {
        typedef typename _TPointer::ObjectType _TImage;

        va_list vl;
        va_start( vl, zero );

        typename _TImage::SizeType size;
        for( unsigned int d = 0; d < _TImage::ImageDimension; ++d )
          size[ d ] = va_arg( vl, int );

        typename _TImage::SpacingType spac;
        for( unsigned int d = 0; d < _TImage::ImageDimension; ++d )
          spac[ d ] = va_arg( vl, double );

        img = _TImage::New( );
        img->SetRegions( size );
        img->SetSpacing( spac );
        img->Allocate( );
        img->FillBuffer( zero );

        va_end( vl );
      }

      // -------------------------------------------------------------------
      template< class _TPointer >
      std::string Read( _TPointer& img, const std::string& fname )
      {
        typedef typename _TPointer::ObjectType _TImage;
        typedef itk::ImageFileReader< _TImage > _TReader;

        typename _TReader::Pointer reader = _TReader::New( );
        reader->SetFileName( fname );
        try
        {
          reader->Update( );
        }
        catch( std::exception& err )
        {
          return( err.what( ) );

        } // ytr
        img = reader->GetOutput( );
        img->DisconnectPipeline( );
        return( "" );
      }

      // -------------------------------------------------------------------
      template< class _TImage >
      std::string Write( const _TImage* img, const std::string& fname )
      {
        typedef itk::ImageFileWriter< _TImage > _TWriter;

        typename _TWriter::Pointer writer = _TWriter::New( );
        writer->SetInput( img );
        writer->SetFileName( fname );
        try
        {
          writer->Update( );
        }
        catch( std::exception& err )
        {
          return( err.what( ) );

        } // ytr
        return( "" );
      }

      // -------------------------------------------------------------------
      /* TODO
         #ifdef USE_ivq
         template< class _TFilter >
         class Viewer
         {
         public:
         typedef _TFilter TFilter;
         typedef typename _TFilter::TInputImage TInputImage;

         public:
         Viewer( const TInputImage* image )
         {
         this->m_VTKInputImage = TVTKInputImage::New( );
         this->m_VTKInputImage->SetInput( image );
         this->m_VTKInputImage->Update( );

         this->m_Viewer = vtkSmartPointer< ivq::VTK::ImageViewer >::New( );
         this->m_Viewer->SetInputData( this->m_VTKInputImage->GetOutput( ) );
         }

         virtual ~Viewer( )
         {
         }

         void ActivateSeedWidget( )
         {
         this->m_SeedWidget =
         vtkSmartPointer< ivq::VTK::SeedWidgetOverImageActor >::New( );
         this->m_SeedWidget->SetActor( this->m_Viewer->GetImageActor( ) );
         this->m_SeedWidget->SetInteractor(
         this->m_Viewer->GetRenderWindow( )->GetInteractor( )
         );
         }

         void ActivateBrushWidget( )
         {
         this->m_BrushWidget =
         vtkSmartPointer< ivq::VTK::BrushWidget >::New( );
         this->m_BrushWidget->SetImageActor( this->m_Viewer->GetImageActor( ) );
         this->m_BrushWidget->SetInteractor(
         this->m_Viewer->GetRenderWindow( )->GetInteractor( )
         );
         }

         void Show( )
         {
         this->m_Viewer->Render( );
         this->m_Viewer->ResetCamera( );
         this->m_Viewer->Initialize( );
         this->m_Viewer->Render( );
         if( this->m_SeedWidget.GetPointer( ) != NULL )
         this->m_SeedWidget->EnabledOn( );
         if( this->m_BrushWidget.GetPointer( ) != NULL )
         this->m_BrushWidget->EnabledOn( );
         this->m_Viewer->Start( );
         if( this->m_SeedWidget.GetPointer( ) != NULL )
         this->m_SeedWidget->EnabledOff( );
         if( this->m_BrushWidget.GetPointer( ) != NULL )
         this->m_BrushWidget->EnabledOff( );
         }

         void AssociateSeedsTo( TFilter* filter )
         {
         if( this->m_SeedWidget.GetPointer( ) != NULL )
         {
         const ivq::VTK::SeedWidgetOverImageActor::TSeeds& wdg_seeds =
         this->m_SeedWidget->GetSeeds( );
         ivq::VTK::SeedWidgetOverImageActor::TSeeds::const_iterator wsIt;
         for( wsIt = wdg_seeds.begin( ); wsIt != wdg_seeds.end( ); ++wsIt )
         {
         typename TInputImage::PointType pnt;
         for( unsigned int i = 0; i < wsIt->second.size( ); i += 3 )
         {
         pnt[ 0 ] = wsIt->second[ i ];
         pnt[ 1 ] = wsIt->second[ i + 1 ];

         typename TInputImage::IndexType idx;
         filter->GetInput( )->TransformPhysicalPointToIndex( pnt, idx );
         filter->AddSeed( idx );

         } // rof

         } // rof

         } // fi
         }

         void AssociateLabelsTo( TFilter* filter )
         {
         if( this->m_BrushWidget.GetPointer( ) != NULL )
         {
         typedef typename TFilter::TLabelImage _TLabelImage;
         typedef itk::VTKImageToImageFilter< _TLabelImage > TITKImage;
         typename TITKImage::Pointer itk_image = TITKImage::New( );
         itk_image->SetInput( this->m_BrushWidget->GetCanvas( ) );
         itk_image->Update( );
         filter->SetLabels( itk_image->GetOutput( ) );

         } // fi
         }

         void ObserveFilter( TFilter* filter )
         {
         typedef fpa::Image::VisualDebugger2D< TFilter > _TDeb;
         typedef typename TFilter::TEvent                _TEvent;
         typename _TDeb::Pointer deb = _TDeb::New( );
         deb->SetVisualization(
         this->m_Viewer->GetRenderer( ),
         this->m_Viewer->GetRenderWindow( )->GetInteractor( )
         );
         this->m_Observer1 = filter->AddObserver( itk::StartEvent( ), deb );
         this->m_Observer2 = filter->AddObserver( itk::EndEvent( ), deb );
         this->m_Observer3 = filter->AddObserver( _TEvent( ), deb );
         filter->VisualDebugOn( );
         }

         protected:
         typedef itk::ImageToVTKImageFilter< TInputImage > TVTKInputImage;
         typename TVTKInputImage::Pointer                      m_VTKInputImage;
         vtkSmartPointer< ivq::VTK::ImageViewer >              m_Viewer;
         vtkSmartPointer< ivq::VTK::SeedWidgetOverImageActor > m_SeedWidget;
         vtkSmartPointer< ivq::VTK::BrushWidget >              m_BrushWidget;
         unsigned long m_Observer1;
         unsigned long m_Observer2;
         unsigned long m_Observer3;
         };
         #endif // USE_ivq
      */

    } // ecapseman

  } // ecapseman

} // ecapseman


#endif // __fpa__tests__image__BaseFunctions__h__

// eof - $RCSfile$