#include "vtkObjectFactory.h"

#include "vtkActor.h"
#include "vtkCylinderSource.h"
#include "vtkPolyDataMapper.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkProperty.h"
#include "vtkCamera.h"
#include "vtkPoints.h"
#include "vtkCellArray.h"
#include "vtkPolyData.h"
#include "vtkPolyDataMapper.h"
#include "vtkPolyDataWriter.h"
#include "vtkPolyDataReader.h"
#include "vtkImageReader.h"
#include "vtkImageViewer.h"
#include "vtkImageViewer2.h"
#include "vtkImageToStructuredPoints.h"
#include <vtkImageThreshold.h> 

#include "vtkExtractVOI.h"
#include "vtkImageClip.h"
#include "vtkImageResample.h"
#include "vtkImageThreshold.h"
#include "vtkImageCast.h"
#include "vtkImageSeedConnectivity.h"
#include "vtkImageData.h"
#include "vtkMarchingCubes.h"
#include "vtkImageReslice.h"
#include "vtkTransform.h"
#include "vtkSphereSource.h"
#include "vtkDoubleArray.h"
#include "vtkPointData.h"
#include "vtkCommand.h"
#include "vtkCallbackCommand.h"
#include "vtkImageResample.h"
#include "vtkMath.h"
#include "vtkStripper.h"

#include "wxEmptyPanelWidget_2.h"

#include <wx/splitter.h>



//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
vtkStandardNewMacro(TreeExtraction_MH_JFC);
//-------------------------------------------------------------------

TreeExtraction_MH_JFC::TreeExtraction_MH_JFC(){
	_branchLevel		= 2;
	_imagedataResult	= NULL;
	_cleanLevel			= 400;
}
//-------------------------------------------------------------------
TreeExtraction_MH_JFC::~TreeExtraction_MH_JFC(){
	Reset();
}
//-------------------------------------------------------------------
void TreeExtraction_MH_JFC::Reset(){
	if (_imagedataResult!=NULL){
		_imagedataResult->Delete();
	}
}
//-------------------------------------------------------------------
void TreeExtraction_MH_JFC::SetInput(marExperiment *input){
	_marExperiment = input;
}

//-------------------------------------------------------------------
void TreeExtraction_MH_JFC::BruleVolume(vtkImageData *imagedata, int x,int y,int z,int r , int value)
{
	int ext[6];
	int i, j, k, ii,jj,kk;	
	imagedata->GetExtent(ext);
	unsigned short *ptr;
	int x1=x-r;
	int x2=x+r;
	int y1=y-r;
	int y2=y+r;
	int z1=z-r;
	int z2=z+r;
	double tmpsqrt;
	for(i=x1;i<=x2;i++){
		for(j=y1;j<=y2;j++){
			for(k=z1;k<=z2;k++){
				ptr=(unsigned short *)	imagedata->GetScalarPointer(i,j,k);
				ii=i-x;
				jj=j-y;
				kk=k-z;
				tmpsqrt=ii*ii + jj*jj + kk*kk;
				if ((ptr!=NULL) && ( sqrt(tmpsqrt)<=r))
				{
					if (value==0){
						*ptr=value;
					} else {
						if (*ptr==0)  {
							*ptr=value;
						}
					}
				} 
			} // for z
		}  // for y
	} // fox x
}

//-------------------------------------------------------------------
void TreeExtraction_MH_JFC::BruleVolume(vtkImageData *imagedata,vtkPolyData *inputAxisRadio, int value)
{
	int x,y,z,r;
	double point[3],radio;
	double fractpart, intpart;
	int i,maxPoints=inputAxisRadio->GetPoints()->GetNumberOfPoints();
	vtkDoubleArray *allRadios = (vtkDoubleArray*)(inputAxisRadio->GetPointData()->GetScalars("radio"));
	for (i=0; i<maxPoints; i++){	
		inputAxisRadio->GetPoints()->GetPoint(i,point);
		radio=allRadios->GetValue(i);
		x = (int)(point[0]);
		y = (int)(point[1]);	
		z = (int)(point[2]);
		fractpart = modf (radio , &intpart);
		if (fractpart>=0.5){
		 intpart++;
		}
		r = (int)( intpart );
		BruleVolume(imagedata,x,y,z,r,value);
	}
}


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

void TreeExtraction_MH_JFC::FindVit( marExperiment *newExperiment , int actualAxis , double *pointBif , double *vit )
{
	double dist,min=-1;
	double point[3];
	double dx,dy,dz;
	int jPoint,maxPoints;
	int iAxis,maxAxis;

	maxAxis=newExperiment->getNumberOfAxes();
	for (iAxis=0;iAxis<maxAxis;iAxis++){
		if (iAxis!=actualAxis){
			newExperiment->setAxis(iAxis);
			marAxis *maraxis = newExperiment->getAxis( );
			if (maraxis!=NULL) {
				vtkPolyData  *axisVtk	= maraxis->GetAxisData();
				maxPoints=axisVtk->GetPoints()->GetNumberOfPoints();
				for (jPoint=0; jPoint<maxPoints; jPoint++){	
					axisVtk->GetPoints()->GetPoint(jPoint,point);
					dx = pointBif[0]-point[0];
					dy = pointBif[1]-point[1];
					dz = pointBif[2]-point[2];
					dist = sqrt( dx*dx + dy*dy + dz*dz );
					if ((min==-1) || (dist<min)) {
						min=dist;
						vit[0] = dx;
						vit[1] = dy;
						vit[2] = dz;
					} //if 
				} // for
			} // if maraxis!=NULL
		} // i!=actualAxis
	} //for
}

