//----------------------------------------------------------------------------------------------------------------
// Class definition include
//----------------------------------------------------------------------------------------------------------------
#include "wxContourMainFrame.h"



//----------------------------------------------------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------------------------------------------------


#include "NameWrapper.h"
#include "wx/artprov.h"
#include "ConceptDataWrap.h"

#include <manualContour.h>
//#include "ImageSourceThing.h"
//#include "wxContour_ActionCommandsID.h"
//#include "OutlineModelBuilder.h"
//#include "wxContourEventHandler.h"
#include <creaWx.h>

//----------------------------------------------------------------------------------------------------------------
// Class implementation
//----------------------------------------------------------------------------------------------------------------
/** @file wxContourMainFrame.cxx */

	//------------------------------------------------------------------------------------------------------------
	// Constructors & Destructors
	//------------------------------------------------------------------------------------------------------------

wxContourMainFrame* wxContourMainFrame:: instance = NULL;
char wxContourMainFrame::COPY = 'C';
		
	wxContourMainFrame :: wxContourMainFrame(wxWindow* parent, wxWindowID id,const wxString& title,const wxPoint& pos,const wxSize& size,long style)
		//: wxPanel(parent, id, title, pos, size, style)
		//: wxWindow(parent, id, pos, size, style)
		: wxPanel(parent, id, pos, size, style)
	{
		m_mgr.SetManagedWindow(this);
		_creatingContoursActive		= false;
		_theViewPanel				= NULL;
//		_modelManager				= NULL;
		_instantPanel				= NULL;
		_buttonsBar					= NULL;
		_gridPanel					= NULL;	
		_drawToolsPanel				= NULL;
		_operationsToolsPanel		= NULL;
		_autoFormsPanel				= NULL; 
		_standardToolsPanel			= NULL;
		_editionToolsPanel			= NULL;
		_listViewPanel				= NULL;
		_sceneManager				= NULL;
		//_actualInstant				= NULL;
		_numberOfVariablesStatistics = 6+1;

		// set up default notebook style
		m_notebook_style =wxAUI_NB_TAB_SPLIT | wxAUI_NB_TAB_EXTERNAL_MOVE | wxNO_BORDER;
		m_notebook_theme = 0;	
		//wxContour_ActionCommandsID a;

	}

wxContourMainFrame :: wxContourMainFrame(wxWindow* parent, wxWindowID id,const wxString& title,const wxPoint& pos,const wxSize& size,std::vector<vtkImageData*> images, long style)		
		: wxPanel(parent, id, pos, size, style)
	{
		m_mgr.SetManagedWindow(this);
		_creatingContoursActive		= false;
		_theViewPanel				= NULL;
//		_modelManager				= NULL;
		_instantPanel				= NULL;
		_buttonsBar					= NULL;
		_gridPanel					= NULL;	
		_drawToolsPanel				= NULL;
		_operationsToolsPanel		= NULL;
		_autoFormsPanel				= NULL; 
		_standardToolsPanel			= NULL;
		_editionToolsPanel			= NULL;
		_listViewPanel				= NULL;
		_sceneManager				= NULL;
		//_actualInstant				= NULL;

		// set up default notebook style
		m_notebook_style =wxAUI_NB_TAB_SPLIT | wxAUI_NB_TAB_EXTERNAL_MOVE | wxNO_BORDER;
		m_notebook_theme = 0;	
		//wxContour_ActionCommandsID a;
		_numberOfVariablesStatistics = 6+1;


		_performingOperation			= new PerformingOperation();
//JCP 17 - 10 - 2008

	inredo = 0;
	inundo = 0;

	kernelManager = new KernelManagerContour(images);
	//kernelManager->setVectImages(images);
	//kernelManager->initializeEnvironment();
        		
	//vtkImageData* selectedimage = kernelManager->getVectImages()[0];
	
//-------------------------------------------------------------

	/*frame = new wxContourMainFrame(_builder->getImSourceEnv(), _builder->getImSectionEnv(), _builder->getAxesEnv(),  _builder->getContourEnv(),NULL, wxID_ANY, wxT("ROI Application Sample"), wxPoint(50,50), wxSize(800, 600)); 
	frame->Show(TRUE);*/

	//Creating the evtHandler of the panels
	//wxContourEventHandler * eventHandler = new wxContourEventHandler();

	//Creating the window that will show the panels

	//Getting the parent for the panels ( using aui )
	wxAuiNotebook * notebook = this->createNotebook();

	//JCP 17 - 11 - 08
	//wxInstantChooserPanel	* instantPanel				= new wxInstantChooserPanel( notebook, "Instant Chooser", true);
	//JCP 17 - 11 - 08
	std::vector<std::string> conceptNameVect;
	std::vector<int> conceptSizeVect;
	


	_instantPanel				= new wxInstantChooserPanel( notebook, "Instant Chooser", true, false, "c" );
	_theViewPanel				= new wxContourViewPanel( kernelManager->getSourceImage(), notebook );	



    kernelManager->getConceptsInformation(conceptNameVect, conceptSizeVect);
	_instantPanel->addConcepts(conceptNameVect, conceptSizeVect);
		

	double val = _theViewPanel->getCurrentDeep();
	_instantPanel->setConceptValue( "Axe Depth", (int)val );
	//JCP _instantPanel->setConceptValue("time", num de imagenes);
	ConceptDataWrap * data = _instantPanel->getConceptDataOf( "Axe Depth" );
	//*******************changeInstant();
	_theViewPanel->setVerticalConcept( "Axe Depth", data->getMinValue(), data->getMaxValue(), data->getMinShowedValue(),  data->getMaxShowedValue(), data->getActualValue() );

	//eventHandler->setModelManager( kernelManager->getOutlineModelManager() );
	//eventHandler->setViewPanel( _theViewPanel );
	//_theViewPanel->initializeScenceManager();
	//eventHandler->setInstantChooserPanel( _instantPanel );
	
	//bool successConfiuration = eventHandler->configureEventsHandling();

	//successConfiuration &= this->configurePanels( notebook );
	this->configurePanels( notebook );

	interfMainPanel* pannew = interfMainPanel::getInstance(parent);//, eventHandler);

//JCP 17 -10 - 2008


	}


	wxContourMainFrame* wxContourMainFrame :: getInstance(wxWindow* parent, wxWindowID id,const wxString& title,const wxPoint& pos,const wxSize& size,std::vector<vtkImageData*> images, long style ){
		if(instance == NULL){
			instance = new wxContourMainFrame(parent, id, title, pos, size, images, style);
		}
		return instance;
	}

	std::vector<vtkImageData*> wxContourMainFrame ::getVectImages(){
		return kernelManager->getVectImages();
	}
	wxContourMainFrame* wxContourMainFrame :: getInstance(){
		return instance;
		
	}

	wxContourMainFrame :: ~wxContourMainFrame()
	{
		  m_mgr.UnInit();
		  //El problema al cerrar la aplicacion puede estar asociado 
		  //a que  wxAUINotebook esta en la aplicacion 
		  //principal (wxContourGUIExample)tambien
//EED????		delete _theViewPanel;		  
//EED????		delete _instantPanel;
//EED????		delete _buttonsBar;
//EED????		delete _actualInstant;		 
//EED????		delete _sceneManager;
	}


	//------------------------------------------------------------------------------------------------------------
	// Creational and initialization methods using WxAui
	//------------------------------------------------------------------------------------------------------------
	//
	wxAuiNotebook * wxContourMainFrame :: createNotebook()
	{
		wxSize client_size = GetClientSize();
		wxAuiNotebook* noteBook = new wxAuiNotebook(this, -1, wxPoint(client_size.x, client_size.y), wxSize(430,200), m_notebook_style);
		wxBitmap page_bmp = wxArtProvider::GetBitmap(wxART_NORMAL_FILE, wxART_OTHER, wxSize(16,16));
		return noteBook;
	}
	

	//------------------------------------------------------------------------------------------------------------
	// Creational and initialization methods 
	//------------------------------------------------------------------------------------------------------------
	bool wxContourMainFrame :: configurePanels(wxAuiNotebook* theNoteBook)
	{
		bool configured = _theViewPanel!=NULL;
					
		configured &= _theViewPanel!=NULL;
		if( _theViewPanel!=NULL )
		{
			theNoteBook->AddPage( _theViewPanel, wxT("       View       ") );		
			m_mgr.Update();
		}


		if( configured )
		{
			theNoteBook->AddPage( _instantPanel, wxT("Instant Page") );
			m_mgr.Update();
		}

		m_mgr.AddPane(theNoteBook, wxAuiPaneInfo().Name(wxT("notebook_content")).CenterPane().PaneBorder(false));
		m_mgr.Update();
		configured &= _buttonsBar!=NULL;
		if( _buttonsBar!=NULL )
		{			
			m_mgr.AddPane(_buttonsBar, wxAuiPaneInfo().
					Name(wxT("TB")).Caption(wxT("Buttons Bar")).
					ToolbarPane().Top().
					LeftDockable(  ).RightDockable( false ).CloseButton(false));
			m_mgr.Update();
		}
		//CreateStatusBar();
			 
		SetMinSize(wxSize(300,300));
		m_mgr.Update();
		return configured;
	}

	void wxContourMainFrame :: setNotebook( wxAuiNotebook * noteBook )
	{

	}

	//------------------------------------------------------------------------------------------------------------
	//  Attributes getters and setters
	//------------------------------------------------------------------------------------------------------------
	

	
	void wxContourMainFrame :: setInstantChooserPanel(  wxInstantChooserPanel * theInstantChooserPanel )
	{
		_instantPanel = theInstantChooserPanel;	
	}

	void wxContourMainFrame :: setButtonsBar(  wxContour_ButtonsBar * theButtonsBar )
	{
		_buttonsBar = theButtonsBar;
	}

	void wxContourMainFrame :: setGrid(  wxContour_Grid * theGridPanel )
	{
		_gridPanel = theGridPanel;
	}

	void wxContourMainFrame :: setDrawToolsPanel(  wxContour_DrawToolsPanel * theDrawToolsPanel )
	{
		_drawToolsPanel = theDrawToolsPanel;
	}

	void wxContourMainFrame :: setOperationsToolsPanel(  wxContour_OperationsToolsPanel * theOperationsToolsPanel )
	{	
		_operationsToolsPanel = theOperationsToolsPanel;
	}

	void wxContourMainFrame :: setAutomaticFormsPanel(  wxContour_AutomaticFormsToolsPanel * theAutoFormsPanel )
	{
		_autoFormsPanel = theAutoFormsPanel;
	}

	void wxContourMainFrame :: setStandardToolsPanel(  wxContour_StandardToolsPanel * theStandardToolsPanel )
	{
		_standardToolsPanel= theStandardToolsPanel;
	}

	void wxContourMainFrame :: setEditionToolsPanel(  wxContour_EdtionToolsPanel * theEditionToolsPanel )
	{
		_editionToolsPanel =  theEditionToolsPanel;
	}

	void wxContourMainFrame :: setListViewPanel(  wxContour_ListViewPanel * theListViewPanel )
	{
		_listViewPanel = theListViewPanel;
	}



