#ifndef __FPA__UTILITY__H__
#define __FPA__UTILITY__H__

#include <sstream>

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

#include <vtkCamera.h>
#include <vtkImageActor.h>
#include <vtkImageData.h>
#include <vtkInteractorStyleImage.h>
#include <vtkPointHandleRepresentation3D.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkSeedRepresentation.h>
#include <vtkSeedWidget.h>
#include <vtkSmartPointer.h>

namespace fpa_Utility
{
  /**
   */
  struct Viewer2DWithSeeds
  {
    vtkSmartPointer< vtkImageData >                   Image;
    vtkSmartPointer< vtkImageActor >                  ImageActor;
    vtkSmartPointer< vtkRenderer >                    Renderer;
    vtkSmartPointer< vtkRenderWindow >                Window;
    vtkSmartPointer< vtkInteractorStyleImage >        Style;
    vtkSmartPointer< vtkRenderWindowInteractor >      Interactor;
    vtkSmartPointer< vtkPointHandleRepresentation3D > Handle;
    vtkSmartPointer< vtkSeedRepresentation >          Representation;
    vtkSmartPointer< vtkSeedWidget >                  Widget;

    Viewer2DWithSeeds( )
      {
        this->ImageActor = vtkSmartPointer< vtkImageActor >::New( );
        this->Renderer = vtkSmartPointer< vtkRenderer >::New( );
        this->Window = vtkSmartPointer< vtkRenderWindow >::New( );
        this->Style = vtkSmartPointer< vtkInteractorStyleImage >::New( );
        this->Interactor = vtkSmartPointer< vtkRenderWindowInteractor >::New( );
        this->Handle = vtkSmartPointer< vtkPointHandleRepresentation3D >::New( );
        this->Representation = vtkSmartPointer< vtkSeedRepresentation >::New( );
        this->Widget = vtkSmartPointer< vtkSeedWidget >::New( );

        this->Renderer->SetBackground( 0.1, 0.2, 0.7 );
        this->Window->SetSize( 600, 600 );
        this->Window->AddRenderer( this->Renderer );
        this->Interactor->SetInteractorStyle( this->Style );
        this->Window->SetInteractor( this->Interactor );
        this->Handle->GetProperty( )->SetColor( 1, 0, 0 );
        this->Representation->SetHandleRepresentation( this->Handle );
        this->Widget->SetInteractor( this->Interactor );
        this->Widget->SetRepresentation( this->Representation );
      }
    void SetImage( vtkImageData* image )
      {
        this->Image = image;
        this->ImageActor->SetInputData( this->Image );
        this->Renderer->AddActor( this->ImageActor );

        // Correct camera due to the loaded image
        vtkCamera* camera = this->Renderer->GetActiveCamera( );
        camera->SetViewUp( 0, -1, 0 );
        camera->SetPosition( 0, 0, -1 );
        camera->SetFocalPoint( 0, 0, 0 );

        // Prepare visualization
        this->Interactor->Initialize( );
        this->Renderer->ResetCamera( );
      }
    void Render( )
      {
        this->Window->Render( );
      }
    void Start( )
      {
        this->Window->Render( );
        this->Widget->On( );
        this->Interactor->Start( );
      }
    unsigned long GetNumberOfSeeds( ) const
      {
        return( this->Representation->GetNumberOfSeeds( ) );
      }

    template< class P >
    bool GetSeed( P& seed, unsigned long i )
      {
        if( i < this->Representation->GetNumberOfSeeds( ) )
        {
          double pos[ 3 ];
          this->Representation->GetSeedWorldPosition( i, pos );

          seed[ 0 ] = ( typename P::ValueType )( pos[ 0 ] );
          seed[ 1 ] = ( typename P::ValueType )( pos[ 1 ] );

          return( true );
        }
        else
          return( false );
      }
  };

  // -----------------------------------------------------------------------
  template< class Ip >
  std::string ReadImage( Ip& image, const std::string& fname )
  {
    typename itk::ImageFileReader< typename Ip::ObjectType >::Pointer r =
      itk::ImageFileReader< typename Ip::ObjectType >::New( );
    r->SetFileName( fname );
    try
    {
      r->Update( );
    }
    catch( itk::ExceptionObject& err )
    {
      std::stringstream str;
      str << "Error while reading image from " << fname << ": " << err;
      return( str.str( ) );

    } // yrt
    image = r->GetOutput( );
    image->DisconnectPipeline( );
    return( "" );
  }

  // -----------------------------------------------------------------------
  template< class I >
  std::string SaveImage( const I* image, const std::string& fname )
  {
    typename itk::ImageFileWriter< I >::Pointer w =
      itk::ImageFileWriter< I >::New( );
    w->SetInput( image );
    w->SetFileName( fname );
    try
    {
      w->Update( );
    }
    catch( itk::ExceptionObject& err )
    {
      std::stringstream str;
      str << "Error while reading image from " << fname << ": " << err;
      return( str.str( ) );

    } // yrt
    return( "" );
  }

} // ecapseman

#endif // __FPA__UTILITY__H__

// eof - $RCSfile$