//-------------------------------------------------------------------
void TreeExtraction_MH_JFC::Execute(int count, int sens, double *vit, int cleanLevel)
{
 	//------------Arbre Extraction --------------
	// Call Maracas axis extraction
	count--;
/*
time_t start,end;
double dif;
time (&start);
*/
		int idActualAxis_Before = _marExperiment->getNumberOfAxes();
		_marExperiment->extractVascularTree( sens , vit, cleanLevel );
/*
time (&end);
dif = difftime (end,start);
FILE *ff;
ff=fopen("c:/temp/MaracasTIME.txt","a+");
fprintf(ff,"\n TreeExtraction_MH_JFC::Execute %d \n",count);
fprintf(ff,"evt %.2lf \n",dif);
fclose(ff);
*/
		int idActualAxis = _marExperiment->getNumberOfAxes();
		// Bifurcation Detection JFC
		marAxis *maraxis = _marExperiment->getAxis( );
		if ((maraxis!=NULL) && (idActualAxis_Before!=idActualAxis)) {
			vtkImageData *imagedata			= _marExperiment->getDynData( )->getVolume( )->castVtk();
			vtkPolyData  *inputAxisRadio	= maraxis->GetAxisData();

			if (count>0){
/*
time (&start);
*/
				_prgov = carotidaBifurcacion::New();
				_prgov->SetMaxPropRadio(5);
				_prgov->SetHumbral(0.45);
				_prgov->SetMaxPropMasa(10);
				_prgov->SetMinPropMasa(0.01);
				_prgov->SetInput( inputAxisRadio );
				_prgov->SetInput2( imagedata );
				_prgov->Update();
/*
time (&end);
dif = difftime (end,start);
ff=fopen("c:/temp/MaracasTIME.txt","a+");
fprintf(ff,"\tcB  %.2lf \n",dif);
fclose(ff);
*/
			}

			// Brule Volume
			BruleVolume(imagedata		 , inputAxisRadio , 0			 );
			BruleVolume(_imagedataResult , inputAxisRadio , idActualAxis );
			inputAxisRadio->Delete();


			if (count>0){
				// LOOP for branch extraction
				vtkPolyData *bifurcations =  _prgov->GetOutput();
				int i,maxPoints = bifurcations->GetPoints()->GetNumberOfPoints();
				int x,y,z;
				double point[3], vit[3];
				for (i=0; i<maxPoints; i++){
					bifurcations->GetPoints()->GetPoint(i,point);
					x = (int)(point[0]);
					y = (int)(point[1]);
					z = (int)(point[2]);
					FindVit( _marExperiment , idActualAxis , point , vit );
					_marExperiment->setStartPoint( x , y , z );
					//Branch extraction;
					Execute(count, 0 , vit , (int)_cleanLevel );
				}
				bifurcations->Delete();
//				_prgov->Delete();
//				_prgov = NULL;
			} // of count>0

		} // maraxi=NULL
}

//-------------------------------------------------------------------
void TreeExtraction_MH_JFC::InitImagaDataResult(){
	Reset();
	vtkImageData *imagedata = _marExperiment->getDynData( )->getVolume( )->castVtk();
	imagedata->Update();
	_imagedataResult = vtkImageData::New();
	int dim[3];
	imagedata->GetDimensions(dim);
	_imagedataResult->SetScalarType(imagedata->GetScalarType());

	_imagedataResult->SetDimensions(dim[0],dim[1],dim[2]); 
	_imagedataResult->SetExtent( 0 , dim[0]-1 , 0 , dim[1]-1 , 0 , dim[2]-1 ); 
	_imagedataResult->SetWholeExtent(0 , dim[0]-1 , 0 , dim[1]-1 , 0 , dim[2]-1 );
	_imagedataResult->SetSpacing( imagedata->GetSpacing()  ); 
	_imagedataResult->SetOrigin( 0,0,0  ); 
	_imagedataResult->Update();
	_imagedataResult->UpdateData();
	unsigned short *ptr;
	int i,j,k;
	for ( i=0 ; i<dim[0] ; i++ ){
  		for ( j=0 ; j<dim[1] ; j++ ){
			for ( k=0 ; k<dim[2] ; k++ ){
				ptr = (unsigned short *)	_imagedataResult->GetScalarPointer(i,j,k);
				*ptr = 0;
			}
		}
	}
}
//-------------------------------------------------------------------
void TreeExtraction_MH_JFC::Update(){
/*
FILE *ff;
ff=fopen("c:/temp/MaracasTIME.txt","w");
fclose(ff);
*/
	InitImagaDataResult();
	Execute(_branchLevel);
}
//-------------------------------------------------------------------
marExperiment* TreeExtraction_MH_JFC::GetInput(){
	return _marExperiment;
}
//-------------------------------------------------------------------
vtkImageData* TreeExtraction_MH_JFC::GetVolume(){
	return _imagedataResult;
}
//-------------------------------------------------------------------
void TreeExtraction_MH_JFC::SetBranchLevel(int branchLevel){
	_branchLevel = branchLevel;
}
//-------------------------------------------------------------------
void TreeExtraction_MH_JFC::SetCleanTreeLevel( int cleanLevel ){
	_cleanLevel = (double)cleanLevel;
}