void wxContourMainFrame::onCreateContourSpline( ){
	
	//JCP 20-10-08 Undo redo implementation
	saveState();
	//JCP 20-10-08 Undo redo implementation
	createContour( 1 );
	
}
void wxContourMainFrame::onCreateContourRectangle( ){
    //JCP 20-10-08 Undo redo implementation
	saveState();
	//JCP 20-10-08 Undo redo implementation	
	createContour( 2 );
}
void wxContourMainFrame::onCreateContourCircle( ){
    //JCP 20-10-08 Undo redo implementation
	saveState();
	//JCP 20-10-08 Undo redo implementation	
	createContour( 3 );
}
//------------------------------------------------------------------------------------------------------------

void wxContourMainFrame :: onCreateContourBullEye(wxPanel* panel )
{
	//Creating the manualContourModel and including in the model
	manualContourModel * manModelContour = factoryManualContourModel(panel );

	std::vector<int> instantVector;
	_instantPanel->getInstant( instantVector );
	std::string theName = kernelManager->createOutline(manModelContour, instantVector);
	
	/*std::vector<int> instantVector;
	_instantPanel->getInstant( instantVector );
	std::string theName;
	theName= _modelManager->createOutline( manModelContour, instantVector );*/
	bool addedModel = theName.compare("") != 0;//??

	if( addedModel )
	{
		double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
		_theViewPanel->getSpacing(spc);					
		//Adding the manualContourControler to interface objects structure
		//Adding the manualViewContour to interface objects structure		
		//_theViewPanel->getSceneManager()->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
		_theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc , 4) ;
	}
}
void wxContourMainFrame :: createContour( int typeContour )
{
	//Creating the manualContourModel and including in the model
	manualContourModel * manModelContour = kernelManager->factoryManualContourModel(typeContour);


	std::vector<int> instantVector;
	_instantPanel->getInstant( instantVector );
	std::string theName = kernelManager->createOutline(manModelContour, instantVector);
	
	/*std::vector<int> instantVector;
	_instantPanel->getInstant( instantVector );
	std::string theName;
	theName= _modelManager->createOutline( manModelContour, instantVector );*/
	bool addedModel = theName.compare("") != 0;//??
	if( addedModel )
	{
		double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
		_theViewPanel->getSpacing(spc);					
		//Adding the manualContourControler to interface objects structure
		//Adding the manualViewContour to interface objects structure		
		//_sceneManager->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
		_theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc , typeContour) ;
	}	

}
manualContourModel * wxContourMainFrame::factoryManualContourModel(wxPanel* panel){

	manualContourModelBullEye *manModelContourBullEye = new manualContourModelBullEye();
	manualContourModel *manModelContour=NULL;
	manModelContour = manModelContourBullEye;
	if (panel!=NULL){
		int iCrown,sizeCrowns,iSector,sizeSectors;
		double radioA,radioB,ang,angDelta ;
		sizeCrowns = ((PanelBullEyeOptions*)panel)->GetNumberOfCrowns();
		for ( iCrown=0 ; iCrown<sizeCrowns ; iCrown++ )
		{
			sizeSectors = ((PanelBullEyeOptions*)panel)->GetNumberOfSections(iCrown);
			radioB	= ((PanelBullEyeOptions*)panel)->GetRadioOfCrown(iCrown);
			if (iCrown==sizeCrowns-1)
			{
				radioA	= 0;
			} else {
				radioA	= ((PanelBullEyeOptions*)panel)->GetRadioOfCrown(iCrown+1);
			}
			radioA=radioA/100.0;
			radioB=radioB/100.0;
			for ( iSector=0 ; iSector<sizeSectors  ; iSector++ )
			{
				ang		= ((PanelBullEyeOptions*)panel)->GetAngOfCrownSection(iCrown,iSector);
				angDelta= ((PanelBullEyeOptions*)panel)->GetAngDeltaOfCrownSection(iCrown);					
				manModelContourBullEye->AddSector(radioA,radioB,ang,angDelta);
			} // for iSector
		} // for iCrown
	} // if _panelBullEyeOptions
	
	return manModelContour;
}
void wxContourMainFrame :: saveState(){	
		
	std::string temp = kernelManager->saveState();
	saveFileWithContours(temp);	
}

