/*# ---------------------------------------------------------------------
#
# Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
#                        pour la Sant�)
# 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 "bbmaracasvisuShowNPoints.h"
#include "bbcreaMaracasVisuPackage.h"

#include "vtkProperty.h"
#include "vtkSphereSource.h"
#include "vtkPolyDataMapper.h"
#include "vtkRenderWindow.h"
#include "vtkTextActor3D.h"
#include <vtkTextProperty.h>

namespace bbcreaMaracasVisu
{

//----------------------------------------------------------------------
ModelShowNPoints::ModelShowNPoints()
{
}
//----------------------------------------------------------------------

ModelShowNPoints::~ModelShowNPoints()
{
}

//------------------------------------------------------------------------
void ModelShowNPoints::SetRadio(double radio)
{
	mradio =  radio;
}


//------------------------------------------------------------------------
double ModelShowNPoints::GetRadio()
{
	return mradio;
}


//------------------------------------------------------------------------
std::vector<int> ModelShowNPoints::GetLstPointsX()
{
	return lstPointsX;
}

//------------------------------------------------------------------------
std::vector<int> ModelShowNPoints::GetLstPointsY()
{
	return lstPointsY;
}

//------------------------------------------------------------------------
std::vector<int> ModelShowNPoints::GetLstPointsZ()
{
	return lstPointsZ;
}

//------------------------------------------------------------------------
std::vector<std::string> ModelShowNPoints::GetLstLabels()
{
	return lstLabels;
}

//------------------------------------------------------------------------
void ModelShowNPoints::SetReferencePoint(std::vector<int> ppoint)
{
	mReferencePoint = ppoint;
}

//------------------------------------------------------------------------
std::vector<int> ModelShowNPoints::GetReferencePoint()
{
	return mReferencePoint;
}

//------------------------------------------------------------------------
void ModelShowNPoints::SetImage(vtkImageData *image)
{
	this->mimage=image;
}


//------------------------------------------------------------------------
std::string ModelShowNPoints::CleanSpaces(std::string ss)
{
	int i;
	while( (i=ss.find(32))>=0 )
	{
		ss.replace(i,1,"_");
	}
	return ss;
}

//------------------------------------------------------------------------
void ModelShowNPoints::GetIdPoint(int id, int *x, int *y, int *z)
{
	*x=lstPointsX[id];
	*y=lstPointsY[id];
	*z=lstPointsZ[id];
}

//------------------------------------------------------------------------
std::string ModelShowNPoints::GetIdLabel(int id)
{
	return lstLabels[id];
}

//------------------------------------------------------------------------
vtkImageData *ModelShowNPoints::GetImage()
{
	return mimage;
}

//------------------------------------------------------------------------
void ModelShowNPoints::AddPoint(int x, int y, int z, std::string label)
{
	lstPointsX.push_back( x );
	lstPointsY.push_back( y );
	lstPointsZ.push_back( z );
	std::string strLabel = CleanSpaces(  label );
	lstLabels.push_back( strLabel );
}

//------------------------------------------------------------------------
double ModelShowNPoints::Distance(double dX0, double dY0, double dZ0, double dX1, double dY1, double dZ1)//CFT
{
    return sqrt((dX1 - dX0)*(dX1 - dX0) + (dY1 - dY0)*(dY1 - dY0) + (dZ1 - dZ0)*(dZ1 - dZ0));
}

//------------------------------------------------------------------------
int ModelShowNPoints::InsertPoint(int x, int y, int z, std::string label)
{
	if(lstPointsX.size()>1)
	{
		std::vector<int> dTotal;
		int pos = 1;
		int a,b,res;
		
		//Calcule distance for each pair of points
		for(int i = 0; i<(int)lstPointsX.size()-1 ; i++)
		{
				a = Distance(x, y, z, lstPointsX[i], lstPointsY[i], lstPointsZ[i]);
				b = Distance(x, y, z, lstPointsX[i+1], lstPointsY[i+1], lstPointsZ[i+1]);
				res = a + b;		
				dTotal.push_back (res);		
		}
		//Gets the smallest distance 
		int smallTMP = dTotal[0];
	 	for (int j = 0; j < (int) dTotal.size(); j++)
		{
			  if(dTotal[j]<smallTMP)
			  {
					  smallTMP=dTotal[j];
						pos = j+1;
			  }
		}
		
		std::vector<int>::iterator it;
		//Insert the point in the list of points
		it = lstPointsX.begin();
		lstPointsX.insert( it+pos, x );
		it = lstPointsY.begin();
		lstPointsY.insert( it+pos, y );
		it = lstPointsZ.begin();
		lstPointsZ.insert( it+pos, z );

		std::string strLabel = CleanSpaces(  label );
	
		std::vector<std::string>::iterator itS;
		itS = lstLabels.begin();
		//Insert Label in list of labels
		lstLabels.insert( itS+pos, strLabel );
		return pos;
	} else {
		return -1;
	}// if size lst X

}


//------------------------------------------------------------------------
void ModelShowNPoints::SavePoints(std::string filename)
{
	std::string tmpLabel;
	FILE *ff;
	ff = fopen( filename.c_str() , "w+" );
	if (ff!=NULL)
	{
		int i , size = (int) (lstPointsX.size());
		fprintf(ff,"NumberOfPoints %d \n",size);
		fprintf(ff," X\tY\tZ\tvalue\tLabel\n");
		int x, y, z;
		double value;
		for (i=0; i<size; i++)
		{
			x=lstPointsX[i];
			y=lstPointsY[i];
			z=lstPointsZ[i];
			value= mimage->GetScalarComponentAsDouble(x,y,z,0);
			if (lstLabels[i]!="") 
			{
				tmpLabel=lstLabels[i];
			} else{
				tmpLabel="<_VOID_>";
			}
			fprintf(ff,"%d\t%d\t%d\t%f\t%s\n", x , y , z , value  , tmpLabel.c_str());
		} // for
		fclose(ff);
	} else {   // else ff
		printf("ModelShowNPoints::SavePoints  ...Error... creating file");
	} //ff
}

//------------------------------------------------------------------------
int ModelShowNPoints::ReadPoints(std::string filename)
{
	int i,size;
	char chartmp[256];
	FILE *ff;
	ff = fopen( filename.c_str() , "r+" );
	if (ff!=NULL)
	{
		fscanf(ff," %s %d",chartmp,&size);
		fscanf(ff," %s %s %s %s %s",chartmp, chartmp,chartmp,chartmp,chartmp );

		float value;
		int x,y,z;
		for (i=0; i<size; i++)
		{
			fscanf(ff,"%d%d%d%f%s",&x,&y,&z,&value,chartmp );  // x,y,z,value,label
			if (strcmp(chartmp,"<_VOID_>")==0) { strcpy(chartmp,""); }
			AddPoint(x,y,z, chartmp );
		}
		fclose(ff);
	} else {   // else ff
		printf("ModelShowNPoints::LoadPoints  ...Error... reading file");
	} //ff
	return size;
}

//------------------------------------------------------------------------
int ModelShowNPoints::GetNearestPoint()
{
	int id=-1;
	int i, size=(int)(lstPointsX.size());
	double radioMin=10000000;	
	for ( i=0  ; i<size; i++ )
	{
		double rx =  mReferencePoint[0] - lstPointsX [i];
		double ry =  mReferencePoint[1] - lstPointsY [i];
		double rz =  mReferencePoint[2] - lstPointsZ [i];
		double radio = rx*rx + ry*ry + rz*rz;
		if ( radio <= radioMin)
		{
			radioMin=radio;
			id=i;
		}	// if
	} // for			
	return id;
}

//------------------------------------------------------------------------
int ModelShowNPoints::GetLstPointsSize()
{
	return lstPointsX.size();
}

//------------------------------------------------------------------------
void ModelShowNPoints::SetPointId_mReferencePoint(int id)
{
	lstPointsX[id] = mReferencePoint[0];
	lstPointsY[id] = mReferencePoint[1];
	lstPointsZ[id] = mReferencePoint[2];		
}


//------------------------------------------------------------------------	
int ModelShowNPoints::IdInsidePoint()
{
	int id=-1;
	int i, size=(int)(lstPointsX.size());
	double spc[3];
	if(mimage ==NULL)
	{
		printf("WidgetShowNPoints::IdInsidePoint  image not set\n");
		return -1;
	}else{
		mimage->GetSpacing(spc);
		for ( i=0  ; i<size; i++ )
		{
			double rx =  spc[0]*(mReferencePoint[0] - lstPointsX [i]);
			double ry =  spc[1]*(mReferencePoint[1] - lstPointsY [i]);
			double rz =  spc[2]*(mReferencePoint[2] - lstPointsZ [i]);
			if ( rx*rx + ry*ry + rz*rz <= mradio*mradio)
			{
				id=i;
			}	// if
		} // for
		return id;
	} // if
}

//------------------------------------------------------------------------	
int ModelShowNPoints::RenamePoint(std::string label)
{
	int id=IdInsidePoint();
	if (id>=0)
	{
		std::string strLabel = CleanSpaces( label );
		lstLabels[id] = strLabel;
	}
	return id;
}

//----------------------------------------------------------------------
void ModelShowNPoints::ErasePoint(int id)
{
	lstPointsX.erase( lstPointsX.begin()+id );
	lstPointsY.erase( lstPointsY.begin()+id );
	lstPointsZ.erase( lstPointsZ.begin()+id );
	lstLabels.erase( lstLabels.begin()+id );
}



//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
  WidgetShowNPoints::WidgetShowNPoints(wxWindow *parent,  bbcreaMaracasVisu::ShowNPoints *box)
    : wxPanel( parent, -1, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL)
  {
	mmodelShowNPoints 				= new ModelShowNPoints();
    mbbShowNPoints					= box;
    this->renderer					= NULL;
    wxPanel	*panel					= this;
    wxSizer *sizer					= NULL;

	if (mbbShowNPoints->bbGetInputType()==0)
	{
		// Widget interface
		askPointLabel					= new wxStaticText(panel, -1, _T("Point label :")); // JPR
		textCtrl						= new wxTextCtrl(panel, -1);
		wxButton *btnAddPoint			= new wxButton( panel, -1, _T("Add Point"));
		wxButton *btnInsertPoint		= new wxButton( panel, -1, _T("Insert Point"));//CFT
		wxButton *btnSetPositionPoint	= new wxButton( panel, -1, _T("Set nearest point"));
		wxButton *btnRenamePoint		= new wxButton( panel, -1, _T("Rename point"));
		wxButton *btnEraseLastPoint		= new wxButton( panel, -1, _T("Erase Last point"));
		wxButton *btnErasePoint			= new wxButton( panel, -1, _T("Erase point"));
		wxButton *btnDeleteAllPoints	= new wxButton( panel, -1, _T("Delete all points"));
		wxButton *btnSavePoints			= new wxButton( panel, -1, _T("Save points"));
		wxButton *btnLoadPoints			= new wxButton( panel, -1, _T("Load points"));
		txtNrPoints						= new wxStaticText(panel,-1, _T(" "));

		//NTU: Sliders for opacity and radio change
		wxStaticText* txOpacity = new wxStaticText(this, -1, wxString(_T("  Points Opacity  ")));
		sdrOpacity = new wxSlider(this, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_LABELS);
		wxStaticText* txRadio = new wxStaticText(this, -1, wxString(_T("  Points Radio  ")));
		sdrRadio = new wxSlider(this, -1, 0, 1, 50, wxDefaultPosition, wxDefaultSize, wxSL_LABELS);

		wxFlexGridSizer *sizer1 = new wxFlexGridSizer(1);
		//    sizer1->Add(new wxStaticText(panel,-1,_T("  ")));

		Connect(btnAddPoint->GetId()		, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnAddPoint);
		Connect(btnInsertPoint->GetId()		, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnInsertPoint);//CFT
		Connect(btnSetPositionPoint->GetId(), wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnSetPoint);
		Connect(btnRenamePoint->GetId()		, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnRenamePoint);
		Connect(btnEraseLastPoint->GetId()	, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnEraseLastPoint);
		Connect(btnErasePoint->GetId()		, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnErasePoint);
		Connect(btnDeleteAllPoints->GetId()	, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnDeleteAllPoints);
		Connect(btnSavePoints->GetId()		, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnSavePoints);
		Connect(btnLoadPoints->GetId()		, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnLoadPoints);

		//NTU: Slider events
		Connect(sdrOpacity->GetId()			, wxEVT_COMMAND_SLIDER_UPDATED	, (wxObjectEventFunction) &WidgetShowNPoints::UpdatePoints);
		Connect(sdrRadio->GetId()			, wxEVT_COMMAND_SLIDER_UPDATED	, (wxObjectEventFunction) &WidgetShowNPoints::UpdatePoints);

		sizer1->Add(askPointLabel); // JPR
		sizer1->Add(textCtrl);
		sizer1->Add(btnAddPoint);
		sizer1->Add(btnInsertPoint);//CFT
		sizer1->Add(btnSetPositionPoint);
		sizer1->Add(btnRenamePoint);
		sizer1->Add(btnErasePoint);
		sizer1->Add(btnEraseLastPoint);
		sizer1->Add(btnDeleteAllPoints);
		sizer1->Add(txtNrPoints);
		sizer1->Add(txOpacity);
		sizer1->Add(sdrOpacity,1,wxGROW );
		sizer1->Add(txRadio);
		sizer1->Add(sdrRadio,1,wxGROW );
		sizer1->Add(btnSavePoints);
		sizer1->Add(btnLoadPoints);
		sizer = sizer1;
	}

	  if (mbbShowNPoints->bbGetInputType()==1)
	  {
		  // Widget interface
		  wxButton *btnSetPositionPoint		= new wxButton( panel, -1, _T("Set nearest point"));
		  txtNrPoints						= new wxStaticText(panel,-1, _T(" "));

		  //NTU: Sliders for opacity and radio change
		  wxStaticText* txOpacity			= new wxStaticText(this, -1, wxString(_T("  Points Opacity  ")));
		  sdrOpacity						= new wxSlider(this, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_LABELS);
		  wxStaticText* txRadio				= new wxStaticText(this, -1, wxString(_T("  Points Radio  ")));
		  sdrRadio							= new wxSlider(this, -1, 0, 1, 50, wxDefaultPosition, wxDefaultSize, wxSL_LABELS);
		  wxFlexGridSizer *sizer1			= new wxFlexGridSizer(1);
		  Connect(btnSetPositionPoint->GetId()	, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnSetPoint);
		  Connect(sdrOpacity->GetId()   , wxEVT_COMMAND_SLIDER_UPDATED	, (wxObjectEventFunction) &WidgetShowNPoints::UpdatePoints);
		  Connect(sdrRadio->GetId()     , wxEVT_COMMAND_SLIDER_UPDATED	, (wxObjectEventFunction) &WidgetShowNPoints::UpdatePoints);

		  sizer1->Add(btnSetPositionPoint);
		  sizer1->Add(txtNrPoints);
		  sizer1->Add(txOpacity);
		  sizer1->Add(sdrOpacity,1,wxGROW );
		  sizer1->Add(txRadio);
		  sizer1->Add(sdrRadio,1,wxGROW );
		  sizer = sizer1;
	  }
    
    if (mbbShowNPoints->bbGetInputType() == 2) 
	{
		askPointLabel 						= new wxStaticText(panel, -1, _T("\nPOINT CONTROLS:")); // JPR
      	wxButton 		*btnAddPoint 		= new wxButton(panel, -1,        _T("      Add  Point      "));
        wxButton 		*btnDeleteAllPoints = new wxButton(panel, -1, _T("      Delete All      "));
        wxStaticText	*spacer 			= new wxStaticText(panel, -1, _T("\n")); // JPR
        				 textCtrl 			= new wxTextCtrl(panel, -1);
        wxFlexGridSizer *sizer1 			= new wxFlexGridSizer(1);
        Connect(btnAddPoint->GetId(), wxEVT_COMMAND_BUTTON_CLICKED, (wxObjectEventFunction) & WidgetShowNPoints::OnAddPoint);
        Connect(btnDeleteAllPoints->GetId(), wxEVT_COMMAND_BUTTON_CLICKED, (wxObjectEventFunction) & WidgetShowNPoints::OnDeleteAllPoints);    
        sizer1->Add(askPointLabel); 
        sizer1->Add(btnAddPoint);
        sizer1->Add(btnDeleteAllPoints);
        sizer1->Add(spacer);
        sizer1->Add(textCtrl);
        sdrOpacity = new wxSlider();
        sdrRadio = new wxSlider();
        txtNrPoints = new wxStaticText(panel, -1, _T("\n\n\n"));
        sizer = sizer1;
	} // bbGetInputType 2

	if (sizer!=NULL)
	{
		panel->SetSizer(sizer);
		panel->SetAutoLayout(true);
		panel->Layout();
	} // if sizer
}

//------------------------------------------------------------------------
WidgetShowNPoints::~WidgetShowNPoints()
{
}

//------------------------------------------------------------------------
ModelShowNPoints* WidgetShowNPoints::GetModelShowNPoints()
{
	return mmodelShowNPoints;
}


//------------------------------------------------------------------------
void WidgetShowNPoints::SetRadio(double radio)
{
	GetModelShowNPoints()->SetRadio(radio);
	//NTU: For Slider
	sdrRadio->SetValue(radio);
}

//------------------------------------------------------------------------
void WidgetShowNPoints::SetColour(std::vector<double> colour)
{
	this->mcolour = colour;
}

//------------------------------------------------------------------------
void WidgetShowNPoints::SetImage(vtkImageData* image)
{
	GetModelShowNPoints()->SetImage(image);
}

//------------------------------------------------------------------------
void WidgetShowNPoints::SetOpacity(double opacity)
{
	this->mopacity=opacity;
	//NTU: For Slider
	sdrOpacity->SetValue(this->mopacity*100.0);
}


//------------------------------------------------------------------------
void  WidgetShowNPoints::SetRenderer(vtkRenderer *renderer)
{
	this->renderer	= renderer;
}
	
//------------------------------------------------------------------------
	
void WidgetShowNPoints::RefreshPoint(int id)
{
	double spc[3];

//EED 2016/06/17
//	mimage->GetSpacing(spc);
//	int x = lstPointsX[id];
//	int y = lstPointsY[id];
//	int z = lstPointsZ[id];
	int x,y,z;
	GetModelShowNPoints()->GetIdPoint(id,&x,&y,&z);
	GetModelShowNPoints()->GetImage()->GetSpacing(spc);
	std::string label 	= GetModelShowNPoints()->GetIdLabel(id);
	double radio 		= GetModelShowNPoints()->GetRadio();

	lstActorsSphere[id]->SetPosition( spc[0]*x , spc[1]*y , spc[2]*z );
	lstActorsSphere[id]->GetProperty()->SetColor( mcolour[0] , mcolour[1] , mcolour[2] );
	lstActorsSphere[id]->GetProperty()->SetOpacity( mopacity );
	lstSourceSphere[id]->SetRadius( radio );

	lstActorsText[id]->SetInput( label.c_str()  );
	lstActorsText[id]->SetPosition(  radio+spc[0]*x , spc[1]*y , spc[2]*z );
}

//------------------------------------------------------------------------
void WidgetShowNPoints::RefreshPoints()
{
	int id,size=lstActorsSphere.size();
	for (id=0;id<size;id++)
	{
		RefreshPoint(id);
	} // for
	renderer->GetRenderWindow()->Render();
}

//------------------------------------------------------------------------
void WidgetShowNPoints::AddVtkPoint()
{
	// Sphere
	vtkSphereSource *vtksphere = vtkSphereSource::New();
	vtksphere->SetThetaResolution (20);
	vtksphere->SetPhiResolution (20);
	vtksphere->SetRadius( 1 );
	//NTU: For updating points
	lstSourceSphere.push_back(vtksphere);
	vtkPolyDataMapper *sphereMapper	= vtkPolyDataMapper::New();
	sphereMapper->SetInput( vtksphere->GetOutput() );
	vtkActor *sphereActor	= vtkActor::New();
	sphereActor->SetMapper(sphereMapper);
	sphereActor->SetOrigin(0, 0, 0);

	lstActorsSphere.push_back(sphereActor);
	if(renderer==NULL){
		wxMessageDialog dialog(this, _T("Renderer Not Set"),_T("Renderer Not Set"),wxICON_ERROR);
		dialog.ShowModal();		
		return;
	}
	renderer->AddActor( sphereActor );
	// Actor
	vtkTextActor3D *textActor = vtkTextActor3D::New();
//	textActor->SetInput( strLabel.c_str()  );
	renderer->AddActor( textActor );
	lstActorsText.push_back(textActor);
}


//------------------------------------------------------------------------
void WidgetShowNPoints::AddPoint(int x, int y, int z, std::string label)
{
	GetModelShowNPoints()->AddPoint(x,y,z, label );
	AddVtkPoint();
	RefreshPoint(lstActorsSphere.size()-1);
}



//------------------------------------------------------------------------
void WidgetShowNPoints::InsertPoint(int x, int y, int z, std::string label)//CFT
{


//--
	if ( GetModelShowNPoints()->InsertPoint(x,y,z,label) != -1 )
	{
/*
		// Sphere
		vtkSphereSource *vtksphere		= vtkSphereSource::New();
		vtksphere->SetThetaResolution (20);
		vtksphere->SetPhiResolution (20);
		vtksphere->SetRadius( mradio  );

		//NTU: For updating points
		std::vector<vtkSphereSource*>::iterator itSS;
		itSS = lstSourceSphere.begin();
		lstSourceSphere.insert( itSS+pos, vtksphere);

		vtkPolyDataMapper *sphereMapper	= vtkPolyDataMapper::New();
		sphereMapper->SetInput( vtksphere->GetOutput() );
		vtkActor *sphereActor	= vtkActor::New();
		sphereActor->SetMapper(sphereMapper);
		sphereActor->SetOrigin(0, 0, 0);

		std::vector<vtkActor*>::iterator itAS;
		itAS = lstActorsSphere.begin();
		lstActorsSphere.insert( itAS+pos, sphereActor);
		if(renderer==NULL){
			wxMessageDialog dialog(this, _T("Renderer Not Set"),_T("Renderer Not Set"),wxICON_ERROR);
			dialog.ShowModal();		
			return;
		}
		renderer->AddActor( sphereActor );

		// Actor
		vtkTextActor3D *textActor = vtkTextActor3D::New();

		textActor->SetInput( strLabel.c_str()  );
		renderer->AddActor( textActor );
		std::vector<vtkTextActor3D*>::iterator itTA;
		itTA = lstActorsText.begin();
		lstActorsText.insert( itTA+pos , textActor);
*/

		AddVtkPoint();
	} else {
		AddPoint(x,y,z,label);
	}
	RefreshPoints();
	//end if
}


