#include "vtkFibersManager.h"

#include <vtkProperty.h>
#include <vtkObjectFactory.h>
#include <vtkPointData.h>
#include <vtkCellArray.h>
#include <vtkRenderWindow.h>

#include <sstream>
#include <assert.h>
#include <cmath>

#include <stdio.h>

vtkCxxRevisionMacro(vtkFibersManager, "$Revision: 1.21 $");
vtkStandardNewMacro(vtkFibersManager);

void vtkFibersManagerCallback::Execute ( vtkObject *caller, unsigned long, void* )
{
  // get the box widget
  vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget*>(caller);

  // get the inputed vtkPolyData
  vtkPolyData* input = (vtkPolyData*)widget->GetInput();
  if( !input )
  {
    return;
  }
  
  // Get the poly data defined by the vtkBoxWidget
  vtkPolyData* myBox = vtkPolyData::New();
  widget->GetPolyData(myBox);
  
  // myBox contains 15 points and points 8 to 13
  // define the bounding box
  double xmin, xmax, ymin, ymax, zmin, zmax;
  double* pt = myBox->GetPoint(8);
  xmin = pt[0];
  pt = myBox->GetPoint(9);
  xmax = pt[0];
  pt = myBox->GetPoint(10);
  ymin = pt[1];
  pt = myBox->GetPoint(11);
  ymax = pt[1];
  pt = myBox->GetPoint(12);
  zmin = pt[2];
  pt = myBox->GetPoint(13);
  zmax = pt[2];
  
  this->FiberLimiter->SetVOI ((int)xmin, (int)xmax, (int)ymin, (int)ymax, (int)zmin, (int)zmax);
  this->ROIFiberLimiter->Update();
  this->FiberLimiter->Update();

  myBox->Delete();  
}



vtkFibersManager::vtkFibersManager()
{
  m_Input = 0;
  m_RWin = 0;
  m_BoxWidget    = vtkBoxWidget::New();
  m_Callback     = vtkFibersManagerCallback::New();
  m_Squeezer     = vtkSqueezeFibers::New();
  m_TubeFilter   = vtkTubeFilter::New();
  m_RibbonFilter = vtkRibbonFilter::New();
  m_Mapper       = vtkPolyDataMapper::New();
  m_Actor        = vtkActor::New();
  
  m_RenderingMode = RENDER_IS_POLYLINES;

  m_BoxWidget->RotationEnabledOff();
  m_BoxWidget->SetPlaceFactor (1.0);
  m_BoxWidget->AddObserver (vtkCommand::InteractionEvent, m_Callback);
  m_BoxWidgetVisibility = true;
  // link the limiters
  
  //m_Squeezer->SetInput(m_Cleaner->GetOutput());

  m_TubeFilter->SetInput(m_Squeezer->GetOutput());
  m_TubeFilter->SetRadius (0.15);
  m_TubeFilter->SetNumberOfSides (4);
  //m_TubeFilter->UseDefaultNormalOff();
  m_TubeFilter->CappingOn();

  m_RibbonFilter->SetInput(m_Squeezer->GetOutput());
  m_RibbonFilter->SetWidth (0.15);

  m_Mapper->SetInput (m_Callback->GetOutput());
  m_Actor->SetMapper (m_Mapper);
  //m_Actor->GetProperty()->SetAmbient (0.0);
  //m_Actor->GetProperty()->SetDiffuse (0.9);
  //m_Actor->GetProperty()->SetSpecular (0.1);
  //m_Actor->GetProperty()->SetSpecularPower(10.0);
  //m_Actor->GetProperty()->SetInterpolationToPhong();

}


vtkFibersManager::~vtkFibersManager()
{
  if( m_RWin )
  {
    m_RWin->GetRenderWindow()->GetRenderers()->InitTraversal();
    vtkRenderer* first_renderer = m_RWin->GetRenderWindow()->GetRenderers()->GetNextItem();
    if (first_renderer)
    {
      first_renderer->RemoveActor(m_Actor);
    }

    m_RWin->Delete();
  }
  m_BoxWidget->Delete();
  m_Callback->Delete();
  m_Squeezer->Delete();
  m_TubeFilter->Delete();
  m_RibbonFilter->Delete();
  m_Mapper->Delete();
  m_Actor->Delete(); 
}


void vtkFibersManager::SetInput(vtkPolyData* input)
{
  if( !input ) return;
  if( !input->GetNumberOfPoints() )
    return;
  
  this->Initialize();
  m_Input = input;
  
  m_Callback->GetROIFiberLimiter()->SetInput ( this->GetInput() );

  m_Callback->GetFiberLimiter()->SetInput ( m_Callback->GetROIFiberLimiter()->GetOutput() );
  
  m_BoxWidget->SetInput ( this->GetInput() );
  m_BoxWidget->PlaceWidget();
  /*
  if (m_BoxWidgetVisibility)
  {
    m_BoxWidget->On();
  }
  else
  {
    m_BoxWidget->Off();
  }*/

  m_Callback->Execute (m_BoxWidget, 0, NULL);
  
  //m_TubeFilter->SetInput(m_Callback->GetOutput());
  //m_RibbonFilter->SetInput (m_Callback->GetOutput());
  m_Squeezer->SetInput(m_Callback->GetOutput());

  // add the actor to the rwin
  if( m_RWin )
  {
    m_RWin->GetRenderWindow()->GetRenderers()->InitTraversal();
    vtkRenderer* first_renderer = m_RWin->GetRenderWindow()->GetRenderers()->GetNextItem();
    if (first_renderer)
      first_renderer->AddActor(m_Actor);
  }

}


void vtkFibersManager::SwapInputOutput()
{
  vtkPolyData* auxPoly = vtkPolyData::New();
  //auxPoly->DeepCopy( m_Callback->GetOutput() );
  auxPoly->SetPoints( m_Callback->GetOutput()->GetPoints() );
  auxPoly->GetPointData()->SetScalars( m_Callback->GetOutput()->GetPointData()->GetScalars() );

  vtkCellArray* auxLines = vtkCellArray::New();
  auxLines->DeepCopy( m_Callback->GetOutput()->GetLines() );
  auxPoly->SetLines( auxLines);

  m_BoxWidget->SetInput ( auxPoly );
  m_Callback->GetFiberLimiter()->SetInput ( auxPoly );
  
  auxPoly->Delete();
  auxLines->Delete();
}


void vtkFibersManager::Reset()
{
  if( !this->GetInput() ) return;

  m_BoxWidget->SetInput ( this->GetInput() );  

  m_Callback->GetFiberLimiter()->SetInput ( m_Callback->GetROIFiberLimiter()->GetOutput() );

  m_Callback->Execute (m_BoxWidget, 0, NULL);
}


void vtkFibersManager::SetVisibility (bool isVisible)
{
  m_Actor->SetVisibility (isVisible);
  if (isVisible)
    this->SetBoxWidget (m_BoxWidgetVisibility);
  /*else
    m_BoxWidget->Off();*/
}

void vtkFibersManager::Initialize (void)
{    
  m_Callback->GetFiberLimiter()->GetOutput()->Initialize();
  m_Callback->GetROIFiberLimiter()->GetOutput()->Initialize();
  m_Callback->GetROIFiberLimiter()->RemoveAllInputs();

  m_TubeFilter->GetOutput()->Initialize();

  m_RibbonFilter->GetOutput()->Initialize();
  m_Squeezer->GetOutput()->Initialize(); 
  
  m_Input=0;
}