void wxContourMainFrame::onDeleteContour(){
	//JCP 20-10-08 Undo redo implementation
		saveState();
		//JCP 20-10-08 Undo redo implementation

		std::vector<std::string> lstKeyNameToBeErase;
		lstKeyNameToBeErase		= _theViewPanel->getSceneManager()->getSelectedObjects();
		deleteContours( lstKeyNameToBeErase );
/*JCP 19 - 11 - 08
		int i,size=_sceneManager->getSelectedObjects().size();
		for(i=0;i<size;i++)
		{
			std::string keyName		= _sceneManager->getSelectedObjects()[i];
			int ispartofstaticlist	= this->_modelManager->IsPartOfStaticList( keyName );
			if ( ispartofstaticlist>=0 )
			{
				std::vector<int> tempVector;
				_instantPanel->getInstant( tempVector );
				Instant instant(&tempVector);
				this->_modelManager->ChangeContourOfList(keyName, &instant);
			}
		}

		std::vector<std::string> lstKeyName;
		std::vector<std::string> lstKeyNameActualSlice;
		std::vector<std::string> lstKeyNameToBeErase;

		lstKeyNameToBeErase		= _sceneManager->getSelectedObjects();
		lstKeyNameActualSlice	= _sceneManager->GetlstContoursNameActualSlice();
		int k,kSize=lstKeyNameToBeErase.size();
		int j,jSize=lstKeyNameActualSlice.size();
		bool ok;
		for (k=0;k<kSize; k++)
		{
			ok=false;
			for (j=0;j<jSize; j++)
			{
				if (lstKeyNameToBeErase[k]==lstKeyNameActualSlice[j])
				{ 
					ok=true;
				}
			} // for j
			if (ok==true)
			{
				lstKeyName.push_back( lstKeyNameToBeErase[k] );
			} // if ok
		} // for k

		deleteContours( lstKeyName );
JCP 19 - 11 - 08*/
}

void wxContourMainFrame :: deleteContours( std::vector<std::string>  keyNamesVector )
{
	int i,size=keyNamesVector.size();
	for (i=0;i<size;i++)
	{
		deleteContour( keyNamesVector[i] );
	}
}

void wxContourMainFrame :: deleteContour( std::string theKeyName ){
	/*manualContourModel			* cModel;
	manualViewBaseContour		* cViewer;
	manualContourBaseControler	* cControler;

	ContourWrap_ViewControl *conwrapviewControl =  _theViewPanel->getSceneManager()->getContourWrap_ViewControlOf( theKeyName );
	cControler	= conwrapviewControl->getControler();*/

	//JCP 21 - 11 - 2008
	bool isedit = _theViewPanel->isEditableCControler(theKeyName);
	bool ispartofstaticlst = kernelManager->IsPartOfStaticList(theKeyName);

	if (isedit  && ispartofstaticlst)
	{
		_theViewPanel->removeFromScene(theKeyName);

		kernelManager->deleteCModel(theKeyName);
		//_theViewPanel->getSceneManager()->removeFromScene( theKeyName );			
		//cViewer		= conwrapviewControl->getViewer();
		//_theViewPanel->getSceneManager()->removeWrap( theKeyName );
		//cControler* conwrapviewControl->getControler();			
//EED Borrame
//FILE *ff = fopen("c:/temp/wxVtkBaseView_SceneManagerStadistics.txt","a+");
//fprintf(ff,"EED wxContourEventHandler::deleteContours() \n" );
//fprintf(ff,"    %s %p\n",keyNamesVector[i].c_str(),  cControler );
//fclose(ff);
	//	delete cModel;
	//	delete cViewer;
	//	delete cControler;
	} // if editable
//JCP 21 - 11 - 08
}

void wxContourMainFrame::onDeleteContoursActSlice(){
	//JCP 20-10-08 Undo redo implementation
	saveState();
	//JCP 20-10-08 Undo redo implementation
	deleteContours( (std::vector<std::string>)_theViewPanel->getSceneManager()->GetlstContoursNameActualSlice() );
}
void wxContourMainFrame::onDeleteAllContours(){
	//JCP 20-10-08 Undo redo implementation
	saveState();
	deleteAllContours();
}
void wxContourMainFrame::deleteAllContours(){
	//JCP 20-10-08 Undo redo implementation

	wxBusyCursor wait;
	std::vector<int> tempVector;
	_instantPanel->getInstant( tempVector );

//JCP --08-09-2008 When using a diferent interface the _mbarrangeDeleteAll might not be initialize
//		the values in GetStart and GetEnd will then not be initialize also.
//		We use instead the values given when initializing the _deletepanel.

	//int minZ = _mbarrangeDeleteAll->GetStart();
	//int maxZ = _mbarrangeDeleteAll->GetEnd();
	int minZ, maxZ;
	
	minZ = 0;
	maxZ = _theViewPanel->getSceneManager()->GetImageDataSizeZ();
	
//JCP --08-09-2008
	
	_theViewPanel->getSceneManager()->removeSceneContours( );	
	_theViewPanel->getSceneManager()->removeAllOutlines();
	kernelManager->removeAllOutlines();	
//JCP --08-09-2008
	/*
	if ( (minZ==0) && (maxZ==_mbarrangeDeleteAll->GetMax() ))
	{
		_theViewPanel->getSceneManager()->removeSceneContours( );
		_modelManager->removeAllOutlines();
		_theViewPanel->getSceneManager()->removeAllOutlines();

	} else {
		for ( z=minZ ; z<=maxZ ; z++)
		{
			tempVector[1]=z;
			Instant instant(&tempVector);
			std::vector<ContourThing**> lstContourThings = this->_modelManager->getOutlinesAtInstant( &instant );

			sizeLstContourThings = lstContourThings.size();
			for (ii=0 ; ii<sizeLstContourThings ; ii++)
			{
				ContourThing **contourthing = lstContourThings[ii];
				deleteContour( (*contourthing)->getName() );
			} //for ii
		}// for z
	} // if 
JCP --08-09-2008 */
}

void wxContourMainFrame::setConceptValue( std::string name, int value ){
	_instantPanel->setConceptValue(name, value);
}

ConceptDataWrap* wxContourMainFrame::getLastConceptData(){
	return _instantPanel->getLastConceptData();
}
bool wxContourMainFrame::getIfConceptCheckedAt( std::string name, int pos ){
	return _instantPanel->getIfConceptCheckedAt( name, pos );
}

void wxContourMainFrame::changeInstant(){
		std::vector<int> instantVect;
		_instantPanel->getInstant( instantVect );
//		Instant * theInstant = new Instant ( &instantVect );
		
		//Setting the actual instant
		//_actualInstant = theInstant;

		kernelManager->setInstant(instantVect);
		//_modelManager->setInstant( _actualInstant );
		
		updateInstantOutlines();
		updateInstantImageData();
		updateInstantAxes();

		
}
void wxContourMainFrame :: updateInstantOutlines(){
	
	_theViewPanel->removeSceneContours();
	_theViewPanel->addNameWrapperToScene();

	//for( int i=0; i<size; i++)
	//{			
	//	_theViewPanel->getSceneManager()->addToScene(namesWrapping[i]->getKeyName(), true, true, true, false, false );
	//}
}

int wxContourMainFrame::getNamesWrappingSize(){
	return kernelManager->getNamesWrappingSize();
}
std::string wxContourMainFrame::getNameWrapping(int i){
	return kernelManager->getNameWrapping(i);
}

void wxContourMainFrame::updateInstantImageData(){
	std::vector<int> inst;
	_instantPanel->getInstant(inst);

	vtkImageData* img = kernelManager->getImageAtInstant(inst);
	if(img!=NULL){
		_theViewPanel->changeImage(img);
	}else{
		int z = _instantPanel->getConceptDataOf("Axe Depth")->getActualValue();
		_theViewPanel->setImageSlice(z);
	}
}
void wxContourMainFrame::updateInstantAxes(){
}

void wxContourMainFrame::onChangeDeep(int val){
	_instantPanel->setConceptValue( "Axe Depth", (int)val );	
	changeInstant();
}