//------------------------------------------------------------------------
void WidgetShowNPoints::OnAddPoint (wxCommandEvent& event)
{	
	if (this->renderer==NULL)
	{ 
		return;
	}

	std::vector<int> point = GetModelShowNPoints()->GetReferencePoint();
	if (point.size()==3)
	{
		AddPoint(point[0],point[1],point[2], (const char*) ( textCtrl->GetValue().mb_str() ) );
		SetOutputBox();
		renderer->GetRenderWindow()->Render();
	} else {//mpoint.size
		printf("creaMaracasVisu::ShowNPoints (not match point) \n");
	}
}

//------------------------------------------------------------------------
void WidgetShowNPoints::OnInsertPoint (wxCommandEvent& event)//CFT
{	
	if (this->renderer==NULL)
	{ 
		return;
	}

	std::vector<int> point = GetModelShowNPoints()->GetReferencePoint();
	if (point.size()==3)
	{
		InsertPoint(point[0],point[1],point[2], (const char*) ( textCtrl->GetValue().mb_str() ) );
		SetOutputBox();
	} else {//mpoint.size
		printf("creaMaracasVisu::ShowNPoints (not match point) \n");
	}
}


//------------------------------------------------------------------------
	void WidgetShowNPoints::SetOutputBox()
	{
//EED		renderer->GetRenderWindow()->Render();
		wxString strTmp;
		strTmp.Printf(_T("Nbr of points: %d"), GetModelShowNPoints()->GetLstPointsSize() );
		txtNrPoints->SetLabel(  strTmp );
		//--BBTK
		mbbShowNPoints->bbSetOutputlstPointsX( GetModelShowNPoints()->GetLstPointsX() );
		mbbShowNPoints->bbSetOutputlstPointsY( GetModelShowNPoints()->GetLstPointsY() );
		mbbShowNPoints->bbSetOutputlstPointsZ( GetModelShowNPoints()->GetLstPointsZ() );
		mbbShowNPoints->bbSetOutputlstLabels( GetModelShowNPoints()->GetLstLabels() );
		mbbShowNPoints->bbSignalOutputModification();
	}


