/*=========================================================================                                                                               
  Program:   bbtk
  Module:    $RCSfile: bbvtkImagePlanes.cxx,v $
  Language:  C++
  Date:      $Date: 2008/12/18 11:55:00 $
  Version:   $Revision: 1.18 $
=========================================================================*/

/* ---------------------------------------------------------------------

* Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
* Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
*
*  This software is governed by the CeCILL-B license under French law and 
*  abiding by the rules of distribution of free software. You can  use, 
*  modify and/ or redistribute the software under the terms of the CeCILL-B 
*  license as circulated by CEA, CNRS and INRIA at the following URL 
*  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
*  or in the file LICENSE.txt.
*
*  As a counterpart to the access to the source code and  rights to copy,
*  modify and redistribute granted by the license, users are provided only
*  with a limited warranty  and the software's author,  the holder of the
*  economic rights,  and the successive licensors  have only  limited
*  liability. 
*
*  The fact that you are presently reading this means that you have had
*  knowledge of the CeCILL-B license and that you accept its terms.
* ------------------------------------------------------------------------ */                                                                         

/**
 *  \file 
 *  \brief 
 */

#ifdef _USE_VTK_
#include "bbvtkImagePlanes.h"
#include "bbvtkPackage.h"
#include "vtkCellPicker.h"
#include "vtkProperty.h"

#include "vtkMetaImageWriter.h"
#include "vtkPNGWriter.h"

#include "bbstdCast.h"
#include <vtkCommand.h>

#include "vtkImageData.h"
//#include "vtkOutlineFilter.h"
//#include "vtkPolyDataMapper.h"
//#include "vtkActor.h"
#include "vtkImagePlaneWidget.h"
#include "vtkCellPicker.h"
//#include "vtkProperty.h"

//#include "vtkRenderer.h"
//#include "vtkCamera.h"

#include "vtkPlaneWidget.h"

#include "bbstdRelay.h"

namespace bbstd
{

  //====================================================================
  BBTK_BLACK_BOX_TEMPLATE2_IMPLEMENTATION(Cast,
					  bbtk::AtomicBlackBox);
  //====================================================================
  //====================================================================
  BBTK_BLACK_BOX_TEMPLATE_IMPLEMENTATION(Relay,
					 bbtk::AtomicBlackBox);
  //====================================================================

}
using namespace bbstd;


namespace bbvtk
{


  //====================================================================
  // Add the specialized adaptors to the package
  typedef vtkImagePlaneWidget* I;
  typedef vtkInteractorObserver* O;

  BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(vtk,Cast,I,O);

  BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(vtk,Relay,vtkImageDataPointer);

}

namespace bbvtk
{

  //================================================================
 class myCallbackPlane : public vtkCommand
 {
 public:
   static myCallbackPlane *New()
      {
         return new myCallbackPlane;
      }
   virtual void Execute(vtkObject *caller, unsigned long, void*)
   {
       currentBlackBox->Process();
       currentBlackBox->bbSignalOutputModification();
   } 
   void SetCurrentBlackBox(ImagePlanes *cBB) {currentBlackBox = cBB;};    
   void SetVtkPlaneWidget( vtkImagePlaneWidget *planeWidget );
   myCallbackPlane() {};

 private:
   vtkPlaneWidget *planeWidget;
   ImagePlanes *currentBlackBox;
 };
  //================================================================



  //================================================================

   BBTK_ADD_BLACK_BOX_TO_PACKAGE(vtk,ImagePlanes)
   BBTK_BLACK_BOX_IMPLEMENTATION(ImagePlanes,bbtk::AtomicBlackBox);

   void ImagePlanes::bbUserConstructor() 
   { 
     bbSetOutputPlaneX(0);
     bbSetOutputPlaneY(0);
     bbSetOutputPlaneZ(0);
     bbSetOutputImageX(0);
     bbSetOutputImageY(0);
     bbSetOutputImageZ(0);
     bbSetInputIn(0);
     std::vector<double> vect;
     vect.push_back(0);
     vect.push_back(0);
     bbSetInputWindowLevel (vect);  
   }
   
   void ImagePlanes::bbUserCopyConstructor(bbtk::BlackBox::Pointer) 
   { 
     bbSetOutputPlaneX(0);
     bbSetOutputPlaneY(0);
     bbSetOutputPlaneZ(0);
     bbSetOutputImageX(0);
     bbSetOutputImageY(0);
     bbSetOutputImageZ(0);
   }