void wxContourMainFrame::onCopy(){
	std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();

	std::vector<int> tempVector;
	_instantPanel->getInstant( tempVector );
    _performingOperation->reset();
	_performingOperation->setStartCommand( COPY );
	_performingOperation->setStartOperationInstantVector( tempVector );
	_performingOperation->setKeyNamesOperationElems( currentSelection );
}
void wxContourMainFrame::onPaste(){


	char theStartCommand = _performingOperation->getStartCommand();
	if (  theStartCommand == COPY )
	{
		//JCP 20-10-08 Undo redo implementation
		saveState();
		//JCP 20-10-08 Undo redo implementation
		std::vector<int> tempVector;
		_instantPanel->getInstant( tempVector );
		_performingOperation->setEndOperationInstantVector ( tempVector );
		std::vector<std::string> elems = _performingOperation->getKeyNamesOperationElems();
		int i,size = elems.size();			
		for( i=0; i<size; i++ )
		{				
			createCopyContourOf( elems[i], tempVector, i>0 );
		}		
	}
}
void wxContourMainFrame::onUndo(){
	std::string filename;
	if(kernelManager->onUndoSaveFile(filename)){
		saveFileWithContours(filename);
	}
	if(kernelManager->onUndo(filename)){
		loadState(filename);
	}
}
void wxContourMainFrame::onRedo(){
	std::string filename;
	if(kernelManager->onRedo(filename)){
		loadState(filename);
	}
	
}
void wxContourMainFrame :: createCopyContourOf ( std::string anExistingKName, std::vector<int> &instantNoTouchData, bool append ){
	std::string cloneName = kernelManager->createCopyContourOf( anExistingKName, instantNoTouchData );
	manualContourModel * manualModel = kernelManager->getOutlineByKeyName(cloneName);//_modelManager->getOutlineByKeyName( cloneName )->getModel();
	_theViewPanel->getSceneManager()->createCopyContourOf( anExistingKName, cloneName, manualModel , append );
}

void wxContourMainFrame ::loadState(std::string filename){
	char tmp[255];
	FILE *pFile=fopen(filename.c_str(),"r+");

	fscanf(pFile,"%s",tmp); // --CreaContour--

	fscanf(pFile,"%s",tmp); // Version
	fscanf(pFile,"%s",tmp); // 1.0.1
	std::string version(tmp);

	deleteAllContours();

	openContours(pFile,false);
	if (version!="1.0.0"){
		openContours(pFile,true);
	}

	fclose(pFile);
	
	//_theViewPanel->getSceneManager()->removeSceneContours();
	//changeInstant();

}

void wxContourMainFrame::onLoad(){
	char tmp[255];
	wxFileDialog dialog(NULL, _T("Choose a file"), _T(""), _T(""), _T("*.roi"), wxOPEN );
	if (dialog.ShowModal() == wxID_OK)
	{
		std::string fileNameContourROI = (const char *)(dialog.GetPath().mb_str());
		FILE *pFile=fopen(fileNameContourROI.c_str(),"r+");

		fscanf(pFile,"%s",tmp); // --CreaContour--

		fscanf(pFile,"%s",tmp); // Version
		fscanf(pFile,"%s",tmp); // 1.0.1
		std::string version(tmp);

		openContours(pFile,false);
		if (version!="1.0.0"){
			openContours(pFile,true);
		}
//			  _theViewPanel->getSceneManager()->openFileWithContours(ff);

		fclose(pFile);
	}
	_theViewPanel->getSceneManager()->removeSceneContours();
	changeInstant();
}
void wxContourMainFrame::onSave(){
	wxFileDialog dialog(NULL, _T("Choose a file"), _T(""), _T(""), _T("*.roi"), wxSAVE );
	if (dialog.ShowModal() == wxID_OK)
	{
		std::string fileNameContourROI = (const char *)(dialog.GetPath().mb_str());
		saveFileWithContours( fileNameContourROI );
	}
}
void wxContourMainFrame::saveFileWithContours( std::string filename ){

	FILE *pFile=fopen(filename.c_str(),"w+");
	std::vector< std::string > lstNameThings;
	int i,sizeLstNameThings; 

	fprintf(pFile,"--CreaContour--\n");
	fprintf(pFile,"Version %s\n", "1.0.1" );

	// Normal Contours
	lstNameThings		= kernelManager->GetLstNameThings();
	sizeLstNameThings	= lstNameThings.size(); 
	fprintf(pFile,"NumberOfContours %d\n", sizeLstNameThings );
	for (i=0 ; i<sizeLstNameThings ; i++) 
	{
		kernelManager->SaveThingName( pFile, lstNameThings[i] );
		_theViewPanel->getSceneManager()->SaveThingName( pFile, lstNameThings[i] );
	}// for i

	//-- Contours Statics 
	lstNameThings		= kernelManager->GetLstNameThingsStatic();
	sizeLstNameThings	= lstNameThings.size(); 
	fprintf(pFile,"NumberOfContoursStatic %d\n", sizeLstNameThings );
	for (i=0 ; i<sizeLstNameThings ; i++) 
	{
		kernelManager->SaveThingName( pFile, lstNameThings[i] );
		_theViewPanel->getSceneManager()->SaveThingName( pFile, lstNameThings[i] );
	}// for i
	fclose(pFile);
}

void wxContourMainFrame::openContours( FILE *pFile, bool staticContour ){
	char tmp[255];
	fscanf(pFile,"%s",tmp); // NumberOfContours 
	fscanf(pFile,"%s",tmp); // ##
	int numberOfContours = atoi(tmp);  

	std::vector<int> instantVector;
	int typeContourModel;
	manualContourModel *manModelContour;
	int typeView;

	int i;
	for (i=0;i<numberOfContours;i++)
	{
		instantVector.clear();
		fscanf(pFile,"%s",tmp); // Instant

		fscanf(pFile,"%s",tmp); // 1
		instantVector.push_back( atoi(tmp) );
		fscanf(pFile,"%s",tmp); // 2
		instantVector.push_back( atoi(tmp) );
		fscanf(pFile,"%s",tmp); // 3
		instantVector.push_back( atoi(tmp) );
		fscanf(pFile,"%s",tmp); // 4
		instantVector.push_back( atoi(tmp) );
		fscanf(pFile,"%s",tmp); // 5
		instantVector.push_back( atoi(tmp) );
		fscanf(pFile,"%s",tmp); // 6
		instantVector.push_back( atoi(tmp) );


		fscanf(pFile,"%s",tmp); // TypeContourModel
		fscanf(pFile,"%s",tmp); // ##
		typeContourModel = atoi(tmp);

		manModelContour =  kernelManager->factoryManualContourModel(typeContourModel);
		manModelContour->Open(pFile);

		fscanf(pFile,"%s",tmp); // TypeView
		fscanf(pFile,"%s",tmp); // ##
		typeView = atoi(tmp);  


//			if (typeView==1) 
//			{
//			}


		std::string theName;
		theName = kernelManager->createOutline( manModelContour, instantVector );
		bool addedModel = theName.compare("") != 0;
		if( addedModel )
		{
			double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
			_theViewPanel->getSpacing(spc);					
			//Adding the manualContourControler to interface objects structure
			//Adding the manualViewContour to interface objects structure		
			//_theViewPanel->getSceneManager()->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
			_theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc , typeView) ;
		}	

		if (staticContour==true)
		{
			Instant instant(&instantVector);
			kernelManager->changeContourOfManager( theName , &instant );
		}

	}// for  numberOfContours

}

void wxContourMainFrame::RefreshInterface(){
	changeInstant();
	_theViewPanel->RefreshInterface();
	//wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)this->_theViewPanel->getWxVtkBaseView();
	//wxvtk2dbaseview->Refresh();
}

vtkImageData* wxContourMainFrame::getImageData(){
	return _theViewPanel->getImageData();
}