//------------------------------------------------------------------------
	void WidgetShowNPoints::OnSavePoints(wxCommandEvent& event)
	{
		wxFileDialog* FD = new wxFileDialog( 0,
                                            _T("Save points .."),
                                            _T(""),
                                            _T(""),
                                            _T("(*.xls)|*.xls"),
                                            wxSAVE | wxOVERWRITE_PROMPT,
                                            wxDefaultPosition);
		//EED

		int result_FD = FD->ShowModal();
		
		// This line is need it by windows //EED
		FD->SetReturnCode( result_FD );

		if (FD->GetReturnCode()==wxID_OK)
		{
			std::string filename= (const char*) ( FD->GetPath().mb_str() );	
			GetModelShowNPoints()->SavePoints( filename );
		} 	// dialog box
	}


//------------------------------------------------------------------------
	void WidgetShowNPoints::OnLoadPoints(wxCommandEvent& event)
	{
		wxFileDialog* FD = new wxFileDialog( 0,
                                             _T("Load points .."),
                                             _T(""),
                                             _T(""),
                                             _T("(*.xls)|*.xls"),
                                             wxOPEN | wxFILE_MUST_EXIST,
                                             wxDefaultPosition);
		int i;
		//EED
		int result_FD = FD->ShowModal();
		// This line is need it by windows //EED
		FD->SetReturnCode( result_FD );
		if (FD->GetReturnCode()==wxID_OK)
		{

			std::string filename= (const char*) ( FD->GetPath().mb_str() );	
			int numberPointsRead = GetModelShowNPoints()->ReadPoints( filename );
			for (i=0;i<numberPointsRead;i++)
			{
				AddVtkPoint();
			}// for
			SetOutputBox();
			RefreshPoints();
		} 	// dialog box

	}

	//------------------------------------------------------------------------
	void WidgetShowNPoints::OnSetPoint(wxCommandEvent& event)
	{
		int id=GetModelShowNPoints()->GetNearestPoint();
		if((id==-1) && (mbbShowNPoints->bbGetInputType()==1))
		{
			id=0;
			AddPoint(0,0,0,"");
			SetOutputBox();
		}
	
		if (id>=0)
		{
			GetModelShowNPoints()->SetPointId_mReferencePoint(id);
			RefreshPoint(id);
			renderer->GetRenderWindow()->Render();
		} // if id
		SetOutputBox();
	}
	
