#ifndef __CPEXTENSIONS__VISUALIZATION__IMAGESLICEACTORS__H__
#define __CPEXTENSIONS__VISUALIZATION__IMAGESLICEACTORS__H__

#include <cpExtensions/cpExtensions_Export.h>

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

#include <cpExtensions/Interaction/ImageInteractorStyle.h>
#include <cpExtensions/Visualization/ImageBlender.h>

// -------------------------------------------------------------------------
class vtkAlgorithmOutput;
class vtkImageData;
class vtkLookupTable;
class vtkRenderer;

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

      typedef cpExtensions::Interaction::ImageInteractorStyle TStyle;
      typedef TStyle::TMouseCommand            TMouseCommand;
      typedef TStyle::TMouseWheelCommand       TMouseWheelCommand;
      typedef TStyle::TKeyCommand              TKeyCommand;
      typedef TStyle::TVoidCommand             TVoidCommand;
      typedef TStyle::TMouseMoveCommand        TMouseMoveCommand;
      typedef TStyle::TMouseClickCommand       TMouseClickCommand;
      typedef TStyle::TMouseDoubleClickCommand TMouseDoubleClickCommand;
      typedef TStyle::TExposeCommand           TExposeCommand;
      typedef TStyle::TConfigureCommand        TConfigureCommand;
      typedef TStyle::TEnterCommand            TEnterCommand;
      typedef TStyle::TLeaveCommand            TLeaveCommand;
      typedef void ( *TSlicesCommand )( double*, int, void* );
      typedef void ( *TWindowLevelCommand )( double, double, void* );
      typedef TVoidCommand TRenderCommand;

      typedef cpExtensions::Visualization::ImageBlender TBlender;

    public:
      vtkTypeMacro( ImageSliceActors, vtkPropCollection );

      cpExtensions_BaseInteractorStyle_Commands( Slices );
      cpExtensions_BaseInteractorStyle_Commands( WindowLevel );
      cpExtensions_BaseInteractorStyle_Commands( Render );

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

      void SetAxis( int axis );
      void SetInputConnection( vtkAlgorithmOutput* aout );
      void SetInputImage( vtkImageData* data );
      int AddBinaryConnection(
        vtkAlgorithmOutput* aout,
        const double& r, const double& g, const double& b
        );
      int AddBinaryImage(
        vtkImageData* data,
        const double& r, const double& g, const double& b
        );
      void Clear( );

      void AssociateSlice( Self* slice );

      vtkImageData* GetInputImage( );
      const vtkImageData* GetInputImage( ) const;

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

      void PushActorsInto( vtkRenderWindow* window, bool force_style = true );
      void PopActorsFrom( vtkRenderWindow* window );
      unsigned int GetNumberOfImages( ) const;

      vtkImageActor* GetImageActor( );
      const vtkImageActor* GetImageActor( ) const;
      vtkImageActor* GetBinaryActor( );
      const vtkImageActor* GetBinaryActor( ) const;
      vtkTextActor* GetTextActor( );
      const vtkTextActor* GetTextActor( ) const;
      vtkActor* GetPlaneActor( );
      const vtkActor* GetPlaneActor( ) const;
      vtkPlane* GetPlaneFunction( );
      const vtkPlane* GetPlaneFunction( ) const;

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

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

      void ResetCursor( );
      void SetCursor( double pos[ 3 ] );

      void ResetAxesCursor( );
      void SetAxesCursor( double pos[ 3 ] );

      double GetMinWindow( ) const;
      double GetMaxWindow( ) const;
      double GetMinLevel( ) const;
      double GetMaxLevel( ) const;
      double GetWindow( ) const;
      double GetLevel( ) const;
      void SetWindow( double w );
      void SetLevel( double l );
      void SetWindowLevel( double w, double l );
      void ResetWindowLevel( );

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

      void Render( const double& t );
      void ResetCamera( );

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

      void _ConfigureStyle( );
      void _ConfigureInputImage( );
      void _ConfigureBinaryImage(
        const double& r, const double& g, const double& b
        );

      // Events
      static void _MouseMoveCommand(
        void* data,
        const TStyle::ButtonID& btn,
        int* idx, double* pos,
        bool alt, bool ctr, bool sft
        );
      static void _MouseClickCommand(
        void* data,
        const TStyle::ButtonID& btn,
        int* idx, 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
        );
      static void _EnterCommand( void* data );
      static void _LeaveCommand( void* data );

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

    protected:
      static double m_PlaneColors[ 3 ][ 3 ];

      vtkSmartPointer< TStyle > m_Style;
      vtkRenderWindow* m_Window;

      // Multiple actors
      vtkSmartPointer< vtkImageSliceMapper > m_ImageMapper;
      vtkSmartPointer< vtkImageActor >       m_ImageActor;

      vtkSmartPointer< vtkImageData >        m_BlenderBase;
      vtkSmartPointer< TBlender >            m_Blender;
      vtkSmartPointer< vtkImageSliceMapper > m_BlenderMapper;
      vtkSmartPointer< vtkLookupTable >      m_BlenderLUT;
      vtkSmartPointer< vtkImageActor >       m_BlenderActor;

      bool m_Interpolate;

      double m_WLRange[ 4 ];

      int    m_VisibleExtent[ 6 ];
      double m_VisibleBounds[ 6 ];

      // Associated slices
      std::vector< Self* > m_AssociatedSlices;

      // Unique objects
      vtkSmartPointer< vtkPolyData >       m_Cursor;
      vtkSmartPointer< vtkPolyDataMapper > m_CursorMapper;
      vtkSmartPointer< vtkActor >          m_CursorActor;

      vtkSmartPointer< vtkPolyData >       m_Axis1;
      vtkSmartPointer< vtkPolyDataMapper > m_Axis1Mapper;
      vtkSmartPointer< vtkActor >          m_Axis1Actor;

      vtkSmartPointer< vtkPolyData >       m_Axis2;
      vtkSmartPointer< vtkPolyDataMapper > m_Axis2Mapper;
      vtkSmartPointer< vtkActor >          m_Axis2Actor;

      vtkSmartPointer< vtkPolyData >       m_Plane;
      vtkSmartPointer< vtkPolyDataMapper > m_PlaneMapper;
      vtkSmartPointer< vtkActor >          m_PlaneActor;

      char                                 m_TextBuffer[ 1024 ];
      vtkSmartPointer< vtkTextActor >      m_TextActor;

      double m_StartWindowLevelPos[ 3 ];
      double m_StartWindowLevel[ 2 ];
    };

  } // ecapseman

} // ecapseman

#endif //  __CPEXTENSIONS__VISUALIZATION__IMAGESLICEACTORS__H__

// eof - $RCSfile$