//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
wxEmptyPanelWidget_2::wxEmptyPanelWidget_2(wxWindow *parent, marInterface* mar)
: wxPanel( parent, -1) 
{

	_sensibility_JF		= 0.5;

	_mar								= mar;
	wxBoxSizer			*sizer			= new wxBoxSizer(wxVERTICAL  );
    wxSplitterWindow	*pnlSplitter	= new wxSplitterWindow( this , -1);
	wxPanel				*viewPanel		= CreateViewPanel(pnlSplitter);
	wxPanel				*controlPanel	= CreateControlPanel(pnlSplitter);

	sizer		-> Add( pnlSplitter ,1,wxGROW  ,0);
	pnlSplitter	-> SetMinimumPaneSize( 150 );
    pnlSplitter	-> SplitVertically( viewPanel, controlPanel, 600 );
	this		-> SetSizer(sizer);

	// Original Volume
	_mCubes				= NULL;
	_surfMapper			= NULL;
	_surfActor			= NULL;

	// Result 1: Volume + Axis
	_1_prgov			= NULL;
	_1_mapfinal			= NULL;
	_1_stripfinal		= NULL;
	_1_isoMapperMC6		= NULL;
	_1_isoActorMC6		= NULL;
	_1_isoMC6			= NULL;

	// Result 2: Volume + Axis
	_2_prgov			= NULL;
	_2_mapfinal			= NULL;
	_2_stripfinal		= NULL;
	_2_isoMapperMC6		= NULL;
	_2_isoActorMC6		= NULL;
	_2_isoMC6			= NULL;

	//
	_isoMapperMC1		= NULL;
	_isoActorMC1		= NULL;
	_isoMC1				= NULL;
	_imageThresholdMC1	= NULL;

	//
	_treeExtraction		= NULL; 

}
//-------------------------------------------------------------------
wxEmptyPanelWidget_2::~wxEmptyPanelWidget_2(){
	// Erase Original Volule
	if (_mCubes			) { _mCubes			-> Delete(); }
	if (_surfMapper		) {	_surfMapper		-> Delete(); }
	if (_surfActor		) {	_surfActor		-> Delete(); }

	// Erase result: Volume + Axis
	ResetTree1_JF();
	ResetTree2_JF();
	ResetTree_MH_JFC();
}
//-------------------------------------------------------------------
wxPanel* wxEmptyPanelWidget_2::CreateViewPanel(wxWindow *parent)
{
 	wxPanel *panel		=	new wxPanel(parent,-1);
    wxBoxSizer *sizer	=	new wxBoxSizer(wxVERTICAL);
	_maracasSurfaceWidget = new wxSurfaceWidget(panel);
	sizer->Add(_maracasSurfaceWidget	, 1, wxEXPAND, 0);
	panel->SetSizer(sizer);
	panel->SetAutoLayout(true);
	panel->SetSize(400,400);
	panel->Layout();
	return panel;
}
//-------------------------------------------------------------------
wxPanel* wxEmptyPanelWidget_2::CreateControlPanel(wxWindow *parent)
{
	wxPanel *panel		= new wxPanel(parent,-1);
	_opacity_OrigVol	= new wxSlider( panel, -1, 30, 0, 100 , wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
	_isoValue			= new wxSlider( panel, -1, 0 , 0, 3000, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
	_opacity_Res1VolJF	= new wxSlider( panel, -1, 25, 0, 100 , wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
	_opacity_Res2VolJF	= new wxSlider( panel, -1, 25, 0, 100 , wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
	_sl_sensibility_JF	= new wxSlider( panel, -1, 0 , 0, 100 , wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
	_branchLevel		= new wxSlider( panel, -1, 2 , 1, 10  , wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
	_opacity_ResVolMHJF	= new wxSlider( panel, -1, 25, 0, 100 , wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
	_isoValue_MH_JFC	= new wxSlider( panel, -1, 0 , 0, 100 , wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
	_cleanTree_MH_JFC	= new wxSlider( panel, -1, 400 , 0, 1000 , wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );

	int tmp_sensibility= (int)(_sensibility_JF*100.0);
	_sl_sensibility_JF->SetValue( tmp_sensibility );


	_opacity_OrigVol	->SetSize(250,20);   // Original Volume
	_isoValue			->SetSize(250,20);
	_opacity_Res1VolJF	->SetSize(250,20);  // Result 1 Volume JF
	_opacity_Res2VolJF	->SetSize(250,20);  // Result 2 Volume JF
	_branchLevel		->SetSize(250,20);
	_opacity_ResVolMHJF	->SetSize(250,20);  // Result Volume MH+JFC

	//Extract Tree 1 JF
	wxButton *btnExtractTree1_JF	= new wxButton(panel,-1,_T("Extract Tree 1 JF"));
	wxButton *btnEraseTree1_JF		= new wxButton(panel,-1,_T("Erase Tree 1 JF"));

	//Extract Tree 2 JF
	wxButton *btnExtractTree2_JF	= new wxButton(panel,-1,_T("Extract Tree 2 JF"));
	wxButton *btnEraseTree2_JF		= new wxButton(panel,-1,_T("Erase Tree 2 JF"));

	//Extract Tree MH + JF
	wxButton *btnExtractTree_MH_JFC = new wxButton(panel,-1,_T("Extract Tree MH + JFC"));
	wxButton *btnEraseTree_MH_JFC	= new wxButton(panel,-1,_T("Erase Tree MH + JFC"));


    wxFlexGridSizer *sizer = new wxFlexGridSizer(1);
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("Isovalue - Original Volume")));	
	sizer->Add(_isoValue);
	sizer->Add(new wxStaticText(panel,-1,_T("Opacity - Original Volume")));
	sizer->Add(_opacity_OrigVol);

	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("  - - -  Juan Francisco Module 1 - - - ")));
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(btnExtractTree1_JF);
	sizer->Add(btnEraseTree1_JF);
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("Opacity - Result Volume")));
	sizer->Add(_opacity_Res1VolJF);

	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("  - - -  Juan Francisco Module 2 - - - ")));
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T(" % Sensibility")));
	sizer->Add(_sl_sensibility_JF);
	sizer->Add(btnExtractTree2_JF);
	sizer->Add(btnEraseTree2_JF);
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("Opacity - Result Volume")));
	sizer->Add(_opacity_Res2VolJF);


	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("  - - -  MH + JFC  - - - ")));
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(btnExtractTree_MH_JFC);
	sizer->Add(btnEraseTree_MH_JFC);
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("Branch Level MH+JFC")));
	sizer->Add(_branchLevel);
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("Opacity - Result Volume MH+JFC")));
	sizer->Add(_opacity_ResVolMHJF);
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("IsoValue - Result Volume MH+JFC")));
	sizer->Add(_isoValue_MH_JFC);
	sizer->Add(new wxStaticText(panel,-1,_T("  ")));
	sizer->Add(new wxStaticText(panel,-1,_T("signal level (Clean Tree)")));
	sizer->Add(_cleanTree_MH_JFC);

	panel->SetSizer(sizer);
	panel->SetAutoLayout(true);
	panel->SetSize(400,400);
	panel->Layout();
	Connect(_opacity_OrigVol->GetId()		, wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnOpacity_OrigVol		); 
	Connect(_isoValue->GetId()				, wxEVT_SCROLL_THUMBRELEASE		, (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnIsoValue				); 
	Connect(_opacity_Res1VolJF->GetId()		, wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnOpacity_Res1VolJF	); 
	Connect(_opacity_Res2VolJF->GetId()		, wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnOpacity_Res2VolJF	); 
	Connect(_sl_sensibility_JF->GetId()		, wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnSensibility			); 

	Connect(btnExtractTree1_JF->GetId()		, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnBtnExtractTree1_JF	); 
	Connect(btnEraseTree1_JF->GetId()		, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnBtnEraseTree1_JF 	); 
	Connect(btnExtractTree2_JF->GetId()		, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnBtnExtractTree2_JF	); 
	Connect(btnEraseTree2_JF->GetId()		, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnBtnEraseTree2_JF 	); 

	Connect(btnExtractTree_MH_JFC->GetId()	, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnBtnExtractTree_MH_JFC);	
	Connect(btnEraseTree_MH_JFC->GetId()	, wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnBtnEraseTree_MH_JFC 	);	
	Connect(_branchLevel->GetId()			, wxEVT_SCROLL_THUMBRELEASE		, (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnBranchLevel			); 
	Connect(_opacity_ResVolMHJF->GetId()	, wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnOpacity_ResVolMHJF	); 
	Connect(_isoValue_MH_JFC->GetId()		, wxEVT_COMMAND_SLIDER_UPDATED	, (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnIsoValue_MH_JFC		); 
	Connect(_cleanTree_MH_JFC->GetId()		, wxEVT_COMMAND_SLIDER_UPDATED	, (wxObjectEventFunction) &wxEmptyPanelWidget_2::OnCleanTree_MH_JFC		); 

	return panel;
}
//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::Refresh()
{
	_maracasSurfaceWidget->GetVtk3DSurfaceWidget()->Render();
}
//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::ConfigureVTK()
{
    wxBusyCursor wait;
//	_imageviewer3D->Configure();
	vtkImageData	*imagedata		= _mar->_experiment->getDynData( )->getVolume( )->castVtk();
	double			opacity_OrigVol	= ((double)(_opacity_OrigVol->GetValue()))/100;
	double			isoValue; 

	// Visualisation - original volume
    double range[2];
    imagedata->GetScalarRange( range );
	isoValue=range[1] / 8;

    _mCubes = vtkMarchingCubes::New( );
    _mCubes->SetInput( imagedata );
    _mCubes->SetValue( 0, isoValue );

    vtkStripper *stripper = vtkStripper::New();
    stripper->SetInput( _mCubes->GetOutput( ) );

    _surfMapper = vtkPolyDataMapper::New( );
	_surfMapper->SetInput( stripper->GetOutput() );
    _surfMapper->ScalarVisibilityOff( );
    stripper->Delete();

    _surfActor = vtkActor::New( );
    _surfActor->SetMapper( _surfMapper );
    _surfActor->PickableOff( );
    _surfActor->GetProperty( )->SetColor( 0, 0, 0.8 );
    _surfActor->GetProperty( )->SetOpacity( opacity_OrigVol );

	// Update Controls
	_isoValue->SetRange( (int)(range[0]), (int)(range[1]) );
	_isoValue->SetValue( (int)isoValue );
	
	// Interface Update
	vtkRenderer *ren = _maracasSurfaceWidget->GetVtk3DSurfaceWidget()->GetRenderer();
	ren->AddActor(_surfActor);

	//-Maracas-
	_maracasSurfaceWidget->ShowMARACASData( _mar );
}


//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::ResetTree1_JF()
{
	// Remove 
	vtkRenderer *ren = _maracasSurfaceWidget->GetVtk3DSurfaceWidget()->GetRenderer();
    if (_1_isoActorMC6){
		ren->RemoveActor(_1_isoActorMC6);
	}
    if (_1_stripfinal){
		ren->RemoveActor(_1_stripfinal);
	}

	// Delete 
	if (_1_prgov		) {	_1_prgov		-> Delete(); }
	if (_1_mapfinal		) {	_1_mapfinal		-> Delete(); }
	if (_1_stripfinal	) {	_1_stripfinal	-> Delete(); }
	if (_1_isoMapperMC6	) {	_1_isoMapperMC6	-> Delete(); }
	if (_1_isoActorMC6	) {	_1_isoActorMC6	-> Delete(); }
	if (_1_isoMC6		) {	_1_isoMC6		-> Delete(); }

	// Init
	_1_prgov		= NULL;
	_1_mapfinal		= NULL;
	_1_stripfinal	= NULL;
	_1_isoMapperMC6	= NULL;
	_1_isoActorMC6	= NULL;
	_1_isoMC6		= NULL;
}

//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::ResetTree2_JF()
{
	// Remove 
	vtkRenderer *ren = _maracasSurfaceWidget->GetVtk3DSurfaceWidget()->GetRenderer();
    if (_2_isoActorMC6){
		ren->RemoveActor(_2_isoActorMC6);
	}
    if (_2_stripfinal){
		ren->RemoveActor(_2_stripfinal);
	}

	// Delete 
	if (_2_prgov		) {	_2_prgov		-> Delete(); }
	if (_2_mapfinal		) {	_2_mapfinal		-> Delete(); }
	if (_2_stripfinal	) {	_2_stripfinal	-> Delete(); }
	if (_2_isoMapperMC6	) {	_2_isoMapperMC6	-> Delete(); }
	if (_2_isoActorMC6	) {	_2_isoActorMC6	-> Delete(); }
	if (_2_isoMC6		) {	_2_isoMC6		-> Delete(); }

	// Init
	_2_prgov		= NULL;
	_2_mapfinal		= NULL;
	_2_stripfinal	= NULL;
	_2_isoMapperMC6	= NULL;
	_2_isoActorMC6	= NULL;
	_2_isoMC6		= NULL;
}



//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::ExtractTree1_JF(int x, int y, int z)
{
	double opacity_Res1VolJF = ((double)_opacity_Res1VolJF->GetValue())/100;
	vtkImageData *imagedata = _mar->_experiment->getDynData( )->getVolume( )->castVtk();

	double	puntoactualprov[3];
	double	espprin[3];
	int		extprin[6];				

	puntoactualprov[0]=x;
	puntoactualprov[1]=y;
	puntoactualprov[2]=z;
	
	imagedata->GetSpacing(espprin);
	imagedata->GetExtent(extprin);

	puntoactualprov[0]=puntoactualprov[0]*espprin[0];
	puntoactualprov[1]=puntoactualprov[1]*espprin[1];
	puntoactualprov[2]=puntoactualprov[2]*espprin[2];
	
	// Juan Francisco Carrillo Filter 
	_1_prgov= axisExtractor::New();
	_1_prgov->SetHumbral(0.45);
	_1_prgov->SetInput(imagedata);
	_1_prgov->SetPoint(puntoactualprov);
	_1_prgov->Update();

	// Visualisation - result vascular tree
	_1_mapfinal = vtkPolyDataMapper::New();
	_1_mapfinal->SetInput(_1_prgov->GetOutput());

	_1_stripfinal = vtkActor::New();
	_1_stripfinal->SetMapper(_1_mapfinal);
	_1_stripfinal->GetProperty()->SetColor(1, 1, 1);
	_1_stripfinal->GetProperty()->SetLineWidth(2);
	_1_stripfinal->GetProperty()->BackfaceCullingOff();

	// Visualisation - result volume
	vtkImageData *imageOut = _1_prgov->GetVolumen();
	imageOut->Update();

    _1_isoMC6 = vtkMarchingCubes::New();
    _1_isoMC6->SetInput(imageOut);
    _1_isoMC6->SetValue(0, 1);
	_1_isoMC6->Update();

	_1_isoMapperMC6 = vtkPolyDataMapper::New();
    _1_isoMapperMC6->SetInput(_1_isoMC6->GetOutput());
    _1_isoMapperMC6->ScalarVisibilityOff();
    _1_isoMapperMC6->ImmediateModeRenderingOn();

	_1_isoActorMC6 = vtkActor::New();
    _1_isoActorMC6->SetMapper(_1_isoMapperMC6);
    _1_isoActorMC6->GetProperty()->SetColor( 0, 1, 0);
    _1_isoActorMC6->GetProperty()->SetOpacity( opacity_Res1VolJF );
 
   
	// Interface Update
	vtkRenderer *ren = _maracasSurfaceWidget->GetVtk3DSurfaceWidget()->GetRenderer();
	ren->AddActor(_1_isoActorMC6);
	ren->AddActor(_1_stripfinal);
}


//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::ExtractTree2_JF(int x, int y, int z)
{
	double opacity_Res2VolJF = ((double)_opacity_Res2VolJF->GetValue())/100;
	vtkImageData *imagedata = _mar->_experiment->getDynData( )->getVolume( )->castVtk();

	double	puntoactualprov[3];
	double	espprin[3];
	int		extprin[6];				

	puntoactualprov[0]=x;
	puntoactualprov[1]=y;
	puntoactualprov[2]=z;
	
	imagedata->GetSpacing(espprin);
	imagedata->GetExtent(extprin);

	puntoactualprov[0]=puntoactualprov[0]*espprin[0];
	puntoactualprov[1]=puntoactualprov[1]*espprin[1];
	puntoactualprov[2]=puntoactualprov[2]*espprin[2];
	
	_2_prgov= axisExtractor02::New();
	_2_prgov->SetParam(1);
	_2_prgov->SetParam2(1);
	_2_prgov->SetParam3(_sensibility_JF);
	_2_prgov->SetMaxant(20);
	_2_prgov->SetMinant(5);
	_2_prgov->SetInput(imagedata);
	_2_prgov->SetPoint(puntoactualprov);
	_2_prgov->Update();

	// Visualisation - result vascular tree
	_2_mapfinal = vtkPolyDataMapper::New();
	_2_mapfinal->SetInput(_2_prgov->GetOutput());

	_2_stripfinal = vtkActor::New();
	_2_stripfinal->SetMapper(_2_mapfinal);
	_2_stripfinal->GetProperty()->SetColor(0.3, 0.3, 0.3);
	_2_stripfinal->GetProperty()->SetLineWidth(2);
	_2_stripfinal->GetProperty()->BackfaceCullingOff();

	// Visualisation - result volume
	vtkImageData *imageOut = _2_prgov->GetVolumen();
	imageOut->Update();

    _2_isoMC6 = vtkMarchingCubes::New();
    _2_isoMC6->SetInput(imageOut);
    _2_isoMC6->SetValue(0, 1);
	_2_isoMC6->Update();

	_2_isoMapperMC6 = vtkPolyDataMapper::New();
    _2_isoMapperMC6->SetInput(_2_isoMC6->GetOutput());
    _2_isoMapperMC6->ScalarVisibilityOff();
    _2_isoMapperMC6->ImmediateModeRenderingOn();

	_2_isoActorMC6 = vtkActor::New();
    _2_isoActorMC6->SetMapper(_2_isoMapperMC6);
    _2_isoActorMC6->GetProperty()->SetColor( 1, 1, 0);
    _2_isoActorMC6->GetProperty()->SetOpacity( opacity_Res2VolJF );
    
	// Interface Update
	vtkRenderer *ren = _maracasSurfaceWidget->GetVtk3DSurfaceWidget()->GetRenderer();
	ren->AddActor(_2_isoActorMC6);
	ren->AddActor(_2_stripfinal);
}

//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnOpacity_OrigVol(wxScrollEvent& event)
{
	double value = ((double)_opacity_OrigVol->GetValue())/100;
    _surfActor->GetProperty( )->SetOpacity( value );
	Refresh();
}
//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnOpacity_Res1VolJF(wxScrollEvent& event)
{
	if (_1_isoActorMC6!=NULL){
		double value = ((double)_opacity_Res1VolJF->GetValue())/100;
		_1_isoActorMC6->GetProperty( )->SetOpacity( value );
		Refresh();
	}
}
//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnOpacity_Res2VolJF(wxScrollEvent& event)
{
	if (_2_isoActorMC6!=NULL){
		double value = ((double)_opacity_Res2VolJF->GetValue())/100;
		_2_isoActorMC6->GetProperty( )->SetOpacity( value );
		Refresh();
	}
}

//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnIsoValue(wxScrollEvent& event)
{
    wxBusyCursor wait;
	_mCubes->SetValue(0, _isoValue->GetValue());
	Refresh();
}
//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnBtnExtractTree1_JF(wxCommandEvent& event)
{
	if (_1_prgov==NULL){
		wxBusyCursor wait;
		vtk3DSurfaceWidget *world3D = _maracasSurfaceWidget->GetVtk3DSurfaceWidget();
		if( world3D->GetInitialSphere() ){
			double point[3];
			world3D->GetSphereCenter( point );
			ExtractTree1_JF((int)point[0],(int)point[1],(int)point[2]);
		}
		Refresh();
	}
}
//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnBtnExtractTree2_JF(wxCommandEvent& event)
{
	if (_2_prgov==NULL){
		wxBusyCursor wait;
		vtk3DSurfaceWidget *world3D = _maracasSurfaceWidget->GetVtk3DSurfaceWidget();
		if( world3D->GetInitialSphere() ){
			double point[3];
			world3D->GetSphereCenter( point );
			ExtractTree2_JF((int)point[0],(int)point[1],(int)point[2]);
		}
		Refresh();
	}
}
//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnBtnEraseTree1_JF(wxCommandEvent& event)
{
	ResetTree1_JF();
	Refresh();
}
//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnBtnEraseTree2_JF(wxCommandEvent& event)
{
	ResetTree2_JF();
	Refresh();
}

//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::PaintVascularTree_MH_JFC(marExperiment * newExperiment)
{
	vtkActor			*branchActor;
	vtkPolyData			*axisVtk;
	vtkPolyDataMapper	*branchMapper;
	vtkRenderer *ren = _maracasSurfaceWidget->GetVtk3DSurfaceWidget()->GetRenderer();

	int i,maxAxis=newExperiment->getNumberOfAxes();
	for (i=0;i<maxAxis;i++){
		newExperiment->setAxis(i);
		marAxis *maraxis =newExperiment->getAxis( );
		if (maraxis!=NULL) {
			axisVtk = maraxis->Draw();
			branchMapper = vtkPolyDataMapper::New( );
			branchMapper->SetInput( axisVtk );
			branchMapper->Update();
			branchActor = vtkActor::New( );
			branchActor->SetMapper( branchMapper );
			branchActor->GetProperty()->SetColor( 1, 1, 1 );
			if (i== 0) { branchActor->GetProperty()->SetColor( 0  , 0	, 0.3 ); }
			if (i== 1) { branchActor->GetProperty()->SetColor( 0  , 0.3	, 0.3 ); }
			if (i== 2) { branchActor->GetProperty()->SetColor( 0.3, 0.3	, 0.3 ); }
			if (i== 3) { branchActor->GetProperty()->SetColor( 0.0, 0.0	, 0.6 ); }
			if (i== 4) { branchActor->GetProperty()->SetColor( 0.0, 0.6	, 0.6 ); }
			if (i== 5) { branchActor->GetProperty()->SetColor( 0.6, 0.6	, 0.6 ); }
			if (i== 7) { branchActor->GetProperty()->SetColor( 0.0, 0.0	, 0.9 ); }
			if (i== 8) { branchActor->GetProperty()->SetColor( 0.0, 0.9	, 0.9 ); }
			if (i== 9) { branchActor->GetProperty()->SetColor( 0.9, 0.9	, 0.9 ); }
			if (i==10) { branchActor->GetProperty()->SetColor( 0.9, 0.0	, 0.0 ); }
			if (i==11) { branchActor->GetProperty()->SetColor( 0.6, 0.0	, 0.0 ); }
			if (i==12) { branchActor->GetProperty()->SetColor( 0.3, 0.0	, 0.0 ); }
			if (i==13) { branchActor->GetProperty()->SetColor( 0.6, 0.6	, 0.0 ); }
			if (i==14) { branchActor->GetProperty()->SetColor( 0.3, 0.3	, 0.0 ); }
			if (i==15) { branchActor->GetProperty()->SetColor( 0.9, 0.9	, 0.0 ); }
			branchActor->GetProperty()->SetLineWidth( 2.0 );
			ren->AddActor( branchActor );

			_lstAxisVtk.push_back( axisVtk );
			_lstBranchActor.push_back( branchActor );
			_lstBranchMapper.push_back( branchMapper );
		}
	}
}


//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::PaintVascularVolume_MH_JFC(vtkImageData * image)
{

	// Visualisation - result volume
	image->Update();

	_imageThresholdMC1=vtkImageThreshold::New();
	_imageThresholdMC1->SetInput(image);
	_imageThresholdMC1->ThresholdBetween(0,100);
	_imageThresholdMC1->SetOutValue  (  0   ); 
	_imageThresholdMC1->Update();

    _isoMC1 = vtkMarchingCubes::New();
    _isoMC1->SetInput(_imageThresholdMC1->GetOutput()	);
    _isoMC1->SetValue(0, 1);
	_isoMC1->Update();

	_isoMapperMC1 = vtkPolyDataMapper::New();
    _isoMapperMC1->SetInput(_isoMC1->GetOutput());
    _isoMapperMC1->ScalarVisibilityOff();
    _isoMapperMC1->ImmediateModeRenderingOn();
	_isoMapperMC1->Update();

	_isoActorMC1 = vtkActor::New();
    _isoActorMC1->SetMapper(_isoMapperMC1);
    _isoActorMC1->GetProperty()->SetColor( 1, 0, 0);
    _isoActorMC1->GetProperty()->SetOpacity( 0.4 );

	// Interface Update
	vtkRenderer *ren = _maracasSurfaceWidget->GetVtk3DSurfaceWidget()->GetRenderer();
	ren->AddActor(_isoActorMC1);
}

//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::WriteSignals(marExperiment *newExperiment){
	int		i		=	0;
	int		j		=	0;
	bool	ok		=	true;
	int		value	=	0;
	int		maxAxis	=	newExperiment->getNumberOfAxes();

	FILE *ff;
	ff=fopen("c:/Temp/MaracasTEMP.TXT", "w");

	while (ok==true){
		ok=false;
		for (i=0;i<maxAxis;i++){
			newExperiment->setAxis(i);
			marAxis *maraxis =newExperiment->getAxis( );
			if (maraxis!=NULL) {
				if ( j < maraxis->getNumberOfControlPoints()  ){
					ok=true;
					value= (int) (maraxis->getSignal((uint)j) );
					fprintf(ff,"%d\t", value );
				} else {
					fprintf(ff,"\t");
				}
			}
		}
		fprintf(ff,"\n" );
		j++;
	}
	fclose(ff);

}


//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnBtnExtractTree_MH_JFC(wxCommandEvent& event)
{
  if ((_lstBranchActor.size()==0) 
	  && 
	  (_maracasSurfaceWidget->GetVtk3DSurfaceWidget()->GetInitialSphere() ) )
  {
   wxBusyCursor wait;

	// Copie Volume
	int voiA[6];
	int voiB[6];
	_mar->_experiment->getVOI(voiA);
	voiB[0]=0;
	voiB[1]=voiA[1]-voiA[0];
	voiB[2]=0;
	voiB[3]=voiA[3]-voiA[2];
	voiB[4]=0;
	voiB[5]=voiA[5]-voiA[4];
	marExperiment *newExperiment = new marExperiment( _mar->_experiment->getParameters() );
	newExperiment->setVOI( voiB );
	newExperiment->initExperiment( _mar->_experiment->getDynData( )->getVolume() );
	
	double	point[3];
	int		extent[ 6 ];
    _mar->_experiment->getDynData( )->getVolume( )->castVtk()->GetExtent( extent );
    _maracasSurfaceWidget->GetVtk3DSurfaceWidget()->GetSphereCenter( point );
	int x = (int)point[0] - extent[0];
	int y = (int)point[1] - extent[2];
	int z = (int)point[2] - extent[4];
	newExperiment->setStartPoint( x, y, z);

	// Vascular tree extraction
	_treeExtraction = TreeExtraction_MH_JFC::New();
	_treeExtraction->SetInput(newExperiment);
	_treeExtraction->SetCleanTreeLevel( _cleanTree_MH_JFC->GetValue() );
	_treeExtraction->SetBranchLevel( _branchLevel->GetValue() );
	_treeExtraction->Update();

	//Paint Vascular Tree
	PaintVascularTree_MH_JFC(newExperiment);
	//Paint Vascular Volume
	PaintVascularVolume_MH_JFC( _treeExtraction->GetVolume() );
	Refresh( );

	WriteSignals(newExperiment);

	// Clening memory
	delete newExperiment;
  }
}
//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnBtnEraseTree_MH_JFC(wxCommandEvent& event)
{
	ResetTree_MH_JFC();
	Refresh();
}

//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::ResetTree_MH_JFC()
{	
	// Remove
	vtkRenderer *ren = _maracasSurfaceWidget->GetVtk3DSurfaceWidget()->GetRenderer();
	int i,size;
	size=_lstAxisVtk.size();
	size=_lstBranchMapper.size();
	size=_lstBranchActor.size();
	for (i=0;i<size;i++){
		if (_lstBranchActor[i]!=NULL){
			ren->RemoveActor( _lstBranchActor[i] );
		}
	}
	for (i=0;i<size;i++){
	// Delete
		if (_lstAxisVtk[i]		!= NULL	) {	_lstAxisVtk[i]		-> Delete();	}
//		if (_lstBranchMapper[i]	!= NULL	) {	_lstBranchMapper[i] -> Delete();	}
		if (_lstBranchActor[i]	!= NULL	) {	_lstBranchActor[i]	-> Delete();	}
	// Init
		_lstAxisVtk[i]		= NULL;
		_lstBranchActor[i]	= NULL;
		_lstBranchMapper[i]	= NULL;
	}
	_lstAxisVtk.clear();
	_lstBranchActor.clear();
	_lstBranchMapper.clear();

	// Remove 
    if (_isoActorMC1){
		ren->RemoveActor(_isoActorMC1);
	}

	// Delete 
	if (_isoMapperMC1		) {	_isoMapperMC1		-> Delete(); }
	if (_isoActorMC1		) {	_isoActorMC1		-> Delete(); }
	if (_isoMC1				) {	_isoMC1				-> Delete(); }
	if (_imageThresholdMC1	) {	_imageThresholdMC1	-> Delete(); }


	// Init
	_isoMapperMC1		= NULL;
	_isoActorMC1		= NULL;
	_isoMC1				= NULL;
	_imageThresholdMC1	= NULL;

	//
//	if (_treeExtraction	) {	_treeExtraction	-> Delete(); }     // EED
//	_treeExtraction=NULL; 

}

//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnOpacity_ResVolMHJF(wxScrollEvent& event)
{
	if (_isoActorMC1!=NULL){
		double value = ((double)_opacity_ResVolMHJF->GetValue())/100;
		_isoActorMC1->GetProperty( )->SetOpacity( value );
	}
	Refresh();
}
//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnBranchLevel(wxScrollEvent& event)
{
	//
}
//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnIsoValue_MH_JFC(wxScrollEvent& event)
{
	if (_imageThresholdMC1!=NULL){
		wxBusyCursor wait;
		double threshold = _isoValue_MH_JFC->GetValue();
		if (threshold!=0){
			_imageThresholdMC1->ThresholdBetween(threshold, threshold );
		} else {
			_imageThresholdMC1->ThresholdBetween(0, 1000 );
		}
		Refresh();
	}
}
//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnCleanTree_MH_JFC(wxScrollEvent& event)
{
//
}
//------------------------------------------------------------------------
void wxEmptyPanelWidget_2::OnSensibility(wxScrollEvent& event)
{
	_sensibility_JF = (double)(_sl_sensibility_JF->GetValue())/100;
}