//------------------------------------------------------------------------
	void WidgetShowNPoints::OnRenamePoint(wxCommandEvent& event)
	{
		int id = GetModelShowNPoints()->RenamePoint( (const char*) ( textCtrl->GetValue().mb_str() ) );
		if (id>=0)
		{
			lstActorsText[id]->SetInput(  (const char*) ( textCtrl->GetValue().mb_str() ) );
			SetOutputBox();
			renderer->GetRenderWindow()->Render();
		}
	}

//------------------------------------------------------------------------
	void WidgetShowNPoints::ErasePoint(int id)
	{
		if (this->renderer!=NULL)
		{
			if (id>=0)
			{
				renderer->RemoveActor( lstActorsSphere[id] );
				renderer->RemoveActor( lstActorsText[id] );
				lstActorsSphere[id]->Delete();
				lstActorsText[id]->Delete();
				lstSourceSphere[id]->Delete();
				lstActorsSphere.erase( lstActorsSphere.begin()+id );
				lstActorsText.erase( lstActorsText.begin()+id );
				lstSourceSphere.erase( lstSourceSphere.begin()+id );
				GetModelShowNPoints()->ErasePoint(id);
			} // if id
		} // if renderer
	}

//------------------------------------------------------------------------
	void WidgetShowNPoints::OnErasePoint(wxCommandEvent& event)
	{
		ErasePoint( GetModelShowNPoints()->IdInsidePoint() );
		SetOutputBox();
		renderer->GetRenderWindow()->Render();
	}