   void ImagePlanes::Init() 
   {  

     /// CREATION DES WIDGETS
     if (bbGetOutputPlaneX() != 0) return;
       
     // The shared picker enables us to use 3 planes at one time
     // and gets the picking order right
     vtkCellPicker* picker = vtkCellPicker::New();
     picker->SetTolerance(0.005);
  
     // The 3 image plane widgets 
     vtkImagePlaneWidget* planeWidgetX = vtkImagePlaneWidget::New();
     planeWidgetX->DisplayTextOn();
     planeWidgetX->SetPicker(picker);
     planeWidgetX->SetKeyPressActivationValue('x');
     vtkProperty* prop1 = planeWidgetX->GetPlaneProperty();
     prop1->SetColor(1, 0, 0);

     vtkImagePlaneWidget* planeWidgetY = vtkImagePlaneWidget::New();
     planeWidgetY->DisplayTextOn();
     planeWidgetY->SetPicker(picker);
     planeWidgetY->SetKeyPressActivationValue('y');
     vtkProperty* prop2 = planeWidgetY->GetPlaneProperty();
     prop2->SetColor(1, 1, 0);
     planeWidgetY->SetLookupTable(planeWidgetX->GetLookupTable());

     vtkImagePlaneWidget* planeWidgetZ = vtkImagePlaneWidget::New();
     planeWidgetZ->DisplayTextOn();
     planeWidgetZ->SetPicker(picker);
     planeWidgetZ->SetKeyPressActivationValue('z');
     vtkProperty* prop3 = planeWidgetZ->GetPlaneProperty();
     prop3->SetColor(0, 0, 1);
     planeWidgetZ->SetLookupTable(planeWidgetX->GetLookupTable());

     bbSetOutputPlaneX(planeWidgetX);
     bbSetOutputPlaneY(planeWidgetY);
     bbSetOutputPlaneZ(planeWidgetZ);
     bbSetOutputImageX(planeWidgetX->GetResliceOutput());
     bbSetOutputImageY(planeWidgetY->GetResliceOutput());
     bbSetOutputImageZ(planeWidgetZ->GetResliceOutput());

     picker->UnRegister(NULL);
     
     myCallbackPlane *_myCallback = myCallbackPlane::New();
     _myCallback->SetCurrentBlackBox(this);
     planeWidgetX->AddObserver(vtkCommand::InteractionEvent,_myCallback);
     planeWidgetY->AddObserver(vtkCommand::InteractionEvent,_myCallback);
     planeWidgetZ->AddObserver(vtkCommand::InteractionEvent,_myCallback);  
   }

//---------------------------------------------------------------------
  void ImagePlanes::bbUserDestructor()
  {

    if (bbGetOutputPlaneX()) bbGetOutputPlaneX()->UnRegister(NULL);
    if (bbGetOutputPlaneY()) bbGetOutputPlaneY()->UnRegister(NULL);
    if (bbGetOutputPlaneZ()) bbGetOutputPlaneZ()->UnRegister(NULL);
  }
  
//---------------------------------------------------------------------  
   void ImagePlanes::Process()
   {
     if (bbGetInputIn()!=0)
       {
	 // Create the widgets if not already done
	 Init();

	 if ( bbGetInputStatus("In") != bbtk::UPTODATE )
	   {
	     // Input image has changed : reinitialize planes
	     image = bbGetInputIn();

	     int xMin, xMax, yMin, yMax, zMin, zMax;
	     bbGetInputIn()->GetExtent(xMin, xMax, yMin, yMax, zMin, zMax);
	     
	     // Initial values : center of the volume (in real world, not in pixels!)
	     double xSpacing, ySpacing, zSpacing;
	     bbGetInputIn()->GetSpacing(xSpacing, ySpacing, zSpacing);
	  

	     bbGetOutputPlaneX()->SetInput(bbGetInputIn());
	     bbGetOutputPlaneX()->SetPlaneOrientationToXAxes();	 
	     bbGetOutputPlaneX()->SetSlicePosition((xMax+xMin)/2.*xSpacing);
	     
	     bbGetOutputPlaneY()->SetInput(bbGetInputIn());
	     bbGetOutputPlaneY()->SetPlaneOrientationToYAxes();
	     bbGetOutputPlaneY()->SetSlicePosition((yMax+yMin)/2.*ySpacing);
	     
	     bbGetOutputPlaneZ()->SetInput(bbGetInputIn());
	     bbGetOutputPlaneZ()->SetPlaneOrientationToZAxes();
	     bbGetOutputPlaneZ()->SetSlicePosition((zMax+zMin)/2.*zSpacing);
	     
	     if (bbGetInputWindowLevel()[0]!=0)
	       {
		 bbGetOutputPlaneZ()->SetWindowLevel(bbGetInputWindowLevel()[0],
						     bbGetInputWindowLevel()[1]);
	       }
	     else 
	       {
		 double *range = image->GetScalarRange();
		 bbGetOutputPlaneZ()->SetWindowLevel(range[1] - range[0],
						     0.5*(range[1]+range[0]));
	       }
	   }
	 
	 
	 // UPDATE DES SORTIES 
	 bbGetOutputPlaneX()->GetResliceOutput()->Update();
	 bbGetOutputPlaneY()->GetResliceOutput()->Update(); 
	 bbGetOutputPlaneZ()->GetResliceOutput()->Update(); 
	 
		 
       }
   }
}//namespace bbtk

#endif // _USE_VTK_