/*=========================================================================                                                                               
  Program:   bbtk
  Module:    $RCSfile: bbvtkImagePlanes.cxx,v $
  Language:  C++
  Date:      $Date: 2009/05/28 08:12:16 $
  Version:   $Revision: 1.25 $
=========================================================================*/

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

* 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"

#include "vtkObjectFactory.h"


namespace bbstd
{

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

}
using namespace bbstd;
/*
namespace bbtk
{
	typedef vtkImageData::Pointer vtkImageDataPointer;
  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(vtkImageDataPointer,
				       "vtkImageDataPointer");
}
*/
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_DEFINE_RELAY_BLACK_BOX(vtkImageDataPointer,vtk,vtkImageDataPointerRelay);
  BBTK_BLACK_BOX_IMPLEMENTATION(vtkImageDataPointerRelay,bbtk::AtomicBlackBox);

  BBTK_ADD_BLACK_BOX_TO_PACKAGE(vtk,vtkImageDataPointerRelay);
 // BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(vtk,Relay,vtkImageDataPointer);
  //Pointer);

}

namespace bbvtk
{

  //================================================================
 class ImagePlanes::VtkCallbackType : public vtkCommand
 {
 public:
   static VtkCallbackType *New()
   {
     return new VtkCallbackType;
   }
   //vtkTypeRevisionMacro(VtkCallbackType,vtkCommand);

   virtual void Execute(vtkObject *caller, unsigned long, void*)
   {
       mBlackBox->Process();
       mBlackBox->bbSignalOutputModification();
   } 
   void SetBlackBox(ImagePlanes *BB) { mBlackBox = BB;};    
   //   void SetVtkPlaneWidget( vtkImagePlaneWidget *planeWidget );
   VtkCallbackType() {};

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

  //vtkCxxRevisionMacro(ImagePlanes::VtkCallbackType, "$Revision: 1.25 $");

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

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

	
	
   void ImagePlanes::bbUserSetDefaultValues() 
   { 
     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);  
     mVtkCallback = 0;
   }
   

	
   void ImagePlanes::bbUserInitializeProcessing() 
   {  

     /// 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);
     
     mVtkCallback = VtkCallbackType::New();
     mVtkCallback->SetBlackBox(this);
     planeWidgetX->AddObserver(vtkCommand::InteractionEvent,mVtkCallback);
     planeWidgetY->AddObserver(vtkCommand::InteractionEvent,mVtkCallback);
     planeWidgetZ->AddObserver(vtkCommand::InteractionEvent,mVtkCallback);  
   }

//---------------------------------------------------------------------
  void ImagePlanes::bbUserFinalizeProcessing()
  {
	    
    if (bbGetOutputPlaneX()) 
      {

	/*

	  bbGetOutputPlaneX()->RemoveObserver(mVtkCallback);
	  bbGetOutputPlaneY()->RemoveObserver(mVtkCallback);
	  bbGetOutputPlaneZ()->RemoveObserver(mVtkCallback);
	
	
	bbGetOutputPlaneX()->Delete();
	bbGetOutputPlaneY()->Delete();
	bbGetOutputPlaneZ()->Delete();
	mVtkCallback->Delete();
	*/
	//bbGetOutputPlaneX()->SetInput(NULL);
	//bbGetOutputPlaneY()->SetInput(NULL);
	//bbGetOutputPlaneZ()->SetInput(NULL);
	
      }
    
  }
  
//---------------------------------------------------------------------  
   void ImagePlanes::Process()
   {
     if (bbGetInputIn()!=0)
       {

	 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(); 		 
       }
   }
	
	
	//-----------------------------------------------------------------	
	void vtkImageDataPointerRelay::bbUserSetDefaultValues()
	{
	}
	
	//-----------------------------------------------------------------	
	void vtkImageDataPointerRelay::bbUserInitializeProcessing()
	{
	}
	
	//-----------------------------------------------------------------	
	void vtkImageDataPointerRelay::bbUserFinalizeProcessing()
	{
	}
	
	
	
}//namespace bbtk

#endif // _USE_VTK_