//------------------------------------------------------------------------
	void WidgetShowNPoints::OnEraseLastPoint(wxCommandEvent& event)
	{
		ErasePoint(lstActorsSphere.size()-1);
		SetOutputBox();
		renderer->GetRenderWindow()->Render();
	}

//------------------------------------------------------------------------
void WidgetShowNPoints::OnDeleteAllPoints(wxCommandEvent& event)
{
	int id,size=lstActorsSphere.size();
	for (id=size-1;id>=0;id--)
	{
		ErasePoint(id);
	}
	SetOutputBox();
	renderer->GetRenderWindow()->Render();
}

//NTU: Method for updating points opacity and Radio

//------------------------------------------------------------------------
void WidgetShowNPoints::UpdatePoints(wxCommandEvent &event)
{
	//Difference in Radio for text placement
	double radio=GetModelShowNPoints()->GetRadio();
	this->mopacity = sdrOpacity->GetValue()/100.0;
	GetModelShowNPoints()->SetRadio( sdrRadio->GetValue() ) ;
	radio = sdrRadio->GetValue();
	//NTU refresh the inputs
	mbbShowNPoints->bbSetInputOpacity(this->mopacity);
	mbbShowNPoints->bbSetInputRadio( radio );
	// EED 
	RefreshPoints();
}