void wxContourMainFrame::onSegmentationOneSlice(int isovalue,int sampling,int method){
	
	//JCP 20-10-08 Undo redo implementation
	saveState();
	//JCP 20-10-08 Undo redo implementation
	
	wxBusyCursor wait;
	int					x					= _theViewPanel->GetX();
	int					y					= _theViewPanel->GetY();
	int					z					= _theViewPanel->GetZ();
	SegmentationOneSlice( x,y,z,isovalue, sampling, method );
	RefreshInterface();
}

void wxContourMainFrame::SegmentationOneSlice( int x, int y, int z, int isovalue, int sampling, int method )
{		
	int typeofcontour = 1;
	//--Extracting Contour
	//vtkImageData	*imagedata	= _theViewPanel->getSceneManager()->GetImageData();
	vtkImageData	*imagedata	= getImageData();
//		double			*range		= imagedata->GetScalarRange();	
//		double			thr			= 1;

	vtkImageReslice *imageReslice = vtkImageReslice::New();
//EED
//		double spc[3];
//		imagedata->GetSpacing(spc);
//		x = x*spc[0];
//		y = y*spc[1];
//		z = z*spc[3];

	imageReslice->SetInput( imagedata );
	imageReslice->SetInformationInput(imagedata);
	imageReslice->SetResliceAxesDirectionCosines(1,0,0, 0,1,0 ,0,0,1);
	imageReslice->SetResliceAxesOrigin(0,0,z);
	imageReslice->SetOutputDimensionality(2);
	imageReslice->SetInterpolationModeToLinear();

	imagedata = imageReslice->GetOutput();
	imagedata->Update();
	imagedata->UpdateInformation();

	vtkContourFilter* cntVTK = vtkContourFilter::New( );
	cntVTK->SetInput( imagedata );

	cntVTK->SetNumberOfContours( 1 );
	//cntVTK->SetValue( 0, vmin );
//		cntVTK->SetValue( 0, (range[1]*thr/100) );
	cntVTK->SetValue( 1, isovalue );
//	cntVTK->SetValue( 1, vmax );
	cntVTK->Update( );
	cntVTK->UpdateInformation();
		
	vtkCleanPolyData* cpd = vtkCleanPolyData::New( );
	cpd->SetInput( cntVTK->GetOutput( ) );
	cpd->ConvertLinesToPointsOff( );
	cpd->Update( );
	cpd->UpdateInformation();

	vtkPolyDataConnectivityFilter* conn = vtkPolyDataConnectivityFilter::New( );
	conn->SetExtractionModeToClosestPointRegion( );
	//conn->SetMaxRecursionDepth( 3000 );
		
	conn->SetInput( cpd->GetOutput( ) );
		
	conn->SetClosestPoint( x, y, 0 );
	conn->Update( );
	conn->UpdateInformation();
		
	vtkCleanPolyData* cpd2 = vtkCleanPolyData::New( );
	cpd2->SetInput( conn->GetOutput( ) );
	cpd2->Update();
	cpd2->UpdateInformation();

	vtkStripper* vtkstripper = vtkStripper::New( );
	vtkstripper->SetInput( cpd2->GetOutput() );
	vtkstripper->Update();
	vtkstripper->UpdateInformation();


	vtkPolyData* polyDataResult =  vtkstripper->GetOutput();

	polyDataResult->Update( );
	polyDataResult->UpdateInformation();

/* EED
ofstream myfile;
myfile.open ("c:/temp/example.txt");
myfile << "\n";
polyDataResult->Print(myfile);
myfile << "-------------------------------------\n";
polyDataResult->GetLines()->Print(myfile);
myfile.close();
*/

	cntVTK		-> Delete();
	cpd2		-> Delete();
	cpd			-> Delete();
	conn		-> Delete();


//--Calculating control points

	std::vector<double> vecX;
	std::vector<double> vecY;
	std::vector<double> vecZ;

	std::vector<double> vecCtrlPointX;
	std::vector<double> vecCtrlPointY;
	std::vector<double> vecCtrlPointZ;


	double *p;
	int ii,size=polyDataResult->GetNumberOfPoints();
	int id;
	for (ii=1;ii<=size;ii++)
	{
		id	= polyDataResult->GetLines()->GetData()->GetValue(ii);
		p	= polyDataResult->GetPoint(id);
		double x=p[0];
		double y=p[1];
		vecX.push_back( p[0] );
		vecY.push_back( p[1] );
		vecZ.push_back( -900 );
//			vecZ.push_back( p[2] );
	}


	ExtractControlPoints2D *extractcontrolpoints2d = new ExtractControlPoints2D();
	extractcontrolpoints2d->SetContour( &vecX , &vecY , &vecZ );

//PROOFS
	/*if (methodRadiobox->GetSelection()==0){
		extractcontrolpoints2d->GetInitialControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
	}
	if (methodRadiobox->GetSelection()==1){
		extractcontrolpoints2d->GetControlPoints(  &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
	}
	if (methodRadiobox->GetSelection()==2){
		extractcontrolpoints2d->SetSamplingControlPoints( sampling );
		extractcontrolpoints2d->GetSamplingControlPoints(  &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
	}*/

	if (method==0){
		extractcontrolpoints2d->GetInitialControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
	}
	else if (method==1){
		extractcontrolpoints2d->GetControlPoints(  &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
	}
	else if (method==2){
		extractcontrolpoints2d->SetSamplingControlPoints( sampling );
		extractcontrolpoints2d->GetSamplingControlPoints(  &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
	}

	//--Adding contour to the system

	std::vector<int> actualInstantVector;
	_instantPanel->getInstant( actualInstantVector );
	actualInstantVector[1]=z;

	int j,sizeCtrPt = vecCtrlPointX.size();
	manualContourModel *manModelContour =  kernelManager->factoryManualContourModel( typeofcontour );
	manModelContour->SetNumberOfPointsSpline( ((sizeCtrPt/100)+1)*100 );
	if (sizeCtrPt>=3){
		for (j=0 ; j<sizeCtrPt ; j++)
		{
			manModelContour->AddPoint( vecCtrlPointX[j] , vecCtrlPointY[j] , vecCtrlPointZ[j]  );
		} // for
		std::string theName;
		//theName = _modelManager->createOutline( manModelContour, actualInstantVector );
		theName = kernelManager->createOutline( manModelContour, actualInstantVector );
		bool addedModel = theName.compare("") != 0;
		if( addedModel )
		{
			double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
			_theViewPanel->getSpacing(spc);					
			//Adding the manualContourControler to interface objects structure
			//Adding the manualViewContour to interface objects structure		
			//_theViewPanel->getSceneManager()->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
			_theViewPanel->configureViewControlTo(theName, manModelContour, spc, typeofcontour);
			//_theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc, typeofcontour ) ;
		}	// if addedModel
	} // if sizeCtrPt
}

int wxContourMainFrame::GetImageDataSizeZ(){
	return _theViewPanel->GetImageDataSizeZ();
}

void wxContourMainFrame::GetImageDataRange(double *range){
	_theViewPanel->GetImageDataRange(range);
}

void wxContourMainFrame::onSegmentationAllSlice(int minZ,int maxZ,int isovalue,int sampling,int method){
	//JCP 20-10-08 Undo redo implementation
	saveState();
	//JCP 20-10-08 Undo redo implementation
	
	wxBusyCursor wait;
	int					x					= _theViewPanel->GetX();
	int					y					= _theViewPanel->GetY();
	int z;
	double porcent; 
	wxString tmpString;	
	double totalZ = maxZ-minZ+1;
	for( z=minZ ; z<=maxZ ; z++ )
	{
		porcent = 100.0* (z-minZ)/totalZ;
		tmpString.Printf(_T("  %d %c            %d/%d            %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ,z );
		interfMainPanel::getInstance()->setLabelSegmentationPanelVTK(tmpString);
		//_staticTextSegmentation->SetLabel(tmpString);
		SegmentationOneSlice( x,y,z,isovalue, sampling,method );
	}
	interfMainPanel::getInstance()->setLabelSegmentationPanelVTK(_T("   "));
	RefreshInterface();
}

void wxContourMainFrame::showAxis(bool show){
	_theViewPanel->SetVisibleAxis(show);
	_theViewPanel->Refresh();
}


void wxContourMainFrame::onRigidPressed(){
	std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();
	int elementsSelected = currentSelection.size();

	if ( elementsSelected >= 1 ){
		//JCP 20-10-08 Undo redo implementation
		saveState();
		//JCP 20-10-08 Undo redo implementation

		std::vector<int> tempVector;
		_instantPanel->getInstant( tempVector );
		Instant instant(&tempVector);

		int i , size=currentSelection.size();
		for ( i=0 ; i<size ; i++ )
		{
			kernelManager->changeContourOfManager(currentSelection[i], &instant);
		} // i
	}
}

void wxContourMainFrame::onWidthOfContour(double width){

	_theViewPanel->removeSceneContours();
	_theViewPanel->SetWidthContour(width);
	
	//_theViewPanel->getSceneManager()->SetWidthContour( width );

	RefreshInterface();
}
int wxContourMainFrame::getColorWindow(){
	return _theViewPanel->getColorWindow();
}
int wxContourMainFrame::getWindowLevel(){
	return _theViewPanel->getWindowLevel();
}

void wxContourMainFrame::onBrigthnessColorWindowLevel(int colorwindow,int windowlevel){
	_theViewPanel->onBrigthnessColorWindowLevel(colorwindow, windowlevel);

	
	RefreshInterface();
}

void wxContourMainFrame::onInterpolation(bool interpolate){
	_theViewPanel->onInterpolation(interpolate);	
	RefreshInterface();
}

void wxContourMainFrame::onChangeInstant(std::string name,int actual){
	_instantPanel->setConceptValue( name, actual );
}

void wxContourMainFrame::resetAppend(){
	kernelManager->resetAppend();
	
}

void wxContourMainFrame::onSpreadAdd(){
	std::vector<double> vecX; 
	std::vector<double> vecY; 
	std::vector<double> vecZ; 
	_theViewPanel->GetPointsOfActualContour(&vecX , &vecY , &vecZ );
	
	std::vector<int> tempVector;
	_instantPanel->getInstant( tempVector );

	std::string val = kernelManager->onSpreadAdd(&vecX , &vecY , &vecZ, tempVector);

	interfMainPanel::getInstance()->appendStringSpread(val);
	
}

void wxContourMainFrame::onSpreadGo(int type){

	//JCP 20-10-08 Undo redo implementation
	saveState();
	//JCP 20-10-08 Undo redo implementation

	wxBusyCursor wait;	
	std::vector<double> vecCtrlPointX;
	std::vector<double> vecCtrlPointY;
	std::vector<double> vecCtrlPointZ;
	double  minZ,maxZ;
	int z;

	std::vector<int> tempVector;
	_instantPanel->getInstant( tempVector );
//		tempVector[1];

	kernelManager->getMaxMinZ(&minZ,&maxZ);
//JSTG_16-07-08_----------------------------------------------------------------
	//_contourPropagation->setInterpolationNumber(maxZ-minZ+1);
	kernelManager->CalculeSplinePropagation();

	double		totalZ = maxZ-minZ+1;
	double		porcent;
	wxString	tmpString;
//--------------------------------------------------------------------
	for ( z=(int)minZ ; z<=(int)maxZ ; z++ )
	{
		porcent = 100.0* (z-minZ)/totalZ;
		int numero = (int)(z-minZ+1)/(int)totalZ;
		std::string stringtemp = "  "+kernelManager->intToString(porcent)+"%            "+kernelManager->intToString(numero)+"            "+kernelManager->intToString(z);
		
		interfMainPanel::getInstance()->setStringSpread(stringtemp);	

		int typeofcontour = 1;
		std::string theName;
		manualContourModel* manModelContour = kernelManager->GetPoints(z, type, &vecCtrlPointX,&vecCtrlPointY,&vecCtrlPointZ, theName,typeofcontour, tempVector);

		if( manModelContour!=NULL ){
			double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
			this->_theViewPanel->getSpacing(spc);					
			//Adding the manualContourControler to interface objects structure
			//Adding the manualViewContour to interface objects structure		
			//_theViewPanel->getSceneManager()->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
			_theViewPanel->configureViewControlTo( theName, manModelContour,spc,typeofcontour ) ;
		} // if addedModel
	} 
	if(z > maxZ){
		porcent = 100.0;
		int numero = (int)(z-minZ+1)/(int)totalZ;
		std::string stringtemp = "  "+kernelManager->intToString(porcent)+"%            "+kernelManager->intToString(numero)+"            "+kernelManager->intToString(z);
		
		interfMainPanel::getInstance()->setStringSpread(stringtemp);
	}// for z
	//RefreshInterface();
}

void wxContourMainFrame::getInstantVector(std::vector<int>& tempVector){
	
}

std::vector<std::string> wxContourMainFrame::getOutlinesName(int slide){
	std::vector<int> tempVector;
	_instantPanel->getInstant(tempVector);
	//Asignation of slide number should be different ex by name
	tempVector[1]=slide;
	return kernelManager->getOutlinesNameAtInstant(tempVector);
}

void wxContourMainFrame::onInformationContourLabels(int typeContourGroup,int selection,int minimumZ,int maximumZ){
	int maxContourGroup	=	0;

	ContourExtractData	*contourextractdata = new ContourExtractData();
	
	contourextractdata ->SetTypeOperation( typeContourGroup % 3 );

	std::vector<manualContourModel*> lstManConMod;
	std::vector<manualContourModel*> lstManConModTmp;
	std::vector<manualContourModel*> lstManConModExp;
	std::vector<double> pLstValue;
	std::vector<double> pLstValuePosX;
	std::vector<double> pLstValuePosY;
	std::vector<double> pLstValuePosZ;

	int		resultSize; 
	int		resultGrayRangeCount;
	double	resultMin; 
	double	resultMax;
	double	resultAverage;
	double	resultStandardeviation;

	std::vector<int> tempVector;
	_instantPanel->getInstant( tempVector );

	vtkImageData *imagedata = _theViewPanel->getImageData();
	int sizeZ = _theViewPanel->GetImageDataSizeZ();
	int z;
	int ii,sizeLstContourThings;


	int minZ,maxZ;
	double totalZ;
	double porcent; 
	wxString tmpString;

	

	if (selection==0 ) // actual slice
	{
		std::vector<int> tempVector;
		_instantPanel->getInstant( tempVector );
		int actualSlice = tempVector[1];
		minZ	= actualSlice;
		maxZ	= actualSlice;
	}
	else if (selection==2 ) // All slices
	{
		minZ	= 0;
		maxZ	= sizeZ-1;
	}
	else if (selection==1 ) // slice range
	{
		minZ	= minimumZ;
		maxZ	= maximumZ;
	}
	

	totalZ	= maxZ-minZ+1;
	contourextractdata->SetImage( imagedata);

// For each slice..
	for ( z=minZ ; z<=maxZ ; z++ )
	{
		
		porcent = 100.0* (z-minZ)/totalZ;
		tmpString.Printf(_T("  %d %c            %d/%d             %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);

		interfMainPanel::getInstance()->setStringInfoPanel(tmpString);		
		//_staticTextInformation->SetLabel(tmpString);

		//Extraction data from contours of each slice
		contourextractdata->SetZtoBeAnalys( z);

		tempVector[1]=z;
		Instant instant(&tempVector);
		std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant( &instant );
		sizeLstContourThings = lstContourThings.size();

		lstManConMod.clear();
		for (ii=0 ; ii<sizeLstContourThings ; ii++)
		{
			ContourThing **contourthing = lstContourThings[ii];
			lstManConMod.push_back( (*contourthing)->getModel() );
		}
		lstManConModExp =  kernelManager->ExploseEachModel( lstManConMod );


		wxString tempString;
		tempString.Printf(_T("%d - %d"),z, sizeLstContourThings);
		interfMainPanel::getInstance()->setRowLabelInfoPanel(z, tempString);
		//_grid->SetRowLabelValue(z, tempString );
//EED004
		int iContourGroup,sizeContourGroup;
		if (typeContourGroup==3) // contour separete
		{
			sizeContourGroup=lstManConModExp.size();
			if ( maxContourGroup<sizeContourGroup ) 
			{
				maxContourGroup=sizeContourGroup;
			}
		} else {  // contour AND OR XOR
			sizeContourGroup=1;
			maxContourGroup=1;
		}

		int tmpIntA;



		for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
			lstManConModTmp.clear();
			if (typeContourGroup==3) // contour separete
			{
				lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
			} else {  // contour AND OR XOR
				lstManConModTmp = lstManConModExp;
			}

			contourextractdata->SetLstManualContourModel( lstManConModTmp );

			pLstValue.clear();
			pLstValuePosX.clear();
			pLstValuePosY.clear();
			pLstValuePosZ.clear();
			contourextractdata->GetValuesInsideCrown(	&pLstValue,
														&pLstValuePosX,
														&pLstValuePosY,
														&pLstValuePosZ);
			// Statistics of each slice.
			contourextractdata->Statistics( &pLstValue,
											minimumZ,
											maximumZ,
											&resultGrayRangeCount, 
											&resultSize, 
											&resultMin, 
											&resultMax,
											&resultAverage,
											&resultStandardeviation);
			
			if (interfMainPanel::getInstance()->getNumberColsInformationPanel()<_numberOfVariablesStatistics*(iContourGroup+1)  )
			{
				interfMainPanel::getInstance()->appendColsInformationPanel(_numberOfVariablesStatistics);
			}

			tmpIntA=_numberOfVariablesStatistics*iContourGroup ;

			tempString.Printf(_T("%d"),resultSize);
			interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA, tempString);	

			tempString.Printf(_T("%d"),resultGrayRangeCount);
			interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+1, tempString);
			
			tempString.Printf(_T("%f"),resultMin);
			interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+2, tempString);
			
			tempString.Printf(_T("%f"),resultMax);
			interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+3, tempString);
			
			tempString.Printf(_T("%f"),resultAverage);
			interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+4, tempString);
			
			tempString.Printf(_T("%f"),resultStandardeviation);
			interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+5, tempString);
			

		} // for iContourGroup
	} // for z

	int iTitleGroup;
	wxString tmpTitleString;
	int tmpIntB;
	for ( iTitleGroup=0 ; iTitleGroup<maxContourGroup ; iTitleGroup++ )
	{
		tmpIntB =_numberOfVariablesStatistics*iTitleGroup;
		tmpTitleString.Printf(_T("%d-Size Data"),iTitleGroup);
		interfMainPanel::getInstance()->setColLableInfoPanel(tmpIntB + 0, tmpTitleString);

		interfMainPanel::getInstance()->setColLableInfoPanel(tmpIntB + 0, tmpTitleString );
		interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 1, _T("Size Range") );
		interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 2, _T("Min") );
		interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 3, _T("Max") );
		interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 4, _T("Average") );
		interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 5, _T("St.Dev.") );
		interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 6, _T(" ") );
	}

	interfMainPanel::getInstance()->setStringInfoPanel( _T("") );
	delete contourextractdata;
}

