#ifndef _vtk_FibersManager_h_
#define _vtk_FibersManager_h_

#include <vtkCommand.h>
#include <vtkBoxWidget.h>
#include <vtkPolyData.h>
#include <vtkLimitFibersToVOI.h>
#include <vtkLimitFibersToROI.h>
#include <vtkSqueezeFibers.h>
#include <vtkTubeFilter.h>
#include <vtkRibbonFilter.h>
#include <vtkPolyDataMapper.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkRendererCollection.h>
#include <vtkActor.h>

class VTK_EXPORT vtkFibersManagerCallback: public vtkCommand
{

 public:
  static vtkFibersManagerCallback* New()
  { return new vtkFibersManagerCallback; }

  virtual void Execute ( vtkObject *caller, unsigned long, void* );

  vtkPolyData* GetOutput (void) const
  { return this->FiberLimiter->GetOutput(); }
  

  vtkLimitFibersToVOI* GetFiberLimiter (void) const
  { return this->FiberLimiter; }
  
  vtkLimitFibersToROI* GetROIFiberLimiter (void) const
  { return this->ROIFiberLimiter; }
  
    
 protected:
  vtkFibersManagerCallback()
  {
    this->FiberLimiter    = vtkLimitFibersToVOI::New();
    this->ROIFiberLimiter = vtkLimitFibersToROI::New();
    this->FiberLimiter->SetInput ( this->ROIFiberLimiter->GetOutput() );
    
  }
  ~vtkFibersManagerCallback()
  {
    this->FiberLimiter->Delete();
    this->ROIFiberLimiter->Delete();
  }
  
  
 private:
  vtkLimitFibersToVOI* FiberLimiter;
  vtkLimitFibersToROI* ROIFiberLimiter;
  
};


class VTK_EXPORT vtkFibersManager : public vtkObject
{
 public:

  static vtkFibersManager* New();
  vtkTypeRevisionMacro(vtkFibersManager, vtkObject);

  enum vtkFiberRenderingMode
  {
    RENDER_IS_POLYLINES,
    RENDER_IS_TUBES,
    RENDER_IS_RIBBONS
  };

  /** Reset the pipeline, deactivate the CP box and release memory.*/
  void Initialize (void);
  
  /** Set the vtkPolyData input */
  void SetInput (vtkPolyData*);
    
  /** Get the vtkPolyData input */
  vtkPolyData* GetInput (void) const
  { return m_Input; }

  /** Set the generated actor */
  vtkActor* GetOutput (void) const
  { return m_Actor; }

  /** Get the ROI Limiter */
  vtkLimitFibersToROI* GetROILimiter(void) const
  { return m_Callback->GetROIFiberLimiter(); }
  
  /** Set the render window interactor */
  void SetRenderWindowInteractor (vtkRenderWindowInteractor* rwin)
  {
    if( !rwin )
    {
      return;
    }

    if( rwin != m_RWin )
    {

      if( m_RWin != NULL )
      {
        m_RWin->UnRegister (this);
      }

      m_BoxWidget->SetInteractor (rwin);
      m_RWin = rwin;
      m_RWin->Register(this);
    }
    
  }

  /** Set the rendering mode to poly lines */
  void SetRenderingModeToPolyLines (void)
  {
    m_RenderingMode = RENDER_IS_POLYLINES;
    m_Mapper->SetInput (m_Callback->GetOutput());
  }

  /** Set the rendering mode to tubes */
  void SetRenderingModeToTubes (void)
  {
    m_RenderingMode = RENDER_IS_TUBES;    
    m_TubeFilter->Update();
    m_Mapper->SetInput (m_TubeFilter->GetOutput());    
  }

    /** Set the rendering mode to tubes */
  void SetRenderingModeToRibbons (void)
  {
    m_RenderingMode = RENDER_IS_RIBBONS;
    m_RibbonFilter->Update();
    m_Mapper->SetInput (m_RibbonFilter->GetOutput());
  }

  /** Set the ouput of the callback to ite input. Thus, users
      can extract a subsample of fibers, and then another subsample,
      and so on. */
  void SwapInputOutput(void);

  /** Reset the fiber manager to its first input. */
  void Reset (void);

  /** Switch on/off the visibility of the fibers */
  void SetVisibility (bool);

  /** Set the box widget on */
  void BoxWidgetOn (void)
  {
    m_BoxWidgetVisibility = true;
    m_BoxWidget->On();
  }

  /** Set the box widget on */
  void BoxWidgetOff (void)
  {
    m_BoxWidgetVisibility = false;
    m_BoxWidget->Off();
  }

  /** Set the box widget on */
  void SetBoxWidget (bool a)
  {
    m_BoxWidgetVisibility = a;
    if(a)
      m_BoxWidget->On();
    else
      m_BoxWidget->Off();
  }

  /** Get the box widget visibility */
  bool GetBoxWidgetVisibility (void) const
  { return m_BoxWidgetVisibility; }

  /** Set Radius & ribbon width */
  void SetRadius (double r)
  {
    m_TubeFilter->SetRadius (r);
    m_RibbonFilter->SetWidth (r);
  }

  /** Return the fiber ids selected by the box widget */
  vtkCellArray* GetSelectedCells (void) const
  { return m_Callback->GetFiberLimiter()->GetOutput()->GetLines(); }
  
  void SetMaskImage (vtkImageData* image)
  {
    m_Callback->GetROIFiberLimiter()->SetMaskImage (image);
    m_Callback->GetROIFiberLimiter()->Modified();
  }
  
 protected:
  vtkFibersManager();
  ~vtkFibersManager();
  
   
 private:

  vtkPolyData*              m_Input;
  vtkBoxWidget*             m_BoxWidget;
  bool                      m_BoxWidgetVisibility;

  vtkFibersManagerCallback* m_Callback;
  vtkSqueezeFibers*         m_Squeezer; 
  vtkTubeFilter*            m_TubeFilter;
  vtkRibbonFilter*          m_RibbonFilter;
  vtkPolyDataMapper*        m_Mapper;
  vtkActor*                 m_Actor;
  vtkFiberRenderingMode     m_RenderingMode;

  vtkRenderWindowInteractor* m_RWin;
  
};



#endif