//------------------------------------------------------------------------
void  WidgetShowNPoints::SetReferencePoint(std::vector<int> point)
{
	GetModelShowNPoints()->SetReferencePoint(point);
}

//------------------------------------------------------------------------
void  WidgetShowNPoints::SetInitLstPoints( std::vector<int> initLstPointsX,  std::vector<int> initLstPointsY, std::vector<int> initLstPointsZ, std::vector<std::string> initLstLabels )
{
	if (this->renderer==NULL)
	{ 
		return;
	}

	int i,sizeX,sizeY,sizeZ,sizeLabels;
	sizeX=(int)initLstPointsX.size();
	sizeY=(int)initLstPointsY.size();
	sizeZ=(int)initLstPointsZ.size();
	sizeLabels=(int)initLstLabels.size();

	int x,y,z;
	std::string label;

	if ( (sizeX==sizeY) && (sizeX==sizeZ) )
	{

		for (i=0;i<sizeX;i++)
		{
			x		= initLstPointsX[i];
			y		= initLstPointsY[i];
			z		= initLstPointsZ[i];
			if (i<sizeLabels) 
			{
				label	= initLstLabels[i];
			} else {
				label="";
			}
			AddPoint( x,y,z,label );
		} // for i
		//	SetOutputBox();	
		//	renderer->GetRenderWindow()->Render();

	} // if size
}