void wxContourMainFrame::onSaveResults(std::string directory,std::string namefile, std::string filename, int typeContourGroup){
    SaveValuesXYZ( directory , namefile, typeContourGroup );
	SaveImageResult( directory , namefile, typeContourGroup);

	
	FILE *pFile=fopen(filename.c_str(),"w+");

	int sizeZ = _theViewPanel->GetImageDataSizeZ();

	wxString tmpString;
	int i,j,maxX,maxY=sizeZ;
	maxX= interfMainPanel::getInstance()->getNumberColsInformationPanel();//this->_grid->GetNumberCols();

	int iTitle,sizeTitle = (maxX / _numberOfVariablesStatistics);
	for ( iTitle=0; iTitle<sizeTitle ; iTitle++)
	{
		fprintf(pFile,"-- \t %d-Size \t SizeRange \t Min \t Max \t Ave \t StDv \t" , iTitle,tmpString.c_str() );
	}
	fprintf(pFile,"\n" );



	for ( j=0; j<maxY ; j++)
	{
		fprintf(pFile,"%d\t" , j );
		for (i=0 ; i<maxX ; i++){
			tmpString = interfMainPanel::getInstance()->getCellValue(j, i);//_grid->GetCellValue( j , i );
			fprintf(pFile,"%s\t" , (const char *)(tmpString.mb_str()) );
		} // for i
		fprintf(pFile,"\n"  );
	} // for j

	fclose(pFile);
}

