#ifndef __CPEXTENSIONS__VISUALIZATION__IMAGESLICEACTORS__H__
#define __CPEXTENSIONS__VISUALIZATION__IMAGESLICEACTORS__H__

#include <cpExtensions/cpExtensions_Export.h>

#include <utility>
#include <vector>

#include <vtkActor.h>
#include <vtkImageActor.h>
#include <vtkImageSliceMapper.h>
#include <vtkPlane.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkPropCollection.h>
#include <vtkSmartPointer.h>
#include <vtkTextActor.h>

#include <cpExtensions/Visualization/ImageInteractorStyle.h>

// -------------------------------------------------------------------------
class vtkAlgorithmOutput;
class vtkImageData;

// -------------------------------------------------------------------------
namespace cpExtensions
{
  namespace Visualization
  {
    /**
     */
    class cpExtensions_EXPORT ImageSliceActors
      : public vtkPropCollection
    {
    public:
      typedef ImageSliceActors Self;

    public:
      vtkTypeMacro( ImageSliceActors, vtkPropCollection );

    public:
      // Creation
      static ImageSliceActors* New( );

      void AddInputConnection( vtkAlgorithmOutput* aout, int axis = 2 );
      void AddInputData( vtkImageData* data, int axis = 2 );
      void Clear( );

      vtkInteractorStyle* GetStyle( );
      const vtkInteractorStyle* GetStyle( ) const;

      void PushActorsInto( vtkRenderer* renderer );
      void PopActorsFrom( vtkRenderer* renderer );
      unsigned int GetNumberOfImageActors( ) const;
      vtkImageActor* GetImageActor( unsigned int id );
      const vtkImageActor* GetImageActor( unsigned int id ) const;
      vtkTextActor* GetTextActor( );
      const vtkTextActor* GetTextActor( ) const;
      vtkActor* GetPlaneActor( );
      const vtkActor* GetPlaneActor( ) const;
      vtkPlane* GetPlaneFunction( );
      const vtkPlane* GetPlaneFunction( ) const;

      void AddActor( vtkAlgorithm* algorithm, vtkActor* actor );
      void AddActor( vtkActor* actor );

      void SetInterpolate( bool v );
      void InterpolateOn( );
      void InterpolateOff( );

      double* GetDisplayBounds( ) const;
      void GetDisplayBounds( double bounds[ 6 ] ) const;

      int GetAxis( ) const;
      int GetSliceNumber( ) const;
      int GetSliceNumberMinValue( ) const;
      int GetSliceNumberMaxValue( ) const;
      void SetSliceNumber( const int& slice );
      void UpdateText( );
      void UpdateText( double pos[ 3 ] );
      void UpdateText( const double& w, const double& l );

    protected:
      ImageSliceActors( );
      virtual ~ImageSliceActors( );

      void _ConfigureNewInput( int axis );

      // Events
      static void _MouseMoveCommand(
        void* data,
        const ImageInteractorStyle::ButtonID& btn, double* pos,
        bool alt, bool ctr, bool sft
        );
      static void _MouseClickCommand(
        void* data,
        const ImageInteractorStyle::ButtonID& btn, double* pos,
        bool alt, bool ctr, bool sft
        );
      static void _MouseDoubleClickCommand(
        void* data,
        const ImageInteractorStyle::ButtonID& btn, double* pos,
        bool alt, bool ctr, bool sft
        );
      static void _MouseWheelCommand(
        void* data,
        const int& dir, bool alt, bool ctr, bool sft
        );
      static void _KeyCommand(
        void* data,
        const char& key
        );

    private:
      // Purposely not implemented
      ImageSliceActors( const Self& );
      Self& operator=( const Self& );

    protected:
      vtkSmartPointer< ImageInteractorStyle > Style;

      // Multiple actors
      std::vector< vtkSmartPointer< vtkImageSliceMapper > > SliceMappers;
      std::vector< vtkSmartPointer< vtkImageActor > >       ImageActors;
      bool Interpolate;

      // Other associated actors
      typedef std::pair< vtkAlgorithm*, vtkActor* > TAssociatedActor;
      typedef std::vector< TAssociatedActor >       TAssociatedActors;
      TAssociatedActors AssociatedActors;

      // Unique objects
      vtkSmartPointer< vtkPlane >          PlaneFunction;
      vtkSmartPointer< vtkPolyData >       PlaneSource;
      vtkSmartPointer< vtkPolyDataMapper > PlaneMapper;
      char                                 TextBuffer[ 1024 ];
      vtkSmartPointer< vtkTextActor >      TextActor;
      vtkSmartPointer< vtkActor >          PlaneActor;
    };

  } // ecapseman

} // ecapseman

#endif //  __CPEXTENSIONS__VISUALIZATION__IMAGESLICEACTORS__H__

// eof - $RCSfile$