BBTK_ADD_BLACK_BOX_TO_PACKAGE(creaMaracasVisu,ShowNPoints)
BBTK_BLACK_BOX_IMPLEMENTATION(ShowNPoints,bbtk::WxBlackBox);

//-----------------------------------------------------------------
void ShowNPoints::Process()
{
	if (mwxwidget!=NULL)
	{
		mwxwidget->SetRenderer( bbGetInputRenderer() );
		mwxwidget->SetReferencePoint( bbGetInputIn() );
		mwxwidget->SetImage( bbGetInputImage() );
		mwxwidget->SetColour( bbGetInputColour() );
		mwxwidget->SetOpacity( bbGetInputOpacity() );
		mwxwidget->SetRadio( bbGetInputRadio() );

		if (firsttime==true)
		{
			firsttime=false;
			mwxwidget->SetInitLstPoints( bbGetInputInitLstPointsX() , bbGetInputInitLstPointsY() , bbGetInputInitLstPointsZ() , bbGetInputInitLstLabels() );
		}

		bbSetOutputlstPointsX( mwxwidget->GetModelShowNPoints()->GetLstPointsX() );
		bbSetOutputlstPointsY( mwxwidget->GetModelShowNPoints()->GetLstPointsY() );
		bbSetOutputlstPointsZ( mwxwidget->GetModelShowNPoints()->GetLstPointsZ() );
		bbSetOutputlstLabels( mwxwidget->GetModelShowNPoints()->GetLstLabels() );
	} // mwxwidget
}

//-----------------------------------------------------------------
void ShowNPoints::CreateWidget(wxWindow* parent)
{
	mwxwidget = new WidgetShowNPoints( parent, this);
    bbSetOutputWidget( mwxwidget );
}

//-----------------------------------------------------------------
void ShowNPoints::bbUserSetDefaultValues()
{
	firsttime = true;
	mwxwidget = NULL;

	bbSetInputRadio(10);
	bbSetInputOpacity(1);

	std::vector<double> colour;
	colour.push_back(1.0);
	colour.push_back(0.0);
	colour.push_back(0.0);
	bbSetInputColour(colour);

	bbSetInputImage(NULL);
	bbSetInputType(0);
	bbSetInputRenderer(NULL);
}

//-----------------------------------------------------------------
	void ShowNPoints::bbUserInitializeProcessing()
	{
	}

//-----------------------------------------------------------------
	void ShowNPoints::bbUserFinalizeProcessing()
	{
	}

//-----------------------------------------------------------------

}
// EO namespace bbcreaMaracasVisu