/*
# ---------------------------------------------------------------------
#
# Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
#                        pour la Sante)
# Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
# Previous Authors : Laurent Guigues, Jean-Pierre Roux
# CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
#
#  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.
# ------------------------------------------------------------------------
*/

#include "creaVtkPlaneWidget.h"

#include "vtkRenderWindow.h"



void creaVtkCallbackPlaneWidget::Execute(vtkObject *caller, unsigned long, void*)
{
	if (creavtkplanewidget!=NULL)
	{
		creavtkplanewidget->UpdatePlane();
		creavtkplanewidget->Execute();
	}		
}


//------------------------------------------------------------------------
//------------------------------------------------------------------------
//------------------------------------------------------------------------
//------------------------------------------------------------------------
//------------------------------------------------------------------------
creaVtkPlaneWidget::creaVtkPlaneWidget()
{
	_firsttime	= true;
 	_vPlaneWidget 	= vtkPlaneWidget::New();
	_vPlaneSource 	= vtkPlaneSource::New();
}

//------------------------------------------------------------------------
creaVtkPlaneWidget::~creaVtkPlaneWidget()
{
	_vPlaneWidget->Delete();
}

//------------------------------------------------------------------------
void creaVtkPlaneWidget::SetImage(vtkImageData* image)
{
	_image = image;
}

//------------------------------------------------------------------------
vtkImageData* creaVtkPlaneWidget::GetImage()
{
	return _image;
}

//------------------------------------------------------------------------
void creaVtkPlaneWidget::SetActive(bool active)
{
	_active = active;
}

//------------------------------------------------------------------------
bool creaVtkPlaneWidget::GetActive()
{
	return _active;
}

//------------------------------------------------------------------------
void creaVtkPlaneWidget::SetRenderer(vtkRenderer* renderer)
{
	_renderer = renderer;
}

//------------------------------------------------------------------------
vtkRenderer* creaVtkPlaneWidget::GetRenderer()
{
	return _renderer;
}

//------------------------------------------------------------------------
vtkPlaneSource* creaVtkPlaneWidget::GetPlaneSource()
{
	return _vPlaneSource;
}

//------------------------------------------------------------------------
void creaVtkPlaneWidget::SetResolution(int resolution)
{
	_resolution = resolution;
}

//------------------------------------------------------------------------
int creaVtkPlaneWidget::GetResolution()
{
	return _resolution;
}



//------------------------------------------------------------------------
std::vector<double> creaVtkPlaneWidget::GetCenter()
{
	std::vector<double> vecCenter;
	double point[3];
	_vPlaneWidget->GetCenter(point);
	vecCenter.push_back(point[0]);
	vecCenter.push_back(point[1]);
	vecCenter.push_back(point[2]);
	return vecCenter;
}

//------------------------------------------------------------------------
std::vector<double> creaVtkPlaneWidget::GetNormal()
{
	std::vector<double> vecNormal;
	double point[3];
	_vPlaneWidget->GetNormal(point);
	vecNormal.push_back(point[0]);
	vecNormal.push_back(point[1]);
	vecNormal.push_back(point[2]);
	return vecNormal;
}


//------------------------------------------------------------------------
void creaVtkPlaneWidget::Process()
{    
    if ((GetActive()==true) && (GetRenderer()!=NULL))
    { 
	_vPlaneWidget->SetInput( GetImage() );
	_vPlaneWidget->SetInteractor( GetRenderer()->GetRenderWindow()->GetInteractor() );
	_vPlaneWidget->NormalToXAxisOn();
	_vPlaneWidget->NormalToZAxisOn();
	_vPlaneWidget->SetResolution(10);
	_vPlaneWidget->SetRepresentationToOutline();
	_vPlaneWidget->SetPlaceFactor(1); //defini zoom initial
	_vPlaneWidget->On();
	if (_firsttime==true )	
	{ 
		_firsttime = false;
		_vPlaneWidget->PlaceWidget();
		creaVtkCallbackPlaneWidget *creavtkcallbackplanewidget = creaVtkCallbackPlaneWidget::New();
		creavtkcallbackplanewidget->creavtkplanewidget   = this ;
		_vPlaneWidget->AddObserver( vtkCommand::InteractionEvent , creavtkcallbackplanewidget );
		_vPlaneWidget->AddObserver( vtkCommand::StartInteractionEvent , creavtkcallbackplanewidget );
		_vPlaneWidget->AddObserver( vtkCommand::EnableEvent , creavtkcallbackplanewidget );
	}
	UpdatePlane();
    } else {
	_vPlaneWidget->Off();
    }
}




//------------------------------------------------------------------------
void creaVtkPlaneWidget::UpdatePlane()
{
        double p0[3];
        double p1[3];
        double p2[3];
        double n[3];
        double c[3];
	_vPlaneWidget->GetOrigin(p0);
	_vPlaneWidget->GetCenter(c); //These is from Execute Method
	_vPlaneWidget->GetNormal(n);
	_vPlaneWidget->GetPoint1(p1);
	_vPlaneWidget->GetPoint2(p2);
	
	_vPlaneSource->SetResolution( GetResolution(),  GetResolution() );
	_vPlaneSource->SetOrigin( p0 );
	_vPlaneSource->SetPoint1( p1 );
	_vPlaneSource->SetPoint2( p2 );
	_vPlaneSource->Update( );
	_vPlaneSource->SetNormal( n[ 0 ], n[ 1 ], n[ 2 ] );
	_vPlaneSource->Update( );
	_vPlaneSource->SetCenter( c );
	_vPlaneSource->Update( );
}	

//------------------------------------------------------------------------
void creaVtkPlaneWidget::Execute()  // virutal
{
	printf("EED creaVtkPlaneWidget::Execute (virtual )\n");
}