// =========================================================================
// @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>
#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( "" );
      }

      // -------------------------------------------------------------------
      template< class _TFilter >
      class Viewer
      {
      public:
        typedef _TFilter TFilter;
        typedef typename _TFilter::TInputImage TInputImage;

      public:
        Viewer( const TInputImage* image )
          {
#ifdef USE_ivq
            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( ) );
#endif // USE_ivq
          }

        virtual ~Viewer( )
          {
          }

        void ActivateSeedWidget( )
          {
#ifdef USE_ivq
            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( )
              );
#endif // USE_ivq
          }

        void ActivateBrushWidget( )
          {
#ifdef USE_ivq
            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( )
              );
#endif // USE_ivq
          }

        void Show( )
          {
#ifdef USE_ivq
            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( );
#endif // USE_ivq
          }

        void AssociateSeedsTo( TFilter* filter )
          {
#ifdef USE_ivq
            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
#endif // USE_ivq
          }

        void AssociateLabelsTo( TFilter* filter )
          {
#ifdef USE_ivq
            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
#endif // USE_ivq
          }

        void ObserveFilter( TFilter* filter )
          {
#ifdef USE_ivq
            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( );
#endif // USE_ivq
          }

      protected:
#ifdef USE_ivq
        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


        /* TODO
           #ifdef USE_ivq
           // VTK image
           typedef itk::ImageToVTKImageFilter< TImage > TVTKImage;
           TVTKImage::Pointer vtk_input;
           vtkSmartPointer< ivq::VTK::ImageViewer > view;
           vtkSmartPointer< ivq::VTK::SeedWidgetOverImageActor > widget;

           if( visual_debug )
           {
           vtk_input = TVTKImage::New( );
           vtk_input->SetInput( input );
           vtk_input->Update( );

           // Viewer
           view = vtkSmartPointer< ivq::VTK::ImageViewer >::New( );
           view->SetInputData( vtk_input->GetOutput( ) );
           view->SetSlice( 0 );

           // Widget
           widget = vtkSmartPointer< ivq::VTK::SeedWidgetOverImageActor >::New( );
           widget->SetActor( view->GetImageActor( ) );
           widget->SetInteractor( view->GetRenderWindow( )->GetInteractor( ) );

           // Visualize
           view->Render( );
           view->ResetCamera( );
           view->Initialize( );
           view->Render( );
           widget->EnabledOn( );
           view->Start( );
           widget->EnabledOff( );

           const ivq::VTK::SeedWidgetOverImageActor::TSeeds& wdg_seeds =
           widget->GetSeeds( );
           ivq::VTK::SeedWidgetOverImageActor::TSeeds::const_iterator wsIt;
           for( wsIt = wdg_seeds.begin( ); wsIt != wdg_seeds.end( ); ++wsIt )
           {
           TImage::PointType pnt;
           for( unsigned int i = 0; i < wsIt->second.size( ); i += 3 )
           {
           pnt[ 0 ] = wsIt->second[ i ];
           pnt[ 1 ] = wsIt->second[ i + 1 ];

           TImage::IndexType idx;
           input->TransformPhysicalPointToIndex( pnt, idx );
           seeds.push_back( idx );

           } // rof

           } // rof

           } // fi
           #endif // USE_ivq
        */
      };

    } // ecapseman

  } // ecapseman

} // ecapseman


#endif // __fpa__tests__image__BaseFunctions__h__

// eof - $RCSfile$