void wxContourMainFrame::SaveValuesXYZ(std::string directory,std::string namefile,int typeContourGroup)
{
	wxBusyCursor wait;
	ContourExtractData	*contourextractdata = new ContourExtractData();
	//int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
	contourextractdata ->SetTypeOperation( typeContourGroup % 3 );

	std::vector<manualContourModel*> lstManConMod;
	std::vector<manualContourModel*> lstManConModTmp;
	std::vector<manualContourModel*> lstManConModExp;
	std::vector<double> pLstValue;
	std::vector<double> pLstValuePosX;
	std::vector<double> pLstValuePosY;
	std::vector<double> pLstValuePosZ;

	std::vector<int> tempVector;
	_instantPanel->getInstant( tempVector );

	vtkImageData *imagedata = _theViewPanel->getSceneManager()->GetImageData();
	int sizeZ = _theViewPanel->getSceneManager()->GetImageDataSizeZ();
	int z;
	int ii,sizeLstContourThings;


	int minZ,maxZ;
	double totalZ;
	double porcent; 
	wxString tmpString;
	minZ	= 0;// _mbarrange->GetStart();
	maxZ	= sizeZ;//_mbarrange->GetEnd();
	totalZ	= maxZ-minZ+1;

	contourextractdata->SetImage( imagedata);

// For each slice..
	for ( z=0 ; z<sizeZ ; z++)
	{

		porcent = 100.0* (z-minZ)/totalZ;
		
		tmpString.Printf(_T("Saving Values"));
		tmpString.Printf(_T("  %d %c            %d/%d             %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
		interfMainPanel::getInstance()->setStringInfoPanel(tmpString);
		//_staticTextInformation->SetLabel(tmpString);


		//Extraction data from contours of each slice
		contourextractdata->SetZtoBeAnalys( z);

		tempVector[1]=z;
		Instant instant(&tempVector);
		std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant(&instant);//this->_modelManager->getOutlinesAtInstant( &instant );
		sizeLstContourThings = lstContourThings.size();

		lstManConMod.clear();
		for (ii=0 ; ii<sizeLstContourThings ; ii++)
		{
			ContourThing **contourthing = lstContourThings[ii];
			lstManConMod.push_back( (*contourthing)->getModel() );
		}
		lstManConModExp =  kernelManager->ExploseEachModel( lstManConMod );


//EED004

		int iContourGroup,sizeContourGroup;
		if (typeContourGroup==3) // contour separete
		{
			sizeContourGroup=lstManConModExp.size();
		} else {  // contour AND OR XOR
			sizeContourGroup=1;
		}

		for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
			lstManConModTmp.clear();
			if (typeContourGroup==3) // contour separete
			{
				lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
			} else {  // contour AND OR XOR
				lstManConModTmp = lstManConModExp;
			}

			contourextractdata->SetLstManualContourModel( lstManConModTmp );

			pLstValue.clear();
			pLstValuePosX.clear();
			pLstValuePosY.clear();
			pLstValuePosZ.clear();
			contourextractdata->GetValuesInsideCrown(	&pLstValue,
														&pLstValuePosX,
														&pLstValuePosY,
														&pLstValuePosZ);

			std::string temp = directory + "/" + namefile + "-slice";
			temp = temp + kernelManager->intToString(z) + "-cont" + kernelManager->intToString(iContourGroup);
			temp = temp + ".txt";

			// LG 14/01/09 : using crea
			wxString filename = crea::std2wx(temp);
			/*filename.Printf(_T("%s"),directory.c_str());
			filename.append(_T("\\"));
			filename.append(_T("%s"),namefile.c_str());
			filename.append(_T("-slice"));
			filename.append(_T("%d"),z);
			filename.append(_T("-cont"));
			filename.append(_T("%d"),iContourGroup);
			filename.append(_T(".txt"));*/
			//			filename.Printf(temp.c_str());

			

			FILE *pFile=fopen((const char *)filename.mb_str(),"w+");
			fprintf(pFile,"value \t x \t y \t z\n"  );
			int iLstValue,sizeLstValue=pLstValue.size();
			for (iLstValue=0 ; iLstValue<sizeLstValue ; iLstValue++ )
			{
				fprintf(pFile,"%f\t %f\t %f\t %f\n", (float)pLstValue[iLstValue] , (float)pLstValuePosX[iLstValue], (float)pLstValuePosY[iLstValue], (float)z );
			}
			fclose(pFile);
		} // for  iContourGroup
	} // for z
	interfMainPanel::getInstance()->setStringInfoPanel(_T(""));
	//_staticTextInformation->SetLabel( _T("") );
	delete contourextractdata;
}

void wxContourMainFrame::SaveImageResult(std::string directory,std::string namefile, int typeContourGroup)
{
	wxBusyCursor wait;
	ContourExtractData	*contourextractdata = new ContourExtractData( true );
	//int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
	if (typeContourGroup==3)
	{
		typeContourGroup=1;
	}
	contourextractdata ->SetTypeOperation( typeContourGroup % 3 );

	std::vector<manualContourModel*> lstManConMod;
	std::vector<manualContourModel*> lstManConModTmp;
	std::vector<manualContourModel*> lstManConModExp;

	std::vector<int> tempVector;
	_instantPanel->getInstant( tempVector );

	vtkImageData *imagedata = _theViewPanel->getImageData();
	int sizeZ = _theViewPanel->GetImageDataSizeZ();
	int z;
	int ii,sizeLstContourThings;


	int minZ,maxZ;
	double totalZ;
	double porcent; 

	wxString tmpString;

	minZ	= 0;// _mbarrange->GetStart();
	maxZ	= sizeZ;//_mbarrange->GetEnd();
	totalZ	= maxZ-minZ+1;

	contourextractdata->SetImage( imagedata);

// For each slice..
	for ( z=0 ; z<sizeZ ; z++)
	{

		porcent = 100.0* (z-minZ)/totalZ;
		tmpString.Printf(_T("Saving Values"));
		tmpString.Printf(_T("%d %c            %d/%d             %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
		interfMainPanel::getInstance()->setStringInfoPanel(tmpString);

		//Extraction data from contours of each slice
		contourextractdata->SetZtoBeAnalys( z);

		tempVector[1]=z;
		Instant instant(&tempVector);
		std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant( &instant );
		sizeLstContourThings = lstContourThings.size();

		lstManConMod.clear();
		for (ii=0 ; ii<sizeLstContourThings ; ii++)
		{
			ContourThing **contourthing = lstContourThings[ii];
			lstManConMod.push_back( (*contourthing)->getModel() );
		}
		lstManConModExp =  kernelManager->ExploseEachModel( lstManConMod );


		int iContourGroup,sizeContourGroup;
		if (typeContourGroup==3) // contour separete
		{
			sizeContourGroup=lstManConModExp.size();
		} else {  // contour AND OR XOR
			sizeContourGroup=1;
		}

		for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
			lstManConModTmp.clear();
			if (typeContourGroup==3) // contour separete
			{
				lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
			} else {  // contour AND OR XOR
				lstManConModTmp = lstManConModExp;
			}

			contourextractdata->SetLstManualContourModel( lstManConModTmp );


//				for (ii=0 ; ii<sizeLstContourThings ; ii++)
//				{
//					ContourThing **contourthing = lstContourThings[ii];
//					lstManConMod.push_back( (*contourthing)->getModel() );
//				}
//				contourextractdata->SetLstManualContourModel( lstManConMod );

			contourextractdata->CalculateImageResult(); // with actual Z

		} // for  iContourGroup
	} // for z

	std::string temp = directory + "/" + namefile + "-Value.mhd";

	wxString filename = crea::std2wx(temp);
	// LG 
	//	filename.Printf(_T(temp.c_str()));
	//filename.Printf(_T("%s\\%s-Value.mhd",directory.c_str(),namefile.c_str(),z);
	/*filename.Printf(_T("%s"),directory.c_str());
	filename.append(_T("\\"));
	filename.append(_T("%s"),namefile.c_str());
	filename.append(_T("-Value.mhd"));*/

// Image Value
	vtkMetaImageWriter *writerValueImage = vtkMetaImageWriter::New( );
	writerValueImage->SetInput( contourextractdata->GetVtkImageValueResult() );
	writerValueImage->SetFileName( (const char *)filename.mb_str() );
	writerValueImage->SetFileDimensionality( 3 );
	writerValueImage->Write( );

// Image Mask
	//		filename.Printf("%s\\%s-Mask.mhd",directory.c_str(),namefile.c_str(),z);
	temp = directory + "/" + namefile + "-Mask.mhd";

	// LG 14/01/09 : using crea
	filename = crea::std2wx(temp);
	//	filename.Printf(_T(temp.c_str()));

	/*filename.Printf(_T("%s"),directory.c_str());
	filename.append(_T("\\"));
	filename.append(_T("%s"),namefile.c_str());
	filename.append(_T("-Mask.mhd"));*/

	vtkMetaImageWriter *writerMaskImage = vtkMetaImageWriter::New( );
	writerMaskImage->SetInput( contourextractdata->GetVtkImageMaskResult() );
	writerMaskImage->SetFileName( (const char *)filename.mb_str() );
	writerMaskImage->SetFileDimensionality( 3 );
	writerMaskImage->Write( );

	interfMainPanel::getInstance()->setStringInfoPanel( _T("") );
	delete contourextractdata;
}

void wxContourMainFrame::onChangeInstantInstantPanel(std::string name,int value, int minshow, int maxshow){
	if( name.compare( _theViewPanel->getVerticalConceptName() ) == 0){
		_theViewPanel->setActualVertical( value);
	}
	else if( name.compare( _theViewPanel->getHorizontalConceptName() ) == 0|| _instantPanel->getIfConceptCheckedAt( name, 0 ) )	{
		_theViewPanel->setHorizontalConcept( name, minshow, maxshow, minshow, maxshow, value);
	}

	changeInstant();
}

void wxContourMainFrame::onSnakePressed(){
	std::vector<double> vecX; 
	std::vector<double> vecY; 
	std::vector<double> vecZ; 
	_theViewPanel->GetPointsOfActualContour( &vecX , &vecY , &vecZ );	

	if (vecX.size()!=0){
		std::vector<int> tempVector;
		_instantPanel->getInstant( tempVector );
		int i,size=vecZ.size();
		int actualSlice = tempVector[1];
		for ( i=0 ; i<size ; i++ )
		{
			vecZ[i] = actualSlice;
		} // for

		wxDialog* dialog = new wxDialog(this, -1, wxString(_T("Snake")));
		wxPanel* panel = new wxPanel(dialog,-1); 
		wxStaticText* sttext = new wxStaticText(panel, -1, wxString(_T("Panel para snake")));
		dialog->ShowModal();
	} // if 

}