lib/Interface_ManagerContour_NDimensions/wxContourMainFrame.cxx

   1 /*# ---------------------------------------------------------------------
   2 #
   3 # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
   4 #                        pour la Sant�)
   5 # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
   6 # Previous Authors : Laurent Guigues, Jean-Pierre Roux
   7 # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
   8 #
   9 #  This software is governed by the CeCILL-B license under French law and
  10 #  abiding by the rules of distribution of free software. You can  use,
  11 #  modify and/ or redistribute the software under the terms of the CeCILL-B
  12 #  license as circulated by CEA, CNRS and INRIA at the following URL
  13 #  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  14 #  or in the file LICENSE.txt.
  15 #
  16 #  As a counterpart to the access to the source code and  rights to copy,
  17 #  modify and redistribute granted by the license, users are provided only
  18 #  with a limited warranty  and the software's author,  the holder of the
  19 #  economic rights,  and the successive licensors  have only  limited
  20 #  liability.
  21 #
  22 #  The fact that you are presently reading this means that you have had
  23 #  knowledge of the CeCILL-B license and that you accept its terms.
  24 # ------------------------------------------------------------------------ */
  25
  26 //----------------------------------------------------------------------------------------------------------------
  27 // Class definition include
  28 //----------------------------------------------------------------------------------------------------------------
  29 #include "wxContourMainFrame.h"
  30
  31
  32
  33 //----------------------------------------------------------------------------------------------------------------
  34 // Includes
  35 //----------------------------------------------------------------------------------------------------------------
  36
  37
  38 #include "NameWrapper.h"
  39 #include "wx/artprov.h"
  40 #include "ConceptDataWrap.h"
  41 #include <creaWx.h>
  42
  43 #include <string>
  44 using namespace std;
  45
  46 //----------------------------------------------------------------------------------------------------------------
  47 // Class implementation
  48 //----------------------------------------------------------------------------------------------------------------
  49 /** @file wxContourMainFrame.cxx */
  50
  51         //------------------------------------------------------------------------------------------------------------
  52         // Constructors & Destructors
  53         //------------------------------------------------------------------------------------------------------------
  54
  55 wxContourMainFrame* wxContourMainFrame:: instance = NULL;
  56 char wxContourMainFrame::COPY = 'C';
  57
  58         wxContourMainFrame :: wxContourMainFrame(wxWindow* parent, wxWindowID id,const wxString& title,const wxPoint& pos,const wxSize& size,long style)
  59                 //: wxPanel(parent, id, title, pos, size, style)
  60                 //: wxWindow(parent, id, pos, size, style)
  61                 : wxPanel(parent, id, pos, size, style)
  62         {
  63                 m_mgr.SetManagedWindow(this);
  64                 _contourGroup                           = 1;
  65                 _creatingContoursActive         = false;
  66                 _theViewPanel                           = NULL;
  67 //              _modelManager                           = NULL;
  68                 _instantPanel                           = NULL;
  69 //              _buttonsBar                                     = NULL;
  70 //              _gridPanel                                      = NULL;
  71 //              _drawToolsPanel                         = NULL;
  72 //              _operationsToolsPanel           = NULL;
  73                 //_autoFormsPanel                               = NULL;
  74 //              _standardToolsPanel                     = NULL;
  75 //              _editionToolsPanel                      = NULL;
  76 //              _listViewPanel                          = NULL;
  77 //              _sceneManager                           = NULL;
  78                 //_actualInstant                                = NULL;
  79                 _numberOfVariablesStatistics = 6+1;
  80
  81                 _refLineControl                         = NULL;
  82                 _refLineModel                           = NULL;
  83                 _refLineView                            = NULL;
  84 //              _actorPresent                           = false;
  85
  86                 // set up default notebook style
  87 //              m_notebook_style =wxAUI_NB_TAB_SPLIT | wxAUI_NB_TAB_EXTERNAL_MOVE | wxNO_BORDER;
  88 //              m_notebook_theme = 0;
  89                 //wxContour_ActionCommandsID a;
  90
  91                 _contourextractdata                     = NULL;
  92                 _viewMaskImage                          = NULL;
  93                 _viewMaskImagePanel                     = NULL;
  94                 _viewThresholdImage                     = NULL;
  95                 _viewThresholdImagePanel        = NULL;
  96                 _viewColorLayerImage            = NULL;
  97                 _viewColorLayerImagePanel       = NULL;
  98         }
  99
 100         wxContourMainFrame :: wxContourMainFrame(wxWindow* parent, wxWindowID id,const wxString& title,const wxPoint& pos,const wxSize& size,std::vector<vtkImageData*> images, long style,std::string datadir)
 101                 : wxPanel(parent, id, pos, size, style)
 102         {
 103                 m_mgr.SetManagedWindow(this);
 104                 _contourGroup                           = 1;
 105                 _creatingContoursActive         = false;
 106                 _theViewPanel                           = NULL;
 107
 108                 _instantPanel                           = NULL;
 109                 _refLineControl                         = NULL;
 110                 _refLineModel                           = NULL;
 111                 _refLineView                            = NULL;
 112 //              _actorPresent                           = false;
 113                 _viewMaskImage                          = NULL;
 114                 _viewMaskImagePanel                     = NULL;
 115                 _viewThresholdImage                     = NULL;
 116                 _viewThresholdImagePanel        = NULL;
 117                 _viewColorLayerImage            = NULL;
 118                 _viewColorLayerImagePanel       = NULL;
 119
 120                 // set up default notebook style
 121                 m_notebook_style =wxAUI_NB_TAB_SPLIT | wxAUI_NB_TAB_EXTERNAL_MOVE | wxNO_BORDER;
 122                 m_notebook_theme = 0;
 123                 //wxContour_ActionCommandsID a;
 124                 _numberOfVariablesStatistics = 7;
 125
 126                 _datadir = datadir;
 127
 128
 129                 inredo = 0;
 130                 inundo = 0;
 131
 132                 _pannew = interfMainPanel::getInstance(this,datadir+"/data/Icons");//, eventHandler);
 133                 _performingOperation = new PerformingOperation();
 134
 135                 if(images.size() > 0)
 136                 {
 137                         this->setVectImages(images);
 138                 }
 139
 140                 _contourextractdata                     = NULL;
 141 }
 142
 143 void wxContourMainFrame::setVectImages(std::vector<vtkImageData*> imgs)
 144 {
 145
 146         _images = imgs;
 147
 148         #if defined(__GNUC__)
 149                 std::string str_home(getenv("HOME"));
 150         #elif defined(_WIN32)
 151                         std::string str_home(getenv("USERPROFILE"));
 152         #endif
 153                 std::string strCreaContourDataTmp = str_home + "/.creaContourDataTemp/";
 154
 155         std::vector<std::string> conceptNameVect;
 156         std::vector<int> conceptSizeVect;
 157
 158         notebook = this->createNotebook();
 159
 160
 161         kernelManager = new KernelManagerContour( imgs , _datadir+"/data/" , strCreaContourDataTmp );
 162
 163
 164         _instantPanel                           = new wxInstantChooserPanel( notebook, "Instant Chooser", true, false, "c" );
 165         _theViewPanel                           = new wxContourViewPanel( kernelManager->getSourceImage(), notebook );
 166
 167 //-------------------------------------------------------------
 168         kernelManager->getConceptsInformation(conceptNameVect, conceptSizeVect);
 169         _instantPanel->addConcepts(conceptNameVect, conceptSizeVect);
 170
 171
 172         double val = _theViewPanel->getCurrentDeep();
 173         _instantPanel->setConceptValue( "Axe Depth", (int)val );
 174         //JCP _instantPanel->setConceptValue("time", num de imagenes);
 175         ConceptDataWrap * data = _instantPanel->getConceptDataOf( "Axe Depth" );
 176         //*******************changeInstant();
 177         _theViewPanel->setVerticalConcept( "Axe Depth", data->getMinValue(), data->getMaxValue(), data->getMinShowedValue(),  data->getMaxShowedValue(), data->getActualValue() );
 178
 179         this->configurePanels( );
 180
 181 }
 182
 183
 184         wxContourMainFrame* wxContourMainFrame :: getInstance(wxWindow* parent, wxWindowID id,const wxString& title,const wxPoint& pos,const wxSize& size,std::vector<vtkImageData*> images, long style,std::string datadir )
 185         {
 186                 if(instance == NULL){
 187                         instance = new wxContourMainFrame(parent, id, title, pos, size, images, style,datadir);
 188                 }
 189                 return instance;
 190         }
 191
 192         std::vector<vtkImageData*> wxContourMainFrame ::getVectImages()
 193         {
 194                 return kernelManager->getVectImages();
 195         }
 196
 197         wxContourMainFrame* wxContourMainFrame :: getInstance()
 198         {
 199                 return instance;
 200         }
 201
 202         void wxContourMainFrame :: resetInstance()
 203         {
 204                 instance->Destroy();
 205         }
 206
 207         wxContourMainFrame :: ~wxContourMainFrame()
 208         {
 209                 delete _contourextractdata;
 210                 deleteAllContours();
 211                 _pannew->Close();
 212                 interfMainPanel::resetInstance();
 213                 delete kernelManager;
 214                 instance = NULL;
 215                 //_pannew->Destroy();
 216                 //delete _pannew;
 217
 218                 m_mgr.UnInit();
 219                 //delete m_mgr;
 220
 221                 //El problema al cerrar la aplicacion puede estar asociado
 222                 //a que  wxAUINotebook esta en la aplicacion
 223                 //principal (wxContourGUIExample)tambien
 224                 //EED????               delete _theViewPanel;
 225                 //EED????               delete _instantPanel;
 226                 //EED????               delete _buttonsBar;
 227                 //EED????               delete _actualInstant;
 228                 //EED????               delete _sceneManager;
 229         }
 230
 231
 232         //------------------------------------------------------------------------------------------------------------
 233         // Creational and initialization methods using WxAui
 234         //------------------------------------------------------------------------------------------------------------
 235         //
 236         wxAuiNotebook * wxContourMainFrame :: createNotebook()
 237         {
 238                 wxSize client_size = GetClientSize();
 239                 wxAuiNotebook* noteBook = new wxAuiNotebook(this, -1, wxPoint(client_size.x, client_size.y), wxSize(430,200), m_notebook_style);
 240                 wxBitmap page_bmp = wxArtProvider::GetBitmap(wxART_NORMAL_FILE, wxART_OTHER, wxSize(16,16));
 241                 return noteBook;
 242         }
 243
 244
 245         //------------------------------------------------------------------------------------------------------------
 246         // Creational and initialization methods
 247         //------------------------------------------------------------------------------------------------------------
 248         bool wxContourMainFrame :: configurePanels( )
 249         {
 250                 bool configured = _theViewPanel!=NULL;
 251
 252                 configured &= _theViewPanel!=NULL;
 253                 if( _theViewPanel!=NULL )
 254                 {
 255                         notebook->AddPage( _theViewPanel, wxT("       View       ") );
 256                         m_mgr.Update();
 257                 }
 258
 259
 260                 if( configured )
 261                 {
 262                         notebook->AddPage( _instantPanel, wxT("Instant Page") );
 263                         m_mgr.Update();
 264                 }
 265
 266                 m_mgr.AddPane(notebook, wxAuiPaneInfo().Name(wxT("notebook_content")).CenterPane().PaneBorder(false));
 267                 m_mgr.Update();
 268
 269                 SetMinSize(wxSize(300,300));
 270                 m_mgr.Update();
 271                 return configured;
 272         }
 273
 274
 275         bool wxContourMainFrame::addNewPanel(wxPanel* panel)
 276                 {
 277                 bool configured = panel!=NULL;
 278                 configured &= panel!=NULL;
 279
 280                 if( configured )
 281                 {
 282                         notebook->AddPage( panel, wxT("       Viewer       "), true );
 283                         m_mgr.Update();
 284                 }
 285                 return configured;
 286         }
 287
 288         //------------------------------------------------------------------------------------------------------------
 289         //  Attributes getters and setters
 290         //------------------------------------------------------------------------------------------------------------
 291
 292
 293
 294         void wxContourMainFrame :: setInstantChooserPanel(  wxInstantChooserPanel * theInstantChooserPanel )
 295         {
 296                 _instantPanel = theInstantChooserPanel;
 297         }
 298
 299 //      void wxContourMainFrame :: setButtonsBar(  wxContour_ButtonsBar * theButtonsBar )
 300 //      {
 301 //              _buttonsBar = theButtonsBar;
 302 //      }
 303
 304 //      void wxContourMainFrame :: setGrid(  wxContour_Grid * theGridPanel )
 305 //      {
 306 //              _gridPanel = theGridPanel;
 307 //      }
 308
 309 //      void wxContourMainFrame :: setDrawToolsPanel(  wxContour_DrawToolsPanel * theDrawToolsPanel )
 310 //      {
 311 //              _drawToolsPanel = theDrawToolsPanel;
 312 //      }
 313
 314 //      void wxContourMainFrame :: setOperationsToolsPanel(  wxContour_OperationsToolsPanel * theOperationsToolsPanel )
 315 //      {
 316 //              _operationsToolsPanel = theOperationsToolsPanel;
 317 //      }
 318
 319 //      void wxContourMainFrame :: setAutomaticFormsPanel(  wxContour_AutomaticFormsToolsPanel * theAutoFormsPanel )
 320 //      {
 321 //              _autoFormsPanel = theAutoFormsPanel;
 322 //      }
 323
 324 //      void wxContourMainFrame :: setStandardToolsPanel(  wxContour_StandardToolsPanel * theStandardToolsPanel )
 325 //      {
 326 //              _standardToolsPanel= theStandardToolsPanel;
 327 //      }
 328
 329 //      void wxContourMainFrame :: setEditionToolsPanel(  wxContour_EdtionToolsPanel * theEditionToolsPanel )
 330 //      {
 331 //              _editionToolsPanel =  theEditionToolsPanel;
 332 //      }
 333
 334 //      void wxContourMainFrame :: setListViewPanel(  wxContour_ListViewPanel * theListViewPanel )
 335 //      {
 336 //              _listViewPanel = theListViewPanel;
 337 //      }
 338
 339
 340
 341 void wxContourMainFrame::onCreateContourSpline( ){
 342
 343         //JCP 20-10-08 Undo redo implementation
 344         saveState();
 345         //JCP 20-10-08 Undo redo implementation
 346         createContour( 1 );
 347
 348 }
 349 void wxContourMainFrame::onCreateContourRectangle( ){
 350     //JCP 20-10-08 Undo redo implementation
 351         saveState();
 352         //JCP 20-10-08 Undo redo implementation
 353         createContour( 2 );
 354 }
 355 void wxContourMainFrame::onCreateContourCircle( ){
 356     //JCP 20-10-08 Undo redo implementation
 357         saveState();
 358         //JCP 20-10-08 Undo redo implementation
 359         createContour( 3 );
 360 }
 361
 362 void wxContourMainFrame::onCreateContourLine( ){
 363     //JCP 20-10-08 Undo redo implementation
 364         saveState();
 365         //JCP 20-10-08 Undo redo implementation
 366         createContour( 6 );
 367 }
 368
 369 // RaC 09-09 --------------------------------------
 370 void wxContourMainFrame::onCreateContourPoints( ){
 371     //JCP 20-10-08 Undo redo implementation
 372         saveState();
 373         //JCP 20-10-08 Undo redo implementation
 374         createContour( 7 );
 375 }
 376 // RaC 09-09 --------------------------------------
 377
 378 // RaC 10-09 --------------------------------------
 379 void wxContourMainFrame::onCreateContourPolygon( ){
 380     //JCP 20-10-08 Undo redo implementation
 381         saveState();
 382         //JCP 20-10-08 Undo redo implementation
 383         createContour( 10 );
 384 }
 385 // RaC 10-09 --------------------------------------
 386
 387 //------------------------------------------------------------------------------------------------------------
 388
 389 void wxContourMainFrame :: onCreateContourBullEye(wxPanel* panel )
 390 {
 391         //Creating the manualBaseModel and including in the model
 392         manualBaseModel * manModelContour = factoryManualContourModel(panel );
 393
 394         std::vector<int> instantVector;
 395         _instantPanel->getInstant( instantVector );
 396         std::string theName = kernelManager->createOutline(manModelContour, instantVector);
 397
 398         /*std::vector<int> instantVector;
 399         _instantPanel->getInstant( instantVector );
 400         std::string theName;
 401         theName= _modelManager->createOutline( manModelContour, instantVector );*/
 402         bool addedModel = theName.compare("") != 0;//??
 403
 404         if( addedModel )
 405         {
 406                 double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
 407                 _theViewPanel->getSpacing(spc);
 408                 //Adding the manualContourControler to interface objects structure
 409                 //Adding the manualViewContour to interface objects structure
 410                 //_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.
 411                 _theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc , 4) ;
 412         }
 413 }
 414 void wxContourMainFrame :: createContour( int typeContour )
 415 {
 416         //Creating the manualContourModel and including in the model
 417         manualBaseModel * manModelContour = kernelManager->factoryManualContourModel(typeContour);
 418
 419         std::vector<int> instantVector;
 420         _instantPanel->getInstant( instantVector );
 421         std::string theName = kernelManager->createOutline(manModelContour, instantVector);
 422
 423         /*std::vector<int> instantVector;
 424         _instantPanel->getInstant( instantVector );
 425         std::string theName;
 426         theName= _modelManager->createOutline( manModelContour, instantVector );*/
 427         bool addedModel = theName.compare("") != 0;//??
 428         if( addedModel )
 429         {
 430                 double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
 431                 _theViewPanel->getSpacing(spc);
 432                 //Adding the manualContourControler to interface objects structure
 433                 //Adding the manualViewContour to interface objects structure
 434                 //_sceneManager->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
 435                 _theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc , typeContour) ;
 436         }
 437
 438 }
 439 manualBaseModel * wxContourMainFrame::factoryManualContourModel(wxPanel* panel){
 440
 441         manualContourModelBullEye *manModelContourBullEye = new manualContourModelBullEye();
 442         manualBaseModel *manModelContour=NULL;
 443         manModelContour = manModelContourBullEye;
 444         if (panel!=NULL){
 445                 int iCrown,sizeCrowns,iSector,sizeSectors;
 446                 double radioA,radioB,ang,angDelta ;
 447                 sizeCrowns = ((PanelBullEyeOptions*)panel)->GetNumberOfCrowns();
 448                 for ( iCrown=0 ; iCrown<sizeCrowns ; iCrown++ )
 449                 {
 450                         sizeSectors = ((PanelBullEyeOptions*)panel)->GetNumberOfSections(iCrown);
 451                         radioB  = ((PanelBullEyeOptions*)panel)->GetRadioOfCrown(iCrown);
 452                         if (iCrown==sizeCrowns-1)
 453                         {
 454                                 radioA  = 0;
 455                         } else {
 456                                 radioA  = ((PanelBullEyeOptions*)panel)->GetRadioOfCrown(iCrown+1);
 457                         }
 458                         radioA=radioA/100.0;
 459                         radioB=radioB/100.0;
 460                         for ( iSector=0 ; iSector<sizeSectors  ; iSector++ )
 461                         {
 462                                 ang             = ((PanelBullEyeOptions*)panel)->GetAngOfCrownSection(iCrown,iSector);
 463                                 angDelta= ((PanelBullEyeOptions*)panel)->GetAngDeltaOfCrownSection(iCrown);
 464                                 manModelContourBullEye->AddSector(radioA,radioB,ang,angDelta);
 465                         } // for iSector
 466                 } // for iCrown
 467         } // if _panelBullEyeOptions
 468
 469         return manModelContour;
 470 }
 471 void wxContourMainFrame :: saveState(){
 472
 473         std::string temp = kernelManager->saveState();
 474         saveFileWithContours(temp);
 475 }
 476
 477 void wxContourMainFrame::onDeleteContour(){
 478         //JCP 20-10-08 Undo redo implementation
 479                 saveState();
 480                 //JCP 20-10-08 Undo redo implementation
 481
 482                 std::vector<std::string> lstKeyNameToBeErase;
 483                 lstKeyNameToBeErase             = _theViewPanel->getSceneManager()->getSelectedObjects();
 484                 deleteContours( lstKeyNameToBeErase );
 485 /*JCP 19 - 11 - 08
 486                 int i,size=_sceneManager->getSelectedObjects().size();
 487                 for(i=0;i<size;i++)
 488                 {
 489                         std::string keyName             = _sceneManager->getSelectedObjects()[i];
 490                         int ispartofstaticlist  = this->_modelManager->IsPartOfStaticList( keyName );
 491                         if ( ispartofstaticlist>=0 )
 492                         {
 493                                 std::vector<int> tempVector;
 494                                 _instantPanel->getInstant( tempVector );
 495                                 Instant instant(&tempVector);
 496                                 this->_modelManager->ChangeContourOfList(keyName, &instant);
 497                         }
 498                 }
 499
 500                 std::vector<std::string> lstKeyName;
 501                 std::vector<std::string> lstKeyNameActualSlice;
 502                 std::vector<std::string> lstKeyNameToBeErase;
 503
 504                 lstKeyNameToBeErase             = _sceneManager->getSelectedObjects();
 505                 lstKeyNameActualSlice   = _sceneManager->GetlstContoursNameActualSlice();
 506                 int k,kSize=lstKeyNameToBeErase.size();
 507                 int j,jSize=lstKeyNameActualSlice.size();
 508                 bool ok;
 509                 for (k=0;k<kSize; k++)
 510                 {
 511                         ok=false;
 512                         for (j=0;j<jSize; j++)
 513                         {
 514                                 if (lstKeyNameToBeErase[k]==lstKeyNameActualSlice[j])
 515                                 {
 516                                         ok=true;
 517                                 }
 518                         } // for j
 519                         if (ok==true)
 520                         {
 521                                 lstKeyName.push_back( lstKeyNameToBeErase[k] );
 522                         } // if ok
 523                 } // for k
 524
 525                 deleteContours( lstKeyName );
 526 JCP 19 - 11 - 08*/
 527 }
 528
 529 void wxContourMainFrame :: deleteContours( std::vector<std::string>  keyNamesVector )
 530 {
 531         int i,size=keyNamesVector.size();
 532         for (i=0;i<size;i++)
 533         {
 534                 deleteContour( keyNamesVector[i] );
 535         }
 536 }
 537
 538 void wxContourMainFrame :: deleteContour( std::string theKeyName ){
 539         /*
 540         manualContourModel                      * cModel;
 541         manualViewBaseContour           * cViewer;
 542         manualContourBaseControler      * cControler;
 543
 544         ContourWrap_ViewControl *conwrapviewControl =  _theViewPanel->getSceneManager()->getContourWrap_ViewControlOf( theKeyName );
 545         cControler      = conwrapviewControl->getControler();*/
 546
 547         //JCP 21 - 11 - 2008
 548         bool isedit = _theViewPanel->isEditableCControler(theKeyName);
 549         bool ispartofstaticlst = kernelManager->IsPartOfStaticList(theKeyName);
 550
 551         if (isedit  && ispartofstaticlst)
 552         {
 553                 _theViewPanel->removeFromScene(theKeyName);
 554
 555                 kernelManager->deleteCModel(theKeyName);
 556                 //_theViewPanel->getSceneManager()->removeFromScene( theKeyName );
 557                 //cViewer               = conwrapviewControl->getViewer();
 558                 //_theViewPanel->getSceneManager()->removeWrap( theKeyName );
 559                 //cControler* conwrapviewControl->getControler();
 560         //      delete cModel;
 561         //      delete cViewer;
 562         //      delete cControler;
 563         } // if editable
 564 //JCP 21 - 11 - 08
 565 }
 566
 567 void wxContourMainFrame::onDeleteContoursActSlice(){
 568         //JCP 20-10-08 Undo redo implementation
 569         saveState();
 570         //JCP 20-10-08 Undo redo implementation
 571         deleteContours( (std::vector<std::string>)_theViewPanel->getSceneManager()->GetlstContoursNameActualSlice() );
 572 }
 573 void wxContourMainFrame::onDeleteAllContours(){
 574         //JCP 20-10-08 Undo redo implementation
 575         saveState();
 576         deleteAllContours();
 577 }
 578 void wxContourMainFrame::deleteAllContours(){
 579         //JCP 20-10-08 Undo redo implementation
 580
 581         wxBusyCursor wait;
 582         std::vector<int> tempVector;
 583         _instantPanel->getInstant( tempVector );
 584
 585 //JCP --08-09-2008 When using a diferent interface the _mbarrangeDeleteAll might not be initialize
 586 //              the values in GetStart and GetEnd will then not be initialize also.
 587 //              We use instead the values given when initializing the _deletepanel.
 588
 589         //int minZ = _mbarrangeDeleteAll->GetStart();
 590         //int maxZ = _mbarrangeDeleteAll->GetEnd();
 591         int minZ, maxZ;
 592
 593         minZ = 0;
 594         maxZ = _theViewPanel->getSceneManager()->GetImageDataSizeZ();
 595
 596 //JCP --08-09-2008
 597
 598         _theViewPanel->getSceneManager()->removeSceneContours( );
 599         _theViewPanel->getSceneManager()->removeAllOutlines();
 600         kernelManager->removeAllOutlines();
 601 //JCP --08-09-2008
 602         /*
 603         if ( (minZ==0) && (maxZ==_mbarrangeDeleteAll->GetMax() ))
 604         {
 605                 _theViewPanel->getSceneManager()->removeSceneContours( );
 606                 _modelManager->removeAllOutlines();
 607                 _theViewPanel->getSceneManager()->removeAllOutlines();
 608
 609         } else {
 610                 for ( z=minZ ; z<=maxZ ; z++)
 611                 {
 612                         tempVector[1]=z;
 613                         Instant instant(&tempVector);
 614                         std::vector<ContourThing**> lstContourThings = this->_modelManager->getOutlinesAtInstant( &instant );
 615
 616                         sizeLstContourThings = lstContourThings.size();
 617                         for (ii=0 ; ii<sizeLstContourThings ; ii++)
 618                         {
 619                                 ContourThing **contourthing = lstContourThings[ii];
 620                                 deleteContour( (*contourthing)->getName() );
 621                         } //for ii
 622                 }// for z
 623         } // if
 624 JCP --08-09-2008 */
 625 }
 626
 627 void wxContourMainFrame::setConceptValue( std::string name, int value ){
 628         _instantPanel->setConceptValue(name, value);
 629 }
 630
 631
 632 ConceptDataWrap* wxContourMainFrame::getLastConceptData(){
 633         return _instantPanel->getLastConceptData();
 634 }
 635
 636
 637 bool wxContourMainFrame::getIfConceptCheckedAt( std::string name, int pos ){
 638         return _instantPanel->getIfConceptCheckedAt( name, pos );
 639 }
 640
 641
 642
 643 void wxContourMainFrame::ShowResultImages(int typeContourGroup, int selection, int minZ, int maxZ)
 644 {
 645         vtkImageData * mask;
 646         vtkImageData * value;
 647         this->getMaskValue(&mask, &value, typeContourGroup, selection, minZ, maxZ);
 648
 649         std::vector<int> nTypeView;
 650         nTypeView.push_back(5);
 651         nTypeView.push_back(1);
 652         nTypeView.push_back(2);
 653         nTypeView.push_back(0);
 654
 655         wxFrame *frame = new wxFrame(this, -1,_T("Result image extracted.."),wxDefaultPosition,wxSize(600,600), wxDEFAULT_FRAME_STYLE|wxSTAY_ON_TOP);
 656         wxAuiManager *m_mgr_noteBookViewerResult = new wxAuiManager();
 657         m_mgr_noteBookViewerResult->SetManagedWindow(frame);
 658
 659         wxAuiNotebook* noteBookViewerResult = new wxAuiNotebook(frame, -1, wxPoint(600, 600), wxSize(430,200), m_notebook_style);
 660         m_mgr_noteBookViewerResult->AddPane(noteBookViewerResult, wxAuiPaneInfo().Name(wxT("notebook_content")).CenterPane().PaneBorder(false));
 661
 662         wxPanel *panelViewer1 = new wxMaracas_N_ViewersWidget(noteBookViewerResult, value,&nTypeView);
 663         wxPanel *panelViewer2 = new wxMaracas_N_ViewersWidget(noteBookViewerResult, mask,&nTypeView);
 664
 665
 666         noteBookViewerResult->AddPage( panelViewer1, wxT("Image result") );
 667         noteBookViewerResult->AddPage( panelViewer2, wxT("Mask result") );
 668         m_mgr_noteBookViewerResult->Update();
 669         frame->Show();
 670 }
 671
 672
 673
 674
 675 void wxContourMainFrame::changeInstant()
 676 {
 677                 std::vector<int> instantVect;
 678                 _instantPanel->getInstant( instantVect );
 679                 int actualSlice = instantVect[1];
 680
 681                 kernelManager->setInstant(instantVect);
 682
 683             // Refresh Mask image
 684                 if(_viewMaskImage!=NULL){
 685                         _viewMaskImage->SetZ(actualSlice);
 686                         if (_viewMaskImagePanel->IsVisible()==true)
 687                         {
 688                                 vtkImageData *mask, *value;
 689                                 getMaskValue(&mask,&value, _contourGroup , 0, -1, -1);
 690                                 _viewMaskImage->onThreshold();
 691                         }
 692                 }
 693
 694         // Refresh Threshold image
 695                 if(_viewThresholdImage!=NULL){
 696                         _viewThresholdImage->SetZ(actualSlice);
 697                         if (_viewThresholdImagePanel->IsVisible()==true){
 698                                 _viewThresholdImage->onThreshold();
 699                         }
 700                 }
 701
 702         // Refresh Threshold image
 703                 if(_viewColorLayerImage!=NULL){
 704                         _viewColorLayerImage->SetZ(actualSlice);
 705                         if (_viewColorLayerImagePanel->IsVisible()==true){
 706                                 _viewColorLayerImage->onThreshold();
 707                         }
 708                 }
 709
 710                 updateInstantOutlines();
 711                 updateInstantImageData();
 712                 updateInstantAxes();
 713 }
 714
 715
 716
 717 void wxContourMainFrame :: updateInstantOutlines()
 718 {
 719         _theViewPanel->removeSceneContours();
 720         _theViewPanel->addNameWrapperToScene();
 721
 722         //for( int i=0; i<size; i++)
 723         //{
 724         //      _theViewPanel->getSceneManager()->addToScene(namesWrapping[i]->getKeyName(), true, true, true, false, false );
 725         //}
 726 }
 727
 728 int wxContourMainFrame::getNamesWrappingSize(){
 729         return kernelManager->getNamesWrappingSize();
 730 }
 731 std::string wxContourMainFrame::getNameWrapping(int i){
 732         return kernelManager->getNameWrapping(i);
 733 }
 734
 735 void wxContourMainFrame::updateInstantImageData()
 736 {
 737         std::vector<int> inst;
 738         _instantPanel->getInstant(inst);
 739
 740         vtkImageData* img = kernelManager->getImageAtInstant(inst);
 741         if(img!=NULL){
 742                 _theViewPanel->changeImage(img);
 743                 showAxis(false);
 744         }else{
 745                 int z = _instantPanel->getConceptDataOf("Axe Depth")->getActualValue();
 746                 _theViewPanel->setImageSlice(z);
 747         }
 748 }
 749
 750 void wxContourMainFrame::updateInstantAxes()
 751 {
 752 }
 753
 754
 755 void wxContourMainFrame::onChangeDeep(int val){
 756         _instantPanel->setConceptValue( "Axe Depth", (int)val );
 757         changeInstant();
 758 }
 759
 760
 761 void wxContourMainFrame::onCopy(){
 762         std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();
 763
 764         std::vector<int> tempVector;
 765         _instantPanel->getInstant( tempVector );
 766     _performingOperation->reset();
 767         _performingOperation->setStartCommand( COPY );
 768         _performingOperation->setStartOperationInstantVector( tempVector );
 769         _performingOperation->setKeyNamesOperationElems( currentSelection );
 770 }
 771
 772 void wxContourMainFrame::onPaste(){
 773
 774
 775         char theStartCommand = _performingOperation->getStartCommand();
 776         if (  theStartCommand == COPY )
 777         {
 778                 //JCP 20-10-08 Undo redo implementation
 779                 saveState();
 780                 //JCP 20-10-08 Undo redo implementation
 781                 std::vector<int> tempVector;
 782                 _instantPanel->getInstant( tempVector );
 783                 _performingOperation->setEndOperationInstantVector ( tempVector );
 784                 std::vector<std::string> elems = _performingOperation->getKeyNamesOperationElems();
 785                 int i,size = elems.size();
 786                 for( i=0; i<size; i++ )
 787                 {
 788                         createCopyContourOf( elems[i], tempVector, i>0 );
 789                 }
 790         }
 791 }
 792 void wxContourMainFrame::onUndo(){
 793         std::string filename;
 794         if(kernelManager->onUndoSaveFile(filename)){
 795                 saveFileWithContours(filename);
 796         }
 797         if(kernelManager->onUndo(filename)){
 798                 loadState(filename);
 799         }
 800 }
 801 void wxContourMainFrame::onRedo(){
 802         std::string filename;
 803         if(kernelManager->onRedo(filename)){
 804                 loadState(filename);
 805         }
 806
 807 }
 808 void wxContourMainFrame :: createCopyContourOf ( std::string anExistingKName, std::vector<int> &instantNoTouchData, bool append )
 809 {
 810         std::string cloneName = kernelManager->createCopyContourOf( anExistingKName, instantNoTouchData );
 811         manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(cloneName);//_modelManager->getOutlineByKeyName( cloneName )->getModel();
 812         _theViewPanel->getSceneManager()->createCopyContourOf( anExistingKName, cloneName, manualModel , append );
 813 }
 814
 815 ///AD: 03-09    Copy the object and apply the given transformation
 816 void wxContourMainFrame :: createMirrorContourOf ( std::string anExistingKName, std::vector<int> &instantNoTouchData, bool append )
 817 {
 818         std::string cloneName = kernelManager->createCopyContourOf( anExistingKName, instantNoTouchData );
 819         manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(cloneName);
 820
 821         manualPoint * refPoint1 = _refLineModel->GetManualPoint(0);
 822         manualPoint * refPoint2 = _refLineModel->GetManualPoint(1);
 823
 824         double pnt1X = refPoint1->GetX();
 825         double pnt1Y = refPoint1->GetY();
 826 //      double pnt1Z = refPoint1->GetZ();
 827         double pnt2X = refPoint2->GetX();
 828         double pnt2Y = refPoint2->GetY();
 829 //      double pnt2Z = refPoint2->GetZ();
 830
 831         double angle = (atan2(pnt2Y - pnt1Y, pnt2X - pnt1X) * 180 / 3.1415926535897932384626433832795)+90;
 832         vtkTransform *t = vtkTransform::New();
 833
 834         t->PostMultiply();
 835         t->Identity();
 836         t->Translate(-pnt1X, -pnt1Y, 0);
 837         t->RotateZ(-angle);
 838         t->Scale(-1,1,1);
 839         t->RotateZ(angle);
 840         t->Translate(pnt1X, pnt1Y, 0);
 841         t->Update();
 842
 843         int i,size=manualModel->GetSizeLstPoints();
 844         for (i=0;i<size;i++)
 845         {
 846                 manualPoint * mp = manualModel->GetManualPoint(i);
 847                 float vecIn[3];
 848                 float vecOut[3];
 849                 vecIn[0]=mp->GetX();
 850                 vecIn[1]=mp->GetY();
 851                 vecIn[2]=mp->GetZ();
 852                 t->TransformPoint( vecIn, vecOut );
 853                 mp->SetPointX( vecOut[0] );
 854                 mp->SetPointY( vecOut[1] );
 855                 mp->SetPointZ( vecOut[2] );
 856         }
 857
 858         _theViewPanel->getSceneManager()->createCopyContourOf( anExistingKName, cloneName, manualModel , append );
 859 }
 860
 861 //EED04
 862 void wxContourMainFrame ::loadState(std::string filename){
 863
 864         deleteAllContours();
 865         onLoadContours(filename,false);
 866
 867         /* EED Borrame
 868         char tmp[255];
 869         FILE *pFile=fopen(filename.c_str(),"r+");
 870
 871         fscanf(pFile,"%s",tmp); // --CreaContour--
 872
 873         fscanf(pFile,"%s",tmp); // Version
 874         fscanf(pFile,"%s",tmp); // 1.0.3 || 1.0.2 || 1.0.1 || 1.0.0
 875
 876         deleteAllContours();
 877
 878         loadContours(pFile, false);
 879         loadContours(pFile, true);
 880
 881         fclose(pFile);
 882         */
 883 }
 884
 885
 886 //EED03
 887 /*EED Borrame
 888 void wxContourMainFrame::loadContours( FILE *pFile, bool staticContour )
 889 {
 890         char tmp[255];
 891
 892         if (staticContour==false)
 893         {
 894                 fscanf(pFile,"%s",tmp); // ImageDimensions
 895                 fscanf(pFile,"%s",tmp); // X
 896                 fscanf(pFile,"%s",tmp); // Y
 897                 fscanf(pFile,"%s",tmp); // Z
 898
 899                 fscanf(pFile,"%s",tmp); // ImageSpacing
 900                 fscanf(pFile,"%s",tmp); // X
 901                 fscanf(pFile,"%s",tmp); // Y
 902                 fscanf(pFile,"%s",tmp); // Z
 903         }
 904
 905         fscanf(pFile,"%s",tmp); // NumberOfContours
 906         fscanf(pFile,"%s",tmp); // ##
 907         int numberOfContours = atoi(tmp);
 908
 909         std::vector<int> instantVector;
 910         int typeContourModel;
 911         manualBaseModel *manModelContour;
 912         int typeView;
 913
 914         int i;
 915         for (i=0;i<numberOfContours;i++)
 916         {
 917                 instantVector.clear();
 918                 fscanf(pFile,"%s",tmp); // Instant
 919                 fscanf(pFile,"%s",tmp); // 1
 920                 instantVector.push_back( atoi(tmp) );
 921                 fscanf(pFile,"%s",tmp); // 2
 922                 instantVector.push_back( atoi(tmp) );
 923                 fscanf(pFile,"%s",tmp); // 3
 924                 instantVector.push_back( atoi(tmp) );
 925                 fscanf(pFile,"%s",tmp); // 4
 926                 instantVector.push_back( atoi(tmp) );
 927                 fscanf(pFile,"%s",tmp); // 5
 928                 instantVector.push_back( atoi(tmp) );
 929                 fscanf(pFile,"%s",tmp); // 6
 930                 instantVector.push_back( atoi(tmp) );
 931
 932                 fscanf(pFile,"%s",tmp); // TypeContourModel
 933                 fscanf(pFile,"%s",tmp); // ##
 934                 typeContourModel = atoi(tmp);
 935
 936                 manModelContour =  kernelManager->factoryManualContourModel(typeContourModel);
 937                 manModelContour->Open(pFile);
 938
 939                 fscanf(pFile,"%s",tmp); // TypeView
 940                 fscanf(pFile,"%s",tmp); // ##
 941                 typeView = atoi(tmp);
 942
 943                 std::string theName;
 944                 theName = kernelManager->createOutline( manModelContour, instantVector );
 945                 bool addedModel = theName.compare("") != 0;
 946                 if( addedModel )
 947                 {
 948                         double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
 949                         _theViewPanel->getSpacing(spc);
 950                         //Adding the manualContourControler to interface objects structure
 951                         //Adding the manualViewContour to interface objects structure
 952                         //_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.
 953                         _theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc , typeView) ;
 954                 }
 955
 956                 if (staticContour==true)
 957                 {
 958                         Instant instant(&instantVector);
 959                         kernelManager->changeContourOfManager( theName , &instant );
 960                 }
 961         }// for  numberOfContours
 962 }
 963 */
 964
 965
 966 void wxContourMainFrame::onLoad()
 967 {
 968         std::string fileNameContourROI = GetFileLocation();
 969 //CMRU 03-09-09-----------------------------------------------------------------------------------------------
 970         if(GetFileLocation().empty())
 971         {
 972 //------------------------------------------------------------------------------------------------------------
 973                 wxFileDialog dialog(NULL, _T("Choose a file"), _T(""), _T(""), _T("*.roi"), wxOPEN );
 974                 if (dialog.ShowModal() == wxID_OK)
 975                 {
 976                         fileNameContourROI = (const char *)(dialog.GetPath().mb_str());
 977                 }
 978         }
 979
 980         onLoadContours(fileNameContourROI,true);
 981 }
 982
 983
 984 void  wxContourMainFrame::SetZForAllContours(int pz)
 985 {
 986         printf("EED wxContourMainFrame::SetZForAllContours\n");
 987
 988         //-- Normal Contours
 989
 990         std::vector< std::string > lstNameThings;
 991         int i,sizeLstNameThings;
 992         int ii,sizeLstPoints;
 993
 994         lstNameThings           = kernelManager->GetLstNameThings();
 995         sizeLstNameThings       = lstNameThings.size();
 996         for (i=0 ; i<sizeLstNameThings ; i++)
 997         {
 998 printf("EED wxContourMainFrame::SetZForAllContours contour=%d \n", i );
 999                 manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(lstNameThings[i]);
1000                 sizeLstPoints = manualModel->GetSizeLstPoints();
1001                 for (ii=0 ; ii<sizeLstPoints ; ii++)
1002                 {
1003                          manualModel->GetManualPoint(ii)->SetPointZ(-900);
1004                 }// for ii  list of points
1005         }// for i  list of Things
1006
1007         //-- Static Contours
1008
1009         lstNameThings           = kernelManager->GetLstNameThingsStatic();
1010         sizeLstNameThings       = lstNameThings.size();
1011         for (i=0 ; i<sizeLstNameThings ; i++)
1012         {
1013                 manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(lstNameThings[i]);
1014                 sizeLstPoints = manualModel->GetSizeLstPoints();
1015                 for (ii=0 ; ii<sizeLstPoints ; ii++)
1016                 {
1017                          manualModel->GetManualPoint(ii)->SetPointZ(-900);
1018                 }// for ii  list of points
1019         }// for i  list of static things
1020 }
1021
1022
1023
1024 void wxContourMainFrame::onLoadContours(std::string fileNameContourROI, bool interactiveInterface)
1025 {
1026         char tmp[255];
1027         char tmpD[255];
1028
1029         FILE *pFile =fopen(fileNameContourROI.c_str(),"r+");
1030
1031
1032 //CMRU 03-09-09- ----------------------------------------------------------------------------------------------
1033         if(pFile != NULL)
1034         {
1035 //------------------------------------------------------------------------------------------------------------
1036         fileNameContourROI.append("data");
1037                 FILE *pFileData=fopen(fileNameContourROI.c_str(),"r+");
1038                 if(pFileData != NULL)
1039                 {
1040                         fscanf(pFileData,"%s",tmpD); // --CreaContour--
1041                         fscanf(pFileData,"%s",tmpD); // Version
1042                         fscanf(pFileData,"%s",tmpD); // 1.0.3 || 1.0.2 || 1.0.1 || 1.0.0
1043
1044                         fscanf(pFileData,"%s",tmpD); // onePixelSize
1045                         fscanf(pFileData,"%s",tmpD); // #
1046                         _onePixelSize = atof(tmpD);
1047                         fscanf(pFileData,"%s",tmpD); // NumberOfContours
1048                         fscanf(pFileData,"%s",tmpD); // #
1049                 }
1050
1051                 fscanf(pFile,"%s",tmp); // --CreaContour--
1052
1053                 fscanf(pFile,"%s",tmp); // Version
1054                 fscanf(pFile,"%s",tmp); // 1.0.3 || 1.0.2 || 1.0.1 || 1.0.0
1055                 std::string version(tmp);
1056
1057
1058 printf("EED wxContourMainFrame::onLoadContours  version%s \n", version.c_str() );
1059
1060
1061                 //AD:02-06-09
1062         _tmpReadFileTypeOfTransformation=-1;
1063                 if (version=="1.0.3")
1064                 {
1065                     readDimSpc(pFile,interactiveInterface);   // DimSpc interactive ON
1066                         openContours(pFile,pFileData,false);
1067                         openContours(pFile,pFileData,true);     //Load StaticContours
1068                 }
1069
1070                 if (version=="1.0.2")
1071                 {
1072 //EED001
1073                         readDimSpc(pFile,interactiveInterface); // DimSpc interactive ON
1074                         openContours(pFile,pFileData,false);
1075                         readDimSpc(pFile,false);                // DimSpc interactive OFF
1076                         openContours(pFile,pFileData,true);     // Load StaticContours
1077                         SetZForAllContours(-900);
1078                 }
1079
1080                 //AD:02-06-09
1081                 else if (version=="1.0.1")
1082                 {
1083                         openContours(pFile,pFileData,false); //Skips ImageDimensions and ImageSpacing
1084                         openContours(pFile,pFileData,true); //Load StaticContours, skips ImageDimensions and ImageSpacing
1085                 }
1086
1087                 //AD:02-06-09
1088                 else if (version=="1.0.0")
1089                 {
1090                         openContours(pFile,pFileData,false); //Skips ImageDimensions and ImageSpacing
1091                 }
1092
1093                 fclose(pFile);
1094
1095                 if(pFileData != NULL)
1096                 {
1097                         fclose(pFileData);
1098                 }
1099         }
1100         _theViewPanel->getSceneManager()->removeSceneContours();
1101         changeInstant();
1102 }
1103
1104
1105
1106 void wxContourMainFrame::onImport(){
1107         std::string filename, filenamecontours;
1108         wxFileDialog dialog(NULL, _T("Choose a XML Osirix File"), _T(""), _T(""), _T("*.xml"), wxOPEN );
1109
1110         if (dialog.ShowModal() == wxID_OK)
1111         {
1112                 filename = dialog.GetPath().mb_str();
1113                 filenamecontours = kernelManager->parseOsirixFile(filename);
1114
1115                 if(filenamecontours.compare("") != 0){
1116                         onLoadContours(filenamecontours,true);
1117                 }
1118
1119         }
1120 }
1121 void wxContourMainFrame::onTest(){
1122         std::string filename, filenamecontours;
1123         wxFileDialog dialog(NULL, _T("Choose a File"), _T(""), _T(""), _T("*.*"), wxOPEN );
1124
1125         if (dialog.ShowModal() == wxID_OK)
1126         {
1127                 filename = dialog.GetPath().mb_str();
1128                 std::cout << "This is the filename: " << filename << std::endl;
1129         }
1130 }
1131
1132
1133 //AD: 29-05-09
1134 void wxContourMainFrame::onSave(){
1135 //CMRU 03-09-09-----------------------------------------------------------------------------------------------
1136         if(GetFileLocation().empty())
1137         {
1138 //------------------------------------------------------------------------------------------------------------
1139                 wxFileDialog dialog(NULL, _T("Choose a file"), _T(""), _T(""), _T("*.roi"), wxSAVE );
1140                 if (dialog.ShowModal() == wxID_OK)
1141                 {
1142                         std::string fileNameContourROI = (const char *)(dialog.GetPath().mb_str());
1143                         kernelManager->setCurrentFileName(fileNameContourROI);
1144                         saveFileWithContours( fileNameContourROI );
1145                 }
1146         }
1147 //CMRU 03-09-09-----------------------------------------------------------------------------------------------
1148         else
1149         {
1150                 std::cout<<"Nombre del archivo: "<<GetFileLocation()<<std::endl;
1151                 std::string fileNameContourROI = GetFileLocation();
1152                 std::cout<<"Nombre del archivo: "<<fileNameContourROI<<std::endl;
1153                 kernelManager->setCurrentFileName(fileNameContourROI);
1154                 saveFileWithContours( fileNameContourROI);
1155         }
1156 //------------------------------------------------------------------------------------------------------------
1157 }
1158
1159 //AD: 29-05-09
1160 void wxContourMainFrame::saveFileWithContours( std::string filename )
1161 {
1162
1163         FILE *pFile=fopen(filename.c_str(),"w+");
1164
1165 //CMRU 03-09-09-----------------------------------------------------------------------------------------------
1166         filename.append("data");
1167         std::cout<<"Nombre del archivo: "<<filename<<std::endl;
1168         FILE *pFileData=fopen(filename.c_str(),"w+");
1169 //------------------------------------------------------------------------------------------------------------
1170
1171         std::vector< std::string > lstNameThings;
1172         int i,sizeLstNameThings;
1173
1174         fprintf(pFile,"--CreaContour--\n");
1175         fprintf(pFile,"Version %s\n", "1.0.3" );
1176
1177 //CMRU 03-09-09-----------------------------------------------------------------------------------------------
1178         fprintf(pFileData,"--CreaContour--\n");
1179         fprintf(pFileData,"Version %s\n", "1.0.3" );
1180         fprintf(pFileData,"OnePixelSize %f\n", _onePixelSize);
1181
1182 //------------------------------------------------------------------------------------------------------------
1183
1184         vtkImageData *image = _images[0];
1185
1186         int dimRange[3];
1187         image->GetDimensions(dimRange);
1188
1189         fprintf(pFile,"ImageDimensions %d %d %d\n", dimRange[0], dimRange[1], dimRange[2] );
1190
1191         double spaRange[3];
1192         image->GetSpacing(spaRange);
1193
1194         fprintf(pFile,"ImageSpacing %f %f %f\n", spaRange[0], spaRange[1], spaRange[2] );
1195
1196         // Normal Contours
1197
1198         lstNameThings           = kernelManager->GetLstNameThings();
1199         sizeLstNameThings       = lstNameThings.size();
1200         fprintf(pFile,"NumberOfContours %d\n", sizeLstNameThings );
1201
1202 //CMRU 03-09-09-----------------------------------------------------------------------------------------------
1203         fprintf(pFileData,"NumberOfContours %d\n", sizeLstNameThings );
1204 //------------------------------------------------------------------------------------------------------------
1205
1206         for (i=0 ; i<sizeLstNameThings ; i++)
1207         {
1208 //CMRU 03-09-09-----------------------------------------------------------------------------------------------
1209                 manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(lstNameThings[i]);
1210                 double sizeInPixel = manualModel ->GetPathSize();
1211                 double realContourSize = sizeInPixel*_onePixelSize;
1212                 manualModel ->SetRealSize(realContourSize);
1213 //------------------------------------------------------------------------------------------------------------
1214
1215         //int size= kernelManager->GetLstNameThings().size();
1216
1217                 kernelManager->SaveThingName( pFile, pFileData, lstNameThings[i] );
1218                 _theViewPanel->getSceneManager()->SaveThingName( pFile, lstNameThings[i] );
1219         }// for i
1220
1221         //-- Static Contours
1222
1223 //      fprintf(pFile,"ImageDimensions %d %d %d\n", dimRange[0], dimRange[1], dimRange[2] );
1224 //      fprintf(pFile,"ImageSpacing %f %f %f\n", spaRange[0], spaRange[1], spaRange[2] );
1225
1226         lstNameThings           = kernelManager->GetLstNameThingsStatic();
1227         sizeLstNameThings       = lstNameThings.size();
1228         fprintf(pFile,"NumberOfContoursStatic %d\n", sizeLstNameThings );
1229
1230 //CMRU 03-09-09-----------------------------------------------------------------------------------------------
1231         fprintf(pFileData,"NumberOfContoursStatic %d\n", sizeLstNameThings );
1232 //------------------------------------------------------------------------------------------------------------
1233
1234         for (i=0 ; i<sizeLstNameThings ; i++)
1235         {
1236                 kernelManager->SaveThingName( pFile, pFileData, lstNameThings[i] );
1237                 _theViewPanel->getSceneManager()->SaveThingName( pFile, lstNameThings[i] );
1238         }// for i
1239         fclose(pFile);
1240         fclose(pFileData);
1241 }
1242
1243
1244 //EED02
1245 void wxContourMainFrame::readDimSpc(FILE *pFile, bool interactiveOption)
1246 {
1247         char tmp[255];
1248         int             imageDim[3];
1249         double          imageSpac[3];
1250         vtkImageData    *image          = _images[0];
1251     image->GetDimensions(imageDim);
1252     image->GetSpacing(imageSpac);
1253
1254     fscanf(pFile,"%s",tmp); // ImageDimensions
1255     fscanf(pFile,"%s",tmp); // X
1256     _tmpReadFileImageDim[0] = atoi(tmp);
1257     fscanf(pFile,"%s",tmp); // Y
1258     _tmpReadFileImageDim[1] = atoi(tmp);
1259     fscanf(pFile,"%s",tmp); // Z
1260     _tmpReadFileImageDim[2] = atoi(tmp);
1261
1262     fscanf(pFile,"%s",tmp); // ImageSpacing
1263     fscanf(pFile,"%s",tmp); // X
1264     _tmpReadFileImageSpac[0] = atof(tmp);
1265     fscanf(pFile,"%s",tmp); // Y
1266     _tmpReadFileImageSpac[1] = atof(tmp);
1267     fscanf(pFile,"%s",tmp); // Z
1268     _tmpReadFileImageSpac[2] = atof(tmp);
1269
1270
1271         if (interactiveOption==true)
1272     {
1273                 //Compare Spacing and Dims in X and Y (Necessary in Z?) - Just for Version 2
1274                 if (imageDim[0]!=_tmpReadFileImageDim[0] || imageDim[1]!=_tmpReadFileImageDim[1] || imageSpac[0]!=_tmpReadFileImageSpac[0] || imageSpac[1]!=_tmpReadFileImageSpac[1])
1275                 {
1276                         wxDialog* dial = new wxDialog (this,-1,_T("Tools"),wxDefaultPosition, wxSize(460,360));
1277                         wxSizer* buttonsSizer = dial->CreateSeparatedButtonSizer(wxOK|wxCANCEL);
1278                         wxBoxSizer *dialSizer = new wxBoxSizer(wxVERTICAL);
1279
1280                         wxString lstOptOperation[2];
1281                         lstOptOperation[0]=_T("By Dimension");
1282                         lstOptOperation[1]=_T("By Spacing");
1283                         wxRadioBox * radioOpts = new wxRadioBox(dial, -1, _T("Type of Transformation"), wxDefaultPosition, wxSize(270,45), 2 , lstOptOperation,  2, wxRA_SPECIFY_COLS);
1284
1285                         dialSizer->Add( new wxStaticText(dial,-1,_T("The image resolution is not compatible with the "))  , 0, wxGROW );
1286                         dialSizer->Add( new wxStaticText(dial,-1,_T("selected Roi file. Do you want to tranform it?"))  , 0, wxGROW );
1287                         dialSizer->Add( new wxStaticText(dial,-1,_T(" "))  , 0, wxGROW );
1288                         dialSizer->Add(radioOpts,0,wxGROW);
1289                         dialSizer->Add( new wxStaticText(dial,-1,_T(" "))  , 0, wxGROW );
1290                         dialSizer->Add(buttonsSizer,0,wxGROW);
1291                         dial->SetSizer(dialSizer, true);
1292                         dial->Layout();
1293                         dial->ShowModal();
1294
1295                         int _tmpReadFileTypeOfTransformation = -1;
1296 //EED                   bool transform = false;
1297
1298                         if (dial->GetReturnCode() == wxID_OK)
1299                         {
1300                                 _tmpReadFileTypeOfTransformation    = radioOpts->GetSelection();
1301                         }// if wxOK
1302
1303                 } // if dim spc
1304     } // if interactiveOption
1305 }
1306
1307
1308
1309
1310 //AD:04-06-09
1311 void wxContourMainFrame::openContours( FILE *pFile, FILE *pFileData, bool staticContour )
1312 {
1313
1314         char tmp[255];
1315
1316         vtkImageData    *image = _images[0];
1317
1318         int             imageDim[3];
1319         double          imageSpac[3];
1320     image->GetDimensions(imageDim);
1321     image->GetSpacing(imageSpac);
1322
1323
1324         fscanf(pFile,"%s",tmp); // NumberOfContours
1325         fscanf(pFile,"%s",tmp); // ##
1326         int numberOfContours = atoi(tmp);
1327
1328         std::vector<int> instantVector;
1329         int typeContourModel;
1330         manualBaseModel *manModelContour;
1331         int typeView;
1332
1333 /*
1334         if (compatible==true)
1335         {
1336                 int i;
1337                 for (i=0;i<numberOfContours;i++)
1338                 {
1339                         instantVector.clear();
1340                         fscanf(pFile,"%s",tmp); // Instant
1341
1342                         fscanf(pFile,"%s",tmp); // 1
1343                         instantVector.push_back( atoi(tmp) );
1344                         fscanf(pFile,"%s",tmp); // 2
1345                         instantVector.push_back( atoi(tmp) );
1346                         fscanf(pFile,"%s",tmp); // 3
1347                         instantVector.push_back( atoi(tmp) );
1348                         fscanf(pFile,"%s",tmp); // 4
1349                         instantVector.push_back( atoi(tmp) );
1350                         fscanf(pFile,"%s",tmp); // 5
1351                         instantVector.push_back( atoi(tmp) );
1352                         fscanf(pFile,"%s",tmp); // 6
1353                         instantVector.push_back( atoi(tmp) );
1354
1355
1356                         fscanf(pFile,"%s",tmp); // TypeContourModel
1357                         fscanf(pFile,"%s",tmp); // ##
1358                         typeContourModel = atoi(tmp);
1359
1360                         manModelContour =  kernelManager->factoryManualContourModel(typeContourModel);
1361                         manModelContour->Open(pFile);
1362                         if(pFileData != NULL)
1363                         {
1364                                 manModelContour->OpenData(pFileData);
1365                         }
1366
1367                         fscanf(pFile,"%s",tmp); // TypeView
1368                         fscanf(pFile,"%s",tmp); // ##
1369                         typeView = atoi(tmp);
1370
1371                         std::string theName;
1372                         theName = kernelManager->createOutline( manModelContour, instantVector );
1373                         bool addedModel = theName.compare("") != 0;
1374                         if( addedModel )
1375                         {
1376                                 double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
1377                                 _theViewPanel->getSpacing(spc);
1378                                 //Adding the manualContourControler to interface objects structure
1379                                 //Adding the manualViewContour to interface objects structure
1380                                 //_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.
1381                                 _theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc , typeView) ;
1382                         }
1383
1384                         if (staticContour) //StaticContours (will appear in all slices)
1385                         {
1386                                 Instant instant(&instantVector);
1387                                 kernelManager->changeContourOfManager( theName , &instant );
1388                         }
1389
1390                 }// for  numberOfContours
1391         }
1392
1393         else if (compatible==false)
1394         {
1395 */
1396
1397                 int i;
1398                 for (i=0;i<numberOfContours;i++)
1399                 {
1400                         instantVector.clear();
1401                         fscanf(pFile,"%s",tmp); // Instant
1402
1403                         fscanf(pFile,"%s",tmp); // 1
1404                         instantVector.push_back( atoi(tmp) );
1405                         fscanf(pFile,"%s",tmp); // 2
1406                         instantVector.push_back( atoi(tmp) );
1407                         fscanf(pFile,"%s",tmp); // 3
1408                         instantVector.push_back( atoi(tmp) );
1409                         fscanf(pFile,"%s",tmp); // 4
1410                         instantVector.push_back( atoi(tmp) );
1411                         fscanf(pFile,"%s",tmp); // 5
1412                         instantVector.push_back( atoi(tmp) );
1413                         fscanf(pFile,"%s",tmp); // 6
1414                         instantVector.push_back( atoi(tmp) );
1415
1416                         fscanf(pFile,"%s",tmp); // TypeContourModel
1417                         fscanf(pFile,"%s",tmp); // ##
1418                         typeContourModel = atoi(tmp);
1419
1420                         manModelContour =  kernelManager->factoryManualContourModel(typeContourModel);
1421                         manModelContour->Open(pFile);
1422                         if(pFileData != NULL)
1423                         {
1424                                 manModelContour->OpenData(pFileData);
1425                         }
1426
1427             if (_tmpReadFileTypeOfTransformation==-1){
1428                 //nothing to do..
1429             } else if (_tmpReadFileTypeOfTransformation==0){
1430                 double transX, transY;
1431                 transX = (double) imageDim[0]/_tmpReadFileImageDim[0];
1432                 transY = (double) imageDim[1]/_tmpReadFileImageDim[1];
1433                 manModelContour->Transform_Ax_Plus_B(transX,0,transY,0);
1434             } else if (_tmpReadFileTypeOfTransformation==1) {
1435                 double transX, transY;
1436                 transX = (double) _tmpReadFileImageSpac[0]/imageDim[0];
1437                 transY = (double) _tmpReadFileImageSpac[1]/imageDim[1];
1438                 manModelContour->Transform_Ax_Plus_B(transX,0,transY,0);
1439             }
1440
1441                         fscanf(pFile,"%s",tmp); // TypeView
1442                         fscanf(pFile,"%s",tmp); // ##
1443                         typeView = atoi(tmp);
1444
1445                         std::string theName;
1446                         theName = kernelManager->createOutline( manModelContour, instantVector );
1447                         bool addedModel = theName.compare("") != 0;
1448                         if( addedModel )
1449                         {
1450                                 double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
1451                                 _theViewPanel->getSpacing(spc);
1452                                 //Adding the manualContourControler to interface objects structure
1453                                 //Adding the manualViewContour to interface objects structure
1454                                 //_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.
1455                                 _theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc , typeView) ;
1456                         }
1457
1458                         if (staticContour) //StaticContours (will appear in all slices)
1459                         {
1460                                 Instant instant(&instantVector);
1461                                 kernelManager->changeContourOfManager( theName , &instant );
1462                         }
1463                 }// for  numberOfContours
1464
1465 /*      }    */
1466
1467 }
1468
1469 void wxContourMainFrame::RefreshInterface(){
1470         changeInstant();
1471         _theViewPanel->RefreshInterface();
1472         //wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)this->_theViewPanel->getWxVtkBaseView();
1473         //wxvtk2dbaseview->Refresh();
1474 }
1475
1476 vtkImageData* wxContourMainFrame::getImageData(){
1477         return _theViewPanel->getImageData();
1478 }
1479
1480 void wxContourMainFrame::onSegmentationOneSliceITK(wxString distance, wxString sigma, wxString alfa, wxString beta, wxString propagation, wxString iterations, wxString inflation)
1481 {
1482         //JCP 20-10-08 Undo redo implementation
1483         saveState();
1484         //JCP 20-10-08 Undo redo implementation
1485
1486         wxBusyCursor wait;
1487         int                                     x                                       = _theViewPanel->GetX();
1488         int                                     y                                       = _theViewPanel->GetY();
1489         int                                     z                                       = _theViewPanel->GetZ();
1490         SegmentationOneSliceITK( x,y,z,distance, sigma, alfa, beta, propagation, iterations, inflation);
1491         RefreshInterface();
1492 }
1493
1494 void wxContourMainFrame::SegmentationOneSliceITK(int x, int y, int z, wxString distanc, wxString sigm, wxString alf, wxString bet, wxString prop, wxString iter, wxString inflation)
1495 {
1496         int typeofcontour = 1;
1497         //Image Data
1498         vtkImageData    *imagedata      = getImageData();
1499
1500         //Tipo de pixeles a utilizar internamente en ITK
1501         typedef   float  InternalPixelType;
1502         const     unsigned int    Dimension = 2;
1503         typedef itk::Image< InternalPixelType, Dimension >  InternalImageType;
1504
1505         //Tipo de pixeles de salida 1
1506         typedef unsigned char OutputPixelType;
1507         typedef itk::Image< OutputPixelType, Dimension > OutputImageType;
1508
1509         //Tipo de pixeles de salida 2
1510         typedef unsigned short OutputPixelType2;
1511         typedef itk::Image< OutputPixelType2, Dimension > OutputImageType2;
1512
1513         //DefiniciÛn del thresholder
1514         typedef itk::BinaryThresholdImageFilter<
1515                                                         InternalImageType,
1516                                                         OutputImageType    >    ThresholdingFilterType;
1517
1518         //DefiniciÛn del primer filtro de conversiÛn de pixeles
1519         typedef itk::CastImageFilter<
1520                                 OutputImageType, OutputImageType2 >  CastFilterType;
1521
1522         //DefiniciÛn del segundo tipo de conversiÛn de pixeles
1523         typedef itk::CastImageFilter<
1524                                 OutputImageType2, InternalImageType >  CastFilterType2;
1525
1526         //Tercer tipo de conversiÛn
1527         typedef itk::RescaleIntensityImageFilter<
1528                                                                 InternalImageType,
1529                                                                 OutputImageType >   CastFilterType3;
1530
1531         //Cuarto tipo de conversiÛn
1532         typedef itk::RescaleIntensityImageFilter<
1533                                                                 OutputImageType,
1534                                                                 OutputImageType >   CastFilterType4;
1535
1536         ThresholdingFilterType::Pointer thresholder = ThresholdingFilterType::New();
1537
1538         thresholder->SetLowerThreshold( 0.0 );
1539         thresholder->SetUpperThreshold( 128 );
1540
1541         thresholder->SetOutsideValue(  255  );
1542         thresholder->SetInsideValue(  0 );
1543
1544         //DefinciÛn de conexiÛnes entre VTK e ITK y el writer
1545         typedef itk::VTKImageToImageFilter<OutputImageType2> ConnectorType;
1546         typedef itk::ImageToVTKImageFilter<OutputImageType> ConnectorType2;
1547 //EED10JUIN2011 typedef  itk::ImageFileWriter<  OutputImageType  > WriterType;
1548
1549         ConnectorType::Pointer connector= ConnectorType::New();
1550         ConnectorType2::Pointer connector2= ConnectorType2::New();
1551
1552
1553         CastFilterType::Pointer filter=CastFilterType::New();
1554         CastFilterType2::Pointer filter2=CastFilterType2::New();
1555
1556         connector->SetInput( imagedata );
1557         filter2->SetInput(connector->GetOutput());
1558
1559         typedef   itk::CurvatureAnisotropicDiffusionImageFilter<
1560                                                                 InternalImageType,
1561                                                                 InternalImageType >  SmoothingFilterType;
1562
1563         SmoothingFilterType::Pointer smoothing = SmoothingFilterType::New();
1564
1565         typedef   itk::GradientMagnitudeRecursiveGaussianImageFilter<
1566                                                                 InternalImageType,
1567                                                                 InternalImageType >  GradientFilterType;
1568
1569         typedef   itk::SigmoidImageFilter<
1570                                                                 InternalImageType,
1571                                                                 InternalImageType >  SigmoidFilterType;
1572
1573         GradientFilterType::Pointer  gradientMagnitude = GradientFilterType::New();
1574
1575         SigmoidFilterType::Pointer sigmoid = SigmoidFilterType::New();
1576
1577         sigmoid->SetOutputMinimum(  0.0  );
1578         sigmoid->SetOutputMaximum(  255.0  );
1579
1580
1581         typedef  itk::FastMarchingImageFilter<
1582                                                                 InternalImageType,
1583                                                                 InternalImageType >    FastMarchingFilterType;
1584
1585
1586         FastMarchingFilterType::Pointer  fastMarching = FastMarchingFilterType::New();
1587
1588 printf("EED wxContourMainFrame::SegmentationOneSliceITK  Skypping this code.  Not compiling   GeodesicActiveContourLevelSetImageFilter     in fedora 17 with ITK 3.20.1 \n ");
1589 /*EED 17 sept 2010
1590  > - > - > - > - > - > - > - > - > - > - > - > - > - > - > - > -   Not compiling   GeodesicActiveContourLevelSetImageFilter     in fedora 17 with ITK 3.20.1
1591
1592
1593         typedef  itk::GeodesicActiveContourLevelSetImageFilter< InternalImageType,
1594                                         InternalImageType >    GeodesicActiveContourFilterType;
1595         GeodesicActiveContourFilterType::Pointer geodesicActiveContour =
1596                                                                                 GeodesicActiveContourFilterType::New();
1597
1598         typedef  itk::ZeroCrossingImageFilter<
1599                                                                 InternalImageType,
1600                                                                 InternalImageType >    ZeroCrossingFilterType;
1601         ZeroCrossingFilterType::Pointer zeroCrossing =
1602                                                         ZeroCrossingFilterType::New();
1603
1604         const double propagationScaling = atof( crea::wx2std(prop).c_str() );
1605
1606         geodesicActiveContour->SetPropagationScaling( propagationScaling );
1607         geodesicActiveContour->SetCurvatureScaling( 1.0 );
1608         geodesicActiveContour->SetAdvectionScaling( 1.0 );
1609
1610         geodesicActiveContour->SetMaximumRMSError( 0.02 );
1611         int it=atoi(  crea::wx2std(iter).c_str() );
1612         geodesicActiveContour->SetNumberOfIterations( it );
1613
1614         smoothing->SetInput( filter2->GetOutput() );
1615         gradientMagnitude->SetInput( smoothing->GetOutput() );
1616         sigmoid->SetInput( gradientMagnitude->GetOutput() );
1617         fastMarching->SetInput( sigmoid->GetOutput() );
1618         geodesicActiveContour->SetInput( fastMarching->GetOutput() );
1619         geodesicActiveContour->SetFeatureImage( sigmoid->GetOutput() );
1620
1621         zeroCrossing->SetInput( geodesicActiveContour->GetOutput() );
1622         //thresholder->SetInput( zeroCrossing->GetOutput() );
1623         thresholder->SetInput( geodesicActiveContour->GetOutput() );
1624         connector2->SetInput( thresholder->GetOutput()  );
1625
1626 < - < - < - < - < - < - < - < - < - < - < - < - < - < - < - < - < - < - < - < -
1627 */
1628
1629
1630
1631
1632         smoothing->SetTimeStep( 0.125 );
1633         smoothing->SetNumberOfIterations(  5 );
1634         smoothing->SetConductanceParameter( 9.0 );
1635
1636
1637         const double sigma = atof(  crea::wx2std(sigm).c_str() );
1638         gradientMagnitude->SetSigma(  sigma  );
1639
1640         const double alpha =  atof(  crea::wx2std(alf).c_str() );
1641         const double beta  =  atof(  crea::wx2std(bet).c_str() );
1642
1643         sigmoid->SetAlpha( alpha );
1644         sigmoid->SetBeta(  beta  );
1645
1646         typedef FastMarchingFilterType::NodeContainer  NodeContainer;
1647         typedef FastMarchingFilterType::NodeType       NodeType;
1648
1649         NodeContainer::Pointer seeds = NodeContainer::New();
1650
1651         InternalImageType::IndexType  seedPosition;
1652         seedPosition[0] = x;
1653         seedPosition[1] = y;
1654
1655         const double initialDistance = atof( crea::wx2std(distanc).c_str() );
1656
1657         NodeType node;
1658
1659         const double seedValue = - initialDistance;
1660
1661         node.SetValue( seedValue );
1662         node.SetIndex( seedPosition );
1663
1664         seeds->Initialize();
1665         seeds->InsertElement( 0, node );
1666
1667         fastMarching->SetTrialPoints( seeds );
1668
1669         fastMarching->SetSpeedConstant( 1.0 );
1670
1671         fastMarching->SetOutputSize(
1672                         connector->GetOutput()->GetBufferedRegion().GetSize() );
1673
1674         fastMarching->SetStoppingValue( 800 );
1675         try
1676     {
1677
1678         connector2->Update();
1679         vtkImageData *idata = connector2->GetOutput();
1680
1681         vtkMarchingContourFilter* cntVTK = vtkMarchingContourFilter::New( );
1682
1683         cntVTK->SetInput( idata );
1684
1685         cntVTK->SetNumberOfContours( 1 );
1686         cntVTK->SetValue( 0, 255 );
1687         cntVTK->Update( );
1688         cntVTK->UpdateInformation();
1689
1690         vtkCleanPolyData* cpd = vtkCleanPolyData::New( );
1691         cpd->SetInput( cntVTK->GetOutput( ) );
1692         cpd->Update( );
1693         cpd->UpdateInformation();
1694
1695         vtkPolyDataConnectivityFilter* conn = vtkPolyDataConnectivityFilter::New( );
1696         conn->SetExtractionModeToLargestRegion( );
1697         conn->SetInput( cpd->GetOutput( ) );
1698         conn->Update( );
1699         conn->UpdateInformation();
1700
1701         vtkStripper* vtkstripper = vtkStripper::New( );
1702         vtkstripper->SetInput( conn->GetOutput() );
1703         vtkstripper->Update();
1704         vtkstripper->UpdateInformation();
1705
1706         vtkPolyData* polyDataResult =  cntVTK->GetOutput();
1707         //std::cout<<"Points "<<polyDataResult->GetNumberOfPoints()<<std::endl;
1708         polyDataResult->Update( );
1709         polyDataResult->UpdateInformation();
1710
1711         //EED
1712                 /*
1713         ofstream myfile;
1714         myfile.open ("C:/Creatis/example.txt");
1715         myfile << "\n";
1716         polyDataResult->Print(myfile);
1717         myfile << "-------------------------------------\n";
1718         polyDataResult->GetLines()->Print(myfile);
1719         myfile.close();*/
1720
1721         cntVTK          -> Delete();
1722         cpd                     -> Delete();
1723         conn            -> Delete();
1724
1725
1726         //--Calculating control points
1727
1728         std::vector<double> vecX;
1729         std::vector<double> vecY;
1730         std::vector<double> vecXo;
1731         std::vector<double> vecYo;
1732         std::vector<double>::iterator vecXoi;
1733         std::vector<double>::iterator vecYoi;
1734         std::vector<double> vecZ;
1735
1736         std::vector<double> vecCtrlPointX;
1737         std::vector<double> vecCtrlPointY;
1738         std::vector<double> vecCtrlPointZ;
1739
1740
1741         double *p;
1742         double xAct=0;
1743         double yAct=0;
1744         int ii,size=polyDataResult->GetNumberOfPoints();
1745         ofstream myfile;
1746         myfile.open ("C:/Creatis/example2.txt");
1747
1748         size=polyDataResult->GetNumberOfPoints();
1749         for (ii=0;ii<size;ii++)
1750         {
1751                 if(ii==0)
1752                 {
1753                         xAct=x;
1754                         yAct=y;
1755                 }
1756                 p       = polyDataResult->GetPoint(ii);
1757                 double x=p[0];
1758                 double y=p[1];
1759                 /*if(fabs(yAct-y)>20)
1760                 {
1761                         if((xAct-x)>1 || (xAct-x)<-1)
1762                         {
1763                         vecX.push_back( p[0] );
1764                         vecY.push_back( p[1] );
1765                         myfile <<p[0]<<","<<p[1]<<"\n";
1766                         std::cout<<" x Anterior "<<xAct<<" x actual "<<x<<std::endl;
1767                 std::cout<<" y Anterior "<<yAct<<" y actual "<<y<<std::endl;
1768                 std::cout<<" x "<<p[0]<<" y "<<p[1]<<std::endl;
1769                         vecZ.push_back( 900 );
1770                         xAct=x;
1771                         yAct=y;
1772                         }
1773                         else
1774                         {
1775                                 vecXo.push_back(p[0]);
1776                                 vecYo.push_back(p[1]);
1777                         }
1778
1779                 }
1780                 else*/ if(fabs(xAct-x)>11)
1781                 {
1782                         vecXo.push_back(p[0]);
1783                         vecYo.push_back(p[1]);
1784                 }
1785                 else
1786                 {
1787                 vecX.push_back( p[0] );
1788                 myfile <<p[0]<<","<<p[1]<<"\n";
1789                 //std::cout<<" x Anterior "<<xAct<<" x actual "<<x<<std::endl;
1790                 //std::cout<<" y Anterior "<<yAct<<" y actual "<<y<<std::endl;
1791                 //std::cout<<" x "<<p[0]<<" y "<<p[1]<<std::endl;
1792                 vecY.push_back( p[1] );
1793                 vecZ.push_back( 900 );
1794                 xAct=x;
1795                 yAct=y;
1796                 }
1797
1798
1799         }
1800
1801         while(!vecXo.empty())
1802         {
1803                 vecX.push_back(vecXo.back());
1804                 //std::cout<<" x Siguiente "<<vecXo.back();
1805                 vecXo.pop_back();
1806                 vecZ.push_back( 900 );
1807         }
1808         while(!vecYo.empty())
1809         {
1810                 vecY.push_back(vecYo.back());
1811                         vecYo.pop_back();
1812         }
1813         myfile.close();
1814
1815         /*for(int l=0;l<vecX.size();l++)
1816         {
1817                 if(l==0)
1818                 {
1819             vecXo.push_back(p[0]);
1820                         vecYo.push_back(p[1]);
1821                 }
1822                 else
1823                 {
1824                         if(vecXoi[l-1]==)
1825                         {
1826                         }
1827                 }
1828
1829         }*/
1830
1831         ExtractControlPoints2D *extractcontrolpoints2d = new ExtractControlPoints2D();
1832
1833         extractcontrolpoints2d->SetContour( &vecX , &vecY , &vecZ );
1834
1835         int method=2;
1836         if (method==0){
1837                 extractcontrolpoints2d->GetInitialControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
1838         }
1839         else if (method==1){
1840                 extractcontrolpoints2d->GetControlPoints(  &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
1841         }
1842         else if (method==2){
1843                 extractcontrolpoints2d->SetSamplingControlPoints( 15 );
1844                 extractcontrolpoints2d->GetSamplingControlPoints(  &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
1845         }
1846         //--Adding contour to the system
1847
1848         std::vector<int> actualInstantVector;
1849         _instantPanel->getInstant( actualInstantVector );
1850         actualInstantVector[1]=z;
1851
1852         int j,sizeCtrPt = vecCtrlPointX.size();
1853
1854         manualBaseModel *manModelContour =  kernelManager->factoryManualContourModel( typeofcontour );
1855         manModelContour->SetNumberOfPointsSpline( ((sizeCtrPt/100)+1)*100 );
1856         if (sizeCtrPt>=3){
1857                 for (j=0 ; j<sizeCtrPt ; j++)
1858                 {
1859                         manModelContour->AddPoint( vecCtrlPointX[j] , vecCtrlPointY[j] , vecCtrlPointZ[j]  );
1860                 } // for
1861                 std::string theName;
1862                 //theName = _modelManager->createOutline( manModelContour, actualInstantVector );
1863                 theName = kernelManager->createOutline( manModelContour, actualInstantVector );
1864                 bool addedModel = theName.compare("") != 0;
1865                 if( addedModel )
1866                 {
1867                         double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
1868                         _theViewPanel->getSpacing(spc);
1869                         //Adding the manualContourControler to interface objects structure
1870                         //Adding the manualViewContour to interface objects structure
1871                         //_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.
1872                         _theViewPanel->configureViewControlTo(theName, manModelContour, spc, typeofcontour);
1873                         //_theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc, typeofcontour ) ;
1874                 }       // if addedModel
1875         } // if sizeCtrPt
1876
1877
1878 /*
1879 //EED10JUIN2011
1880                  WriterType::Pointer writer = WriterType::New();
1881          CastFilterType3::Pointer caster = CastFilterType3::New();
1882
1883                  caster->SetInput( gradientMagnitude->GetOutput() );
1884                  writer->SetInput( caster->GetOutput() );
1885                  writer->SetFileName("Gradient Magnitude.png");
1886                  caster->SetOutputMinimum(   0 );
1887                  caster->SetOutputMaximum( 255 );
1888                  writer->Update();
1889
1890                  CastFilterType3::Pointer caster2 = CastFilterType3::New();
1891                  WriterType::Pointer writer2 = WriterType::New();
1892
1893                  caster2->SetInput( sigmoid->GetOutput() );
1894                  writer2->SetInput( caster2->GetOutput() );
1895                  writer2->SetFileName("Sigmoid.png");
1896                  caster2->SetOutputMinimum(   0 );
1897                  caster2->SetOutputMaximum( 255 );
1898                  writer2->Update();
1899
1900                  CastFilterType3::Pointer caster3 = CastFilterType3::New();
1901                  WriterType::Pointer writer3 = WriterType::New();
1902
1903                  caster3->SetInput( fastMarching->GetOutput() );
1904                  writer3->SetInput( caster3->GetOutput() );
1905                  writer3->SetFileName("FastMarching.bmp");
1906                  caster3->SetOutputMinimum(   0 );
1907                  caster3->SetOutputMaximum( 255 );
1908                  writer3->Update();
1909
1910                  CastFilterType3::Pointer caster4 = CastFilterType3::New();
1911                  WriterType::Pointer writer4 = WriterType::New();
1912
1913                  caster4->SetInput( geodesicActiveContour->GetOutput() );
1914                  writer4->SetInput( caster4->GetOutput() );
1915                  writer4->SetFileName("GeodesicActiveContour.png");
1916                  caster4->SetOutputMinimum(   0 );
1917                  caster4->SetOutputMaximum( 255 );
1918                  writer4->Update();
1919
1920                  CastFilterType3::Pointer caster5 = CastFilterType3::New();
1921                  WriterType::Pointer writer5 = WriterType::New();
1922
1923                  caster5->SetInput( zeroCrossing->GetOutput() );
1924                  writer5->SetInput( caster5->GetOutput() );
1925                  writer5->SetFileName("ZeroCrossing.bmp");
1926                  caster5->SetOutputMinimum(   0 );
1927                  caster5->SetOutputMaximum( 255 );
1928                  writer5->Update();
1929 */
1930     }
1931   catch( itk::ExceptionObject & excep )
1932     {
1933     std::cerr << "Exception caught !" << std::endl;
1934     std::cerr << excep << std::endl;
1935     }
1936 }
1937
1938 void wxContourMainFrame::onSegmentationOneSlice(int isovalue,int sampling,int method){
1939
1940         //JCP 20-10-08 Undo redo implementation
1941         saveState();
1942         //JCP 20-10-08 Undo redo implementation
1943
1944         wxBusyCursor wait;
1945         int                                     x                                       = _theViewPanel->GetX();
1946         int                                     y                                       = _theViewPanel->GetY();
1947         int                                     z                                       = _theViewPanel->GetZ();
1948         SegmentationOneSlice( x,y,z,isovalue, sampling, method );
1949         RefreshInterface();
1950 }
1951
1952
1953 void wxContourMainFrame::SegmentationOneSlice( int x, int y, int z, int isovalue, int sampling, int method )
1954 {
1955         int typeofcontour = 1;
1956         //--Extracting Contour
1957         //vtkImageData  *imagedata      = _theViewPanel->getSceneManager()->GetImageData();
1958         vtkImageData    *imagedata      = getImageData();
1959 //              double                  *range          = imagedata->GetScalarRange();
1960 //              double                  thr                     = 1;
1961
1962         vtkImageReslice *imageReslice = vtkImageReslice::New();
1963 //EED
1964 //              double spc[3];
1965 //              imagedata->GetSpacing(spc);
1966 //              x = x*spc[0];
1967 //              y = y*spc[1];
1968 //              z = z*spc[3];
1969
1970         imageReslice->SetInput( imagedata );
1971         imageReslice->SetInformationInput(imagedata);
1972         imageReslice->SetResliceAxesDirectionCosines(1,0,0, 0,1,0 ,0,0,1);
1973         imageReslice->SetResliceAxesOrigin(0,0,z);
1974         imageReslice->SetOutputDimensionality(2);
1975         imageReslice->SetInterpolationModeToLinear();
1976
1977         imagedata = imageReslice->GetOutput();
1978         imagedata->Update();
1979         imagedata->UpdateInformation();
1980
1981         vtkContourFilter* cntVTK = vtkContourFilter::New( );
1982         cntVTK->SetInput( imagedata );
1983
1984         cntVTK->SetNumberOfContours( 1 );
1985         //cntVTK->SetValue( 0, vmin );
1986 //              cntVTK->SetValue( 0, (range[1]*thr/100) );
1987         cntVTK->SetValue( 1, isovalue );
1988 //      cntVTK->SetValue( 1, vmax );
1989         cntVTK->Update( );
1990         cntVTK->UpdateInformation();
1991
1992         vtkCleanPolyData* cpd = vtkCleanPolyData::New( );
1993         cpd->SetInput( cntVTK->GetOutput( ) );
1994         cpd->ConvertLinesToPointsOff( );
1995         cpd->Update( );
1996         cpd->UpdateInformation();
1997
1998         vtkPolyDataConnectivityFilter* conn = vtkPolyDataConnectivityFilter::New( );
1999         conn->SetExtractionModeToClosestPointRegion( );
2000         //conn->SetMaxRecursionDepth( 3000 );
2001
2002         conn->SetInput( cpd->GetOutput( ) );
2003
2004         conn->SetClosestPoint( x, y, 0 );
2005         conn->Update( );
2006         conn->UpdateInformation();
2007
2008         vtkCleanPolyData* cpd2 = vtkCleanPolyData::New( );
2009         cpd2->SetInput( conn->GetOutput( ) );
2010         cpd2->Update();
2011         cpd2->UpdateInformation();
2012
2013         vtkStripper* vtkstripper = vtkStripper::New( );
2014         vtkstripper->SetInput( cpd2->GetOutput() );
2015         vtkstripper->Update();
2016         vtkstripper->UpdateInformation();
2017
2018
2019         vtkPolyData* polyDataResult =  vtkstripper->GetOutput();
2020
2021         polyDataResult->Update( );
2022         polyDataResult->UpdateInformation();
2023
2024 /* EED
2025 ofstream myfile;
2026 myfile.open ("c:/temp/example.txt");
2027 myfile << "\n";
2028 polyDataResult->Print(myfile);
2029 myfile << "-------------------------------------\n";
2030 polyDataResult->GetLines()->Print(myfile);
2031 myfile.close();
2032 */
2033
2034         cntVTK          -> Delete();
2035         cpd2            -> Delete();
2036         cpd                     -> Delete();
2037         conn            -> Delete();
2038
2039
2040 //--Calculating control points
2041
2042         std::vector<double> vecX;
2043         std::vector<double> vecY;
2044         std::vector<double> vecZ;
2045
2046         std::vector<double> vecCtrlPointX;
2047         std::vector<double> vecCtrlPointY;
2048         std::vector<double> vecCtrlPointZ;
2049
2050
2051         double *p;
2052         int ii,size=polyDataResult->GetNumberOfPoints();
2053         int id;
2054         for (ii=1;ii<=size;ii++)
2055         {
2056                 id      = polyDataResult->GetLines()->GetData()->GetValue(ii);
2057                 p       = polyDataResult->GetPoint(id);
2058 //              double x=p[0];
2059 //              double y=p[1];
2060                 vecX.push_back( p[0] );
2061                 vecY.push_back( p[1] );
2062                 vecZ.push_back( 900 );
2063 //                      vecZ.push_back( p[2] );
2064         }
2065
2066
2067         ExtractControlPoints2D *extractcontrolpoints2d = new ExtractControlPoints2D();
2068         extractcontrolpoints2d->SetContour( &vecX , &vecY , &vecZ );
2069
2070 //PROOFS
2071         /*if (methodRadiobox->GetSelection()==0){
2072                 extractcontrolpoints2d->GetInitialControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
2073         }
2074         if (methodRadiobox->GetSelection()==1){
2075                 extractcontrolpoints2d->GetControlPoints(  &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
2076         }
2077         if (methodRadiobox->GetSelection()==2){
2078                 extractcontrolpoints2d->SetSamplingControlPoints( sampling );
2079                 extractcontrolpoints2d->GetSamplingControlPoints(  &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
2080         }*/
2081
2082         if (method==0){
2083                 extractcontrolpoints2d->GetInitialControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
2084         }
2085         else if (method==1){
2086                 extractcontrolpoints2d->GetControlPoints(  &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
2087         }
2088         else if (method==2){
2089                 extractcontrolpoints2d->SetSamplingControlPoints( sampling );
2090                 extractcontrolpoints2d->GetSamplingControlPoints(  &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
2091         }
2092
2093         //--Adding contour to the system
2094
2095         std::vector<int> actualInstantVector;
2096         _instantPanel->getInstant( actualInstantVector );
2097         actualInstantVector[1]=z;
2098
2099         int j,sizeCtrPt = vecCtrlPointX.size();
2100         manualBaseModel *manModelContour =  kernelManager->factoryManualContourModel( typeofcontour );
2101         manModelContour->SetNumberOfPointsSpline( ((sizeCtrPt/100)+1)*100 );
2102         if (sizeCtrPt>=3){
2103                 for (j=0 ; j<sizeCtrPt ; j++)
2104                 {
2105                         manModelContour->AddPoint( vecCtrlPointX[j] , vecCtrlPointY[j] , vecCtrlPointZ[j]  );
2106                 } // for
2107                 std::string theName;
2108                 //theName = _modelManager->createOutline( manModelContour, actualInstantVector );
2109                 theName = kernelManager->createOutline( manModelContour, actualInstantVector );
2110                 bool addedModel = theName.compare("") != 0;
2111                 if( addedModel )
2112                 {
2113                         double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
2114                         _theViewPanel->getSpacing(spc);
2115                         //Adding the manualContourControler to interface objects structure
2116                         //Adding the manualViewContour to interface objects structure
2117                         //_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.
2118                         _theViewPanel->configureViewControlTo(theName, manModelContour, spc, typeofcontour);
2119                         //_theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc, typeofcontour ) ;
2120                 }       // if addedModel
2121         } // if sizeCtrPt
2122 }
2123 int wxContourMainFrame::GetImageDataSizeZ(){
2124         return _theViewPanel->GetImageDataSizeZ();
2125 }
2126
2127 void wxContourMainFrame::GetImageDataRange(double *range){
2128         _theViewPanel->GetImageDataRange(range);
2129 }
2130
2131 void wxContourMainFrame::onSegmentationAllSlice(int minZ,int maxZ,int isovalue,int sampling,int method){
2132         //JCP 20-10-08 Undo redo implementation
2133         saveState();
2134         //JCP 20-10-08 Undo redo implementation
2135
2136         wxBusyCursor wait;
2137         int                                     x                                       = _theViewPanel->GetX();
2138         int                                     y                                       = _theViewPanel->GetY();
2139         int z;
2140         double porcent;
2141         wxString tmpString;
2142         double totalZ = maxZ-minZ+1;
2143         for( z=minZ ; z<=maxZ ; z++ )
2144         {
2145                 porcent = 100.0* (z-minZ)/totalZ;
2146                 tmpString.Printf(_T("  %d %c            %d/%d            %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ,z );
2147                 interfMainPanel::getInstance()->setLabelSegmentationPanelVTK(tmpString);
2148                 //_staticTextSegmentation->SetLabel(tmpString);
2149                 SegmentationOneSlice( x,y,z,isovalue, sampling,method );
2150         }
2151         interfMainPanel::getInstance()->setLabelSegmentationPanelVTK(_T("   "));
2152         RefreshInterface();
2153 }
2154
2155
2156 //Creates a reference line to be used as the axis of the mirroring
2157 void wxContourMainFrame::referenceLine()
2158 {
2159         if (_refLineControl==NULL)
2160         {
2161                 wxBusyCursor wait;
2162                 double spc[3];
2163
2164                 vtkImageData *vtkimagedata = _theViewPanel->getImageData();
2165                 vtkimagedata->GetSpacing(spc);
2166
2167                 wxVtkBaseView * viewer2D = _theViewPanel->getWxVtkBaseView();
2168
2169                 _refLineControl = new manualLineControler();
2170                 _refLineModel   = new manualContourModelLine();
2171                 _refLineView = new manualViewLine();
2172                 _refLineView->SetModel( _refLineModel );
2173                 _refLineView->SetWxVtkBaseView( viewer2D );
2174                 _refLineView->SetRange( 2 );
2175                 _refLineView->SetZ( 1200 );
2176
2177                 _refLineView->SetSpacing(spc);
2178
2179                 _refLineView->SetColorNormalContour(0, 0, 1);
2180                 _refLineView->SetColorEditContour(0, 0.5, 0.5);
2181                 _refLineView->SetWidthLine(4);
2182
2183                 _refLineControl->SetModelView( _refLineModel , _refLineView );
2184                 vtkInteractorStyleBaseView* style = (vtkInteractorStyleBaseView*)viewer2D->GetInteractorStyleBaseView();
2185                 style->AddInteractorStyleMaracas( _refLineControl );
2186                 _refLineModel->SetCloseContour(false);
2187                 _refLineControl->CreateNewManualContour();
2188
2189 //AD: Inicializar el mirroring con una linea ya pintada
2190         /*
2191                 double z = _refLineControl->GetZ();
2192
2193                 int imageDim[3];
2194                 image->GetDimensions(imageDim);
2195                 double x = (double) imageDim[0]/2;
2196                 double y1 = (double) (imageDim[1]/2)+15;
2197                 double y2 = (double) (imageDim[1]/2)-15;
2198
2199                 _refLineControl->AddPoint(x,y1,z);
2200                 _refLineControl->AddPoint(x,y2,z);
2201                 _refLineControl->SetCompleteCreation(true);
2202
2203                 _refLineModel->AddPoint(x,y1,z);
2204                 _refLineModel->AddPoint(x,y2,z);
2205                 _refLineModel->UpdateSpline();
2206
2207                 _refLineView->UpdateViewPoint(0);
2208                 _refLineView->UpdateViewPoint(1);
2209         */
2210
2211                 _refLineControl->SetActive(true);
2212                 _refLineView->RefreshContour();
2213         }
2214 }
2215
2216 //Hides the referenceLine
2217 void wxContourMainFrame::refLineHide()
2218 {
2219         if (_refLineControl!=NULL)
2220         {
2221                 if (_refLineControl->GetActive())
2222                 {
2223                         _refLineView->RemoveCompleteContourActor();
2224                         _refLineControl->SetEditable(false);
2225                         _refLineControl->SetActive(false);
2226
2227                         RefreshInterface();
2228                 }
2229         }
2230 }
2231
2232 //Shows the referenceLine
2233 void wxContourMainFrame::refLineShow()
2234 {
2235         if (_refLineControl!=NULL)
2236         {
2237                 if (_refLineControl->GetActive()==false)
2238                 {
2239                         wxVtkBaseView * viewer2D = _theViewPanel->getWxVtkBaseView();
2240
2241                         _refLineView->SetModel( _refLineModel );
2242                         _refLineView->SetWxVtkBaseView( viewer2D );
2243                         _refLineView->SetRange( 2 );
2244                         _refLineView->SetZ( 1200 );
2245
2246                         _refLineControl->SetModelView( _refLineModel , _refLineView );
2247                         vtkInteractorStyleBaseView* style = (vtkInteractorStyleBaseView*)viewer2D->GetInteractorStyleBaseView();
2248                         style->AddInteractorStyleMaracas( _refLineControl );
2249                         _refLineControl->CreateNewManualContour();
2250                         _refLineControl->SetActive(true);
2251                         _refLineView->RefreshContour();
2252
2253                         RefreshInterface();
2254                 }
2255         }
2256 }
2257
2258 void wxContourMainFrame::refLineChangeWidth(int width)
2259 {
2260         _refLineView->SetWidthLine(width);
2261         _refLineView->RefreshContour();
2262
2263         RefreshInterface();
2264 }
2265
2266
2267 void wxContourMainFrame::onMirror()
2268 {
2269         //AD:02-09
2270         std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();
2271         std::vector<std::string> filterCurrentSelection;
2272
2273         std::vector<int> tempVector;
2274         _instantPanel->getInstant( tempVector );
2275     _performingOperation->reset();
2276         _performingOperation->setStartCommand( COPY );
2277         _performingOperation->setStartOperationInstantVector( tempVector );
2278         _performingOperation->setKeyNamesOperationElems( currentSelection );
2279
2280         char theStartCommand = _performingOperation->getStartCommand();
2281         if (  theStartCommand == COPY )
2282         {
2283                 //JCP 20-10-08 Undo redo implementation
2284                 saveState();
2285                 //JCP 20-10-08 Undo redo implementation
2286                 std::vector<int> tempVector;
2287                 _instantPanel->getInstant( tempVector );
2288                 _performingOperation->setEndOperationInstantVector ( tempVector );
2289                 std::vector<std::string> elems = _performingOperation->getKeyNamesOperationElems();
2290                 int i,size = elems.size();
2291                 for( i=0; i<size; i++ )
2292                 {
2293                         createMirrorContourOf( elems[i], tempVector, i>0 );
2294                 }
2295         }
2296
2297         //deleteContour( _refName );
2298         //_refName = "";
2299 }
2300
2301
2302 void wxContourMainFrame::showAxis(bool show)
2303 {
2304         _theViewPanel->SetVisibleAxis(show);
2305         _theViewPanel->Refresh();
2306 }
2307
2308
2309 void wxContourMainFrame::onRigidPressed(){
2310         std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();
2311         int elementsSelected = currentSelection.size();
2312
2313         if ( elementsSelected >= 1 ){
2314                 //JCP 20-10-08 Undo redo implementation
2315                 saveState();
2316                 //JCP 20-10-08 Undo redo implementation
2317
2318                 std::vector<int> tempVector;
2319                 _instantPanel->getInstant( tempVector );
2320                 Instant instant(&tempVector);
2321
2322                 int i , size=currentSelection.size();
2323                 for ( i=0 ; i<size ; i++ )
2324                 {
2325                         kernelManager->changeContourOfManager(currentSelection[i], &instant);
2326                 } // i
2327         }
2328 }
2329
2330 void wxContourMainFrame::onWidthOfContour(double width){
2331
2332         _theViewPanel->removeSceneContours();
2333         _theViewPanel->SetWidthContour(width);
2334
2335         //_theViewPanel->getSceneManager()->SetWidthContour( width );
2336
2337         RefreshInterface();
2338 }
2339
2340 int wxContourMainFrame::getColorWindow()
2341 {
2342         /*
2343         double range[2];
2344         vtkImageData * img = getImageData();
2345         img->GetScalarRange(range);
2346
2347         std::cout<<"Val 1: "<<range[0]<<" Val 2: "<<range[1]<<std::endl;
2348
2349         return (int)range[1];
2350         */
2351         return _theViewPanel->getColorWindow();
2352 }
2353
2354 int wxContourMainFrame::getWindowLevel()
2355 {
2356         /*
2357         double range[2];
2358         vtkImageData * img = getImageData();
2359         img->GetScalarRange(range);
2360
2361         std::cout<<"Val 1: "<<range[0]<<" Val 2: "<<range[1]<<std::endl;
2362
2363         return (int)range[1];
2364         */
2365         return _theViewPanel->getWindowLevel();
2366 }
2367
2368 void wxContourMainFrame::onBrigthnessColorWindowLevel(int colorwindow,int windowlevel){
2369         _theViewPanel->onBrigthnessColorWindowLevel(colorwindow, windowlevel);
2370
2371         RefreshInterface();
2372 }
2373
2374 void wxContourMainFrame::onInterpolation(bool interpolate){
2375         _theViewPanel->onInterpolation(interpolate);
2376         RefreshInterface();
2377 }
2378
2379 void wxContourMainFrame::onChangeInstant(std::string name,int actual){
2380         _instantPanel->setConceptValue( name, actual );
2381 }
2382
2383
2384 void wxContourMainFrame::resetAppend(){
2385         kernelManager->resetAppend();
2386
2387 }
2388
2389
2390 void wxContourMainFrame::onSpreadAdd(){
2391         std::vector<double> vecX;
2392         std::vector<double> vecY;
2393         std::vector<double> vecZ;
2394         _theViewPanel->GetPointsOfActualContour(&vecX , &vecY , &vecZ );
2395         std::vector<int> tempVector;
2396         _instantPanel->getInstant( tempVector );
2397         std::string val = kernelManager->onSpreadAdd(&vecX , &vecY , &vecZ, tempVector);
2398         interfMainPanel::getInstance()->appendStringSpread(val);
2399 }
2400
2401
2402 void wxContourMainFrame::onSpreadAddAll(){
2403 //EED02
2404         std::vector<int> tempVector;
2405         _instantPanel->getInstant( tempVector );
2406         int minZ,maxZ;
2407     minZ        = 0;
2408     maxZ        = interfMainPanel::getInstance()->GetImageDataSizeZ();
2409         int z;
2410         int sizeLstContourThings;
2411         for ( z=minZ ; z<=maxZ ; z++ )
2412         {
2413                 tempVector[1]=z;
2414                 Instant instant(&tempVector);
2415                 std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant( &instant );
2416                 sizeLstContourThings = lstContourThings.size();
2417                 if (sizeLstContourThings>=1)
2418         {
2419             std::vector<double> vecX;
2420             std::vector<double> vecY;
2421             std::vector<double> vecZ;
2422             ContourThing **contourthing = lstContourThings[0];
2423                         manualBaseModel *cModel                         =  (*contourthing)->getModel();
2424                         int i,size = cModel->GetNumberOfPointsSpline();
2425                         double x,y,z;
2426                         for (i=0; i<size; i++)
2427                         {
2428                                 cModel->GetSpline_i_Point(i, &x, &y, &z);
2429                                 vecX.push_back(x);
2430                                 vecY.push_back(y);
2431                                 vecZ.push_back(z);
2432                         } // for i
2433             std::string val = kernelManager->onSpreadAdd(&vecX , &vecY , &vecZ, tempVector);
2434             interfMainPanel::getInstance()->appendStringSpread(val);
2435         }// if sizeLstContourThings
2436     } // for z
2437 }
2438
2439
2440 void wxContourMainFrame::onSpreadGo(int type){
2441         //JCP 20-10-08 Undo redo implementation
2442         saveState();
2443         //JCP 20-10-08 Undo redo implementation
2444         wxBusyCursor wait;
2445         std::vector<double> vecCtrlPointX;
2446         std::vector<double> vecCtrlPointY;
2447         std::vector<double> vecCtrlPointZ;
2448         double  minZ,maxZ;
2449         int z;
2450
2451         std::vector<int> tempVector;
2452         _instantPanel->getInstant( tempVector );
2453 //              tempVector[1];
2454
2455         kernelManager->getMaxMinZ(&minZ,&maxZ);
2456 //JSTG_16-07-08_----------------------------------------------------------------
2457         //_contourPropagation->setInterpolationNumber(maxZ-minZ+1);
2458         kernelManager->CalculeSplinePropagation();
2459
2460         double          totalZ = maxZ-minZ+1;
2461         double          porcent;
2462         wxString        tmpString;
2463 //--------------------------------------------------------------------
2464         for ( z=(int)minZ ; z<=(int)maxZ ; z++ )
2465         {
2466                 porcent = 100.0* (z-minZ)/totalZ;
2467                 int numero = (int)(z-minZ+1)/(int)totalZ;
2468                 std::string stringtemp = "  "+kernelManager->intToString(porcent)+"%            "+kernelManager->intToString(numero)+"            "+kernelManager->intToString(z);
2469
2470                 interfMainPanel::getInstance()->setStringSpread(stringtemp);
2471
2472                 int typeofcontour = 1;
2473                 std::string theName;
2474                 manualBaseModel* manModelContour = kernelManager->GetPoints(z, type, &vecCtrlPointX,&vecCtrlPointY,&vecCtrlPointZ, theName,typeofcontour, tempVector);
2475
2476                 if( manModelContour!=NULL ){
2477                         double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
2478                         this->_theViewPanel->getSpacing(spc);
2479                         //Adding the manualContourControler to interface objects structure
2480                         //Adding the manualViewContour to interface objects structure
2481                         //_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.
2482                         _theViewPanel->configureViewControlTo( theName, manModelContour,spc,typeofcontour ) ;
2483                 } // if addedModel
2484         }
2485         if(z > maxZ){
2486                 porcent = 100.0;
2487                 int numero = (int)(z-minZ+1)/(int)totalZ;
2488                 std::string stringtemp = "  "+kernelManager->intToString(porcent)+"%            "+kernelManager->intToString(numero)+"            "+kernelManager->intToString(z);
2489
2490                 interfMainPanel::getInstance()->setStringSpread(stringtemp);
2491         }// for z
2492         //RefreshInterface();
2493 }
2494
2495 void wxContourMainFrame::getInstantVector(std::vector<int>& tempVector){
2496
2497 }
2498
2499 std::vector<std::string> wxContourMainFrame::getOutlinesName(int slide){
2500         std::vector<int> tempVector;
2501         _instantPanel->getInstant(tempVector);
2502         //Asignation of slide number should be different ex by name
2503         tempVector[1]=slide;
2504         return kernelManager->getOutlinesNameAtInstant(tempVector);
2505 }
2506
2507
2508 void wxContourMainFrame::SetScalarRange(int grayRangeMin, int grayRangeMax)
2509 {
2510         _contourextractdata->SetScalarRange(grayRangeMin,grayRangeMax);
2511 }
2512
2513
2514 void wxContourMainFrame::onInformationContourLabels(int typeContourGroup,int selection,int minimumZ,int maximumZ,int grayRangeMin, int grayRangeMax)
2515 {
2516 //EED01Juillet2009      GenerateContourExtractData();
2517
2518         wxString tempString;
2519         int maxContourGroup     =       0;
2520
2521         _contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
2522
2523         std::vector<manualBaseModel*> lstManConMod;
2524         std::vector<manualBaseModel*> lstManConModTmp;
2525         std::vector<manualBaseModel*> lstManConModExp;
2526         std::vector<double> pLstValue;
2527         std::vector<double> pLstValuePosX;
2528         std::vector<double> pLstValuePosY;
2529         std::vector<double> pLstValuePosZ;
2530
2531         int             resultSize;
2532         int             resultGrayRangeCount;
2533         double  resultMin;
2534         double  resultMax;
2535         double  resultAverage;
2536         double  resultStandardeviation;
2537
2538         std::vector<int> tempVector;
2539         _instantPanel->getInstant( tempVector );
2540
2541 //EED01Juillet2009      vtkImageData *imagedata = _theViewPanel->getImageData();
2542 //      int sizeZ = _theViewPanel->GetImageDataSizeZ();
2543         int z;
2544         int ii,sizeLstContourThings;
2545
2546
2547         int minZ,maxZ;
2548         double totalZ;
2549         double porcent;
2550         wxString tmpString;
2551
2552
2553         if (selection==0 ) // actual slice
2554         {
2555                 int actualSlice = tempVector[1];
2556                 minZ    = actualSlice;
2557                 maxZ    = actualSlice;
2558         }       else  {  // slice range
2559                 minZ    = minimumZ;
2560                 maxZ    = maximumZ;
2561         }
2562
2563
2564         totalZ  = maxZ-minZ+1;
2565 //EED01Juillet2009      _contourextractdata->SetImage( imagedata);
2566
2567         _contourextractdata->InitVolumeStatistics();
2568
2569 // For each slice..
2570         for ( z=minZ ; z<=maxZ ; z++ )
2571         {
2572
2573                 porcent = 100.0* (z-minZ)/totalZ;
2574                 tmpString.Printf(_T("  %d %c            %d/%d             %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
2575
2576                 interfMainPanel::getInstance()->setStringInfoPanel(tmpString);
2577                 //_staticTextInformation->SetLabel(tmpString);
2578
2579                 //Extraction data from contours of each slice
2580                 _contourextractdata->SetZtoBeAnalys(z);
2581
2582                 tempVector[1]=z;
2583                 Instant instant(&tempVector);
2584                 std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant( &instant );
2585                 sizeLstContourThings = lstContourThings.size();
2586
2587                 lstManConMod.clear();
2588                 for (ii=0 ; ii<sizeLstContourThings ; ii++)
2589                 {
2590                         ContourThing **contourthing = lstContourThings[ii];
2591                         lstManConMod.push_back( (*contourthing)->getModel() );
2592                 }
2593
2594                 lstManConModExp =  kernelManager->ExploseEachModel( lstManConMod );
2595
2596                 tempString.Printf(_T("%d - %d"),z, sizeLstContourThings);
2597                 interfMainPanel::getInstance()->setRowLabelInfoPanel(z, tempString);
2598                 //_grid->SetRowLabelValue(z, tempString );
2599 //EED004
2600                 int iContourGroup,sizeContourGroup;
2601                 if (typeContourGroup==3) // contour separete
2602                 {
2603                         sizeContourGroup=lstManConModExp.size();
2604                         if ( maxContourGroup<sizeContourGroup )
2605                         {
2606                                 maxContourGroup=sizeContourGroup;
2607                         }
2608                 } else {  // contour AND OR XOR
2609                         sizeContourGroup=1;
2610                         maxContourGroup=1;
2611                 }
2612
2613                 int tmpIntA;
2614
2615                 for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
2616                         lstManConModTmp.clear();
2617
2618
2619
2620                         if (typeContourGroup==3) // contour separete
2621                         {
2622                                 lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
2623                         } else {  // contour AND OR XOR
2624                                 lstManConModTmp = lstManConModExp;
2625                         }
2626
2627                         _contourextractdata->SetLstManualContourModel( lstManConModTmp );
2628                         _contourextractdata->SetScalarRange(grayRangeMin,grayRangeMax);
2629
2630                         pLstValue.clear();
2631                         pLstValuePosX.clear();
2632                         pLstValuePosY.clear();
2633                         pLstValuePosZ.clear();
2634
2635
2636                         int numberOfPixels;
2637                         _contourextractdata->GetValuesInsideCrown(  &numberOfPixels,
2638                                                                                                                 &pLstValue,
2639                                                                                                                 &pLstValuePosX,
2640                                                                                                                 &pLstValuePosY,
2641                                                                                                                 &pLstValuePosZ);
2642
2643                         resultSize=numberOfPixels;
2644                         // Statistics of each slice.
2645                         _contourextractdata->Statistics( &pLstValue,
2646                                                                                         grayRangeMin,
2647                                                                                         grayRangeMax,
2648                                                                                         &resultGrayRangeCount,
2649                                                                                         &resultSize,
2650                                                                                         &resultMin,
2651                                                                                         &resultMax,
2652                                                                                         &resultAverage,
2653                                                                                         &resultStandardeviation);
2654
2655                         if (interfMainPanel::getInstance()->getNumberColsInformationPanel()<_numberOfVariablesStatistics*(iContourGroup+1)  )
2656                         {
2657                                 interfMainPanel::getInstance()->appendColsInformationPanel(_numberOfVariablesStatistics);
2658                         }
2659
2660                         tmpIntA=_numberOfVariablesStatistics*iContourGroup ;
2661
2662                         tempString.Printf(_T("%d"),numberOfPixels);
2663
2664                         interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA, tempString);
2665
2666                         tempString.Printf(_T("%d"),resultGrayRangeCount);
2667                         interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+1, tempString);
2668
2669                         tempString.Printf(_T("%f"),resultMin);
2670                         interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+2, tempString);
2671
2672                         tempString.Printf(_T("%f"),resultMax);
2673                         interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+3, tempString);
2674
2675                         tempString.Printf(_T("%f"),resultAverage);
2676                         interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+4, tempString);
2677
2678                         tempString.Printf(_T("%f"),resultStandardeviation);
2679                         interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+5, tempString);
2680
2681
2682                 } // for iContourGroup
2683         } // for z
2684
2685         // Print Volume Statistics
2686
2687
2688         int             vol_rCountRange;
2689         int             vol_rsize;
2690         double  vol_minValue;
2691         double  vol_maxValue;
2692         double  vol_average;
2693         double  vol_standardeviation;
2694
2695         if (selection!=0 ) // actual slice
2696         {
2697
2698                 _contourextractdata->GetVolumeStatistics(&vol_rCountRange, &vol_rsize,
2699                                                                                                  &vol_minValue, &vol_maxValue,
2700                                                                                                  &vol_average, &vol_standardeviation);
2701
2702                 interfMainPanel::getInstance()->setRowLabelInfoPanel(maxZ+2, _T("Total:"));
2703
2704                 tempString.Printf(_T("%d"),vol_rsize);
2705                 interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 0, tempString);
2706
2707                 tempString.Printf(_T("%d"),vol_rCountRange);
2708                 interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 1, tempString);
2709
2710                 tempString.Printf(_T("%f"),vol_minValue);
2711                 interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 2, tempString);
2712
2713                 tempString.Printf(_T("%f"),vol_maxValue);
2714                 interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 3, tempString);
2715
2716                 tempString.Printf(_T("%f"),vol_average);
2717                 interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 4, tempString);
2718
2719                 tempString.Printf(_T("%f"),vol_standardeviation);
2720                 interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 5, tempString);
2721         }
2722         //-----------------------------------------
2723
2724         int iTitleGroup;
2725         wxString tmpTitleString;
2726         int tmpIntB;
2727         for ( iTitleGroup=0 ; iTitleGroup<maxContourGroup ; iTitleGroup++ )
2728         {
2729                 tmpIntB =_numberOfVariablesStatistics*iTitleGroup;
2730                 tmpTitleString.Printf(_T("%d-Size Data"),iTitleGroup);
2731                 interfMainPanel::getInstance()->setColLableInfoPanel(tmpIntB + 0, tmpTitleString);
2732
2733                 interfMainPanel::getInstance()->setColLableInfoPanel(tmpIntB + 0, tmpTitleString );
2734                 interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 1, _T("Size Range") );
2735                 interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 2, _T("Min") );
2736                 interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 3, _T("Max") );
2737                 interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 4, _T("Average") );
2738                 interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 5, _T("St.Dev.") );
2739                 interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 6, _T(" ") );
2740         }// for title
2741         interfMainPanel::getInstance()->setStringInfoPanel( _T("") );
2742 }
2743
2744 //AD: 29-05-09
2745 void wxContourMainFrame::onSaveResults(std::string directory,std::string namefile, std::string filename,
2746         int typeContourGroup, int selection, int minZ, int maxZ, bool XYZValues, bool contourImage, bool statistics)
2747 {
2748         if (XYZValues)
2749         {
2750                 SaveValuesXYZ( directory , namefile, typeContourGroup );
2751         }
2752
2753         if (contourImage)
2754         {
2755                 vtkImageData * mask;
2756                 vtkImageData * value;
2757                 this->getMaskValue(&mask, &value, typeContourGroup,selection,minZ,maxZ);
2758                 this->SaveImageResult( directory , namefile, mask, value);
2759         }
2760
2761         if (statistics)
2762         {
2763                 std::ostringstream name;
2764                 name << filename << ".xls";
2765
2766
2767                 FILE *pFile=fopen(name.str().c_str(),"w+");
2768
2769
2770                 wxString tmpString;
2771                 int i,j,maxX;
2772
2773 //              int sizeZ = _theViewPanel->GetImageDataSizeZ();
2774 //              int maxY=sizeZ+2;
2775
2776                 maxX= interfMainPanel::getInstance()->getNumberColsInformationPanel();//this->_grid->GetNumberCols();
2777
2778                 // -- Title --
2779                 int iTitle,sizeTitle = (maxX / _numberOfVariablesStatistics);
2780                 for ( iTitle=0; iTitle<sizeTitle ; iTitle++)
2781                 {
2782                                 // fprintf(pFile,"-- \t %d-Size \t SizeRange \t Min \t Max \t Ave \t StDv \t" , iTitle,tmpString.c_str() );
2783                                 fprintf(pFile,"slice\t %d-Size \t SizeRange \t Min \t Max \t Ave \t StDv \t" , iTitle );
2784                 }
2785                 fprintf(pFile,"\n\n" );
2786
2787
2788
2789                 if (selection==0 ) // actual slice
2790                 {
2791                         std::vector<int> tempVector;
2792                         _instantPanel->getInstant( tempVector );
2793                         int actualSlice = tempVector[1];
2794                         minZ    = actualSlice;
2795                         maxZ    = actualSlice;
2796                 }
2797
2798                 // Stadistics...
2799                 for ( j=minZ; j<=maxZ ; j++)
2800                 {
2801                         fprintf(pFile,"%d\t" , j );
2802                         for (i=0 ; i<maxX ; i++){
2803                                 tmpString = interfMainPanel::getInstance()->getCellValue(j, i);//_grid->GetCellValue( j , i );
2804                                 fprintf(pFile,"%s\t" , (const char *)(tmpString.mb_str()) );
2805                         } // for i
2806                         fprintf(pFile,"\n"  );
2807                 } // for j
2808
2809
2810                 // Total of stadistics.....
2811                 if (selection!=0)
2812                 {
2813                         fprintf(pFile,"\n Total:\t"  );
2814                         for (i=0 ; i<maxX ; i++){
2815                                 tmpString = interfMainPanel::getInstance()->getCellValue(maxZ+2, i);//_grid->GetCellValue( maxZ+2 , i );
2816                                 fprintf(pFile,"%s\t" , (const char *)(tmpString.mb_str()) );
2817                         } // for i
2818                         fprintf(pFile,"\n"  );
2819                 }
2820
2821                 fclose(pFile);
2822         }
2823 }
2824
2825 //AD: 29-05-09
2826 void wxContourMainFrame::SaveValuesXYZ(std::string directory,std::string namefile,int typeContourGroup)
2827 {
2828         wxBusyCursor wait;
2829 //EED01Juillet2009      GenerateContourExtractData();
2830
2831         //int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
2832         _contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
2833
2834         std::vector<manualBaseModel*> lstManConMod;
2835         std::vector<manualBaseModel*> lstManConModTmp;
2836         std::vector<manualBaseModel*> lstManConModExp;
2837         std::vector<double> pLstValue;
2838         std::vector<double> pLstValuePosX;
2839         std::vector<double> pLstValuePosY;
2840         std::vector<double> pLstValuePosZ;
2841
2842         std::vector<int> tempVector;
2843         _instantPanel->getInstant( tempVector );
2844
2845 //EED01Juillet2009      vtkImageData *imagedata = _theViewPanel->getSceneManager()->GetImageData();
2846         int sizeZ = _theViewPanel->getSceneManager()->GetImageDataSizeZ();
2847         int z;
2848         int ii,sizeLstContourThings;
2849
2850
2851         int minZ,maxZ;
2852         double totalZ;
2853         double porcent;
2854         wxString tmpString;
2855         minZ    = 0;// _mbarrange->GetStart();
2856         maxZ    = sizeZ;//_mbarrange->GetEnd();
2857         totalZ  = maxZ-minZ+1;
2858
2859 //EED01Juillet2009      _contourextractdata->SetImage( imagedata);
2860
2861 // For each slice..
2862         for ( z=0 ; z<sizeZ ; z++)
2863         {
2864
2865                 porcent = 100.0* (z-minZ)/totalZ;
2866
2867                 tmpString.Printf(_T("Saving Values"));
2868                 tmpString.Printf(_T("  %d %c            %d/%d             %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
2869                 interfMainPanel::getInstance()->setStringInfoPanel(tmpString);
2870                 //_staticTextInformation->SetLabel(tmpString);
2871
2872
2873                 //Extraction data from contours of each slice
2874                 _contourextractdata->SetZtoBeAnalys( z);
2875
2876                 tempVector[1]=z;
2877                 Instant instant(&tempVector);
2878                 std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant(&instant);//this->_modelManager->getOutlinesAtInstant( &instant );
2879                 sizeLstContourThings = lstContourThings.size();
2880
2881                 lstManConMod.clear();
2882                 for (ii=0 ; ii<sizeLstContourThings ; ii++)
2883                 {
2884                         ContourThing **contourthing = lstContourThings[ii];
2885                         lstManConMod.push_back( (*contourthing)->getModel() );
2886                 }
2887                 lstManConModExp =  kernelManager->ExploseEachModel( lstManConMod );
2888
2889
2890 //EED004
2891
2892                 int iContourGroup,sizeContourGroup;
2893                 if (typeContourGroup==3) // contour separete
2894                 {
2895                         sizeContourGroup=lstManConModExp.size();
2896                 } else {  // contour AND OR XOR
2897                         sizeContourGroup=1;
2898                 }
2899
2900                 for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
2901                         lstManConModTmp.clear();
2902                         if (typeContourGroup==3) // contour separete
2903                         {
2904                                 lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
2905                         } else {  // contour AND OR XOR
2906                                 lstManConModTmp = lstManConModExp;
2907                         }
2908
2909                         _contourextractdata->SetLstManualContourModel( lstManConModTmp );
2910
2911                         pLstValue.clear();
2912                         pLstValuePosX.clear();
2913                         pLstValuePosY.clear();
2914                         pLstValuePosZ.clear();
2915                         int numberOfPixels;
2916                         _contourextractdata->GetValuesInsideCrown(      &numberOfPixels,
2917                                                                                                                 &pLstValue,
2918                                                                                                                 &pLstValuePosX,
2919                                                                                                                 &pLstValuePosY,
2920                                                                                                                 &pLstValuePosZ);
2921
2922                         std::string temp = directory + "/" + namefile + "-slice";
2923                         temp = temp + kernelManager->intToString(z) + "-cont" + kernelManager->intToString(iContourGroup);
2924                         temp = temp + ".txt";
2925
2926                         // LG 14/01/09 : using crea
2927                         wxString filename = crea::std2wx(temp);
2928                         /*filename.Printf(_T("%s"),directory.c_str());
2929                         filename.append(_T("\\"));
2930                         filename.append(_T("%s"),namefile.c_str());
2931                         filename.append(_T("-slice"));
2932                         filename.append(_T("%d"),z);
2933                         filename.append(_T("-cont"));
2934                         filename.append(_T("%d"),iContourGroup);
2935                         filename.append(_T(".txt"));*/
2936                         //                      filename.Printf(temp.c_str());
2937
2938
2939
2940                         FILE *pFile=fopen((const char *)filename.mb_str(),"w+");
2941                         fprintf(pFile,"value \t x \t y \t z\n"  );
2942                         int iLstValue,sizeLstValue=pLstValue.size();
2943                         for (iLstValue=0 ; iLstValue<sizeLstValue ; iLstValue++ )
2944                         {
2945                                 fprintf(pFile,"%f\t %f\t %f\t %f\n", (float)pLstValue[iLstValue] , (float)pLstValuePosX[iLstValue], (float)pLstValuePosY[iLstValue], (float)z );
2946                         }
2947                         fclose(pFile);
2948                 } // for  iContourGroup
2949         } // for z
2950         interfMainPanel::getInstance()->setStringInfoPanel(_T(""));
2951         //_staticTextInformation->SetLabel( _T("") );
2952
2953 }
2954
2955 void wxContourMainFrame::getMaskValue(vtkImageData ** mask,vtkImageData ** value,int typeContourGroup, int selection, int minZ, int maxZ){
2956         wxBusyCursor wait;
2957 //EED01Juillet2009      GenerateContourExtractData();
2958
2959         //int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
2960         if (typeContourGroup==3)
2961         {
2962                 typeContourGroup=1;
2963         }
2964         _contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
2965
2966         std::vector<manualBaseModel*> lstManConMod;
2967         std::vector<manualBaseModel*> lstManConModTmp;
2968         std::vector<manualBaseModel*> lstManConModExp;
2969
2970         std::vector<int> tempVector;
2971         _instantPanel->getInstant( tempVector );
2972
2973     vtkImageData *imagedata = _theViewPanel->getImageData();
2974         int ext[6];
2975         imagedata->GetExtent(ext);
2976         int sizeZimage = ext[5]-ext[4]+1;
2977         int z;
2978         int ii,sizeLstContourThings;
2979
2980
2981         double totalZ;
2982         double porcent;
2983
2984         wxString tmpString;
2985
2986
2987         if (selection==0 ) // actual slice
2988         {
2989                 int actualSlice = tempVector[1];
2990                 minZ    = actualSlice;
2991                 maxZ    = actualSlice;
2992         }
2993
2994         totalZ  = maxZ-minZ;
2995
2996 //EED01Juillet2009      _contourextractdata->SetImage( imagedata);
2997
2998         // cleanning image before range
2999         for (z=0; z<minZ; z++){
3000                 _contourextractdata->ResetImageResult(z);
3001         }
3002         // cleanning image after range
3003         for (z=maxZ+1; z<sizeZimage; z++){
3004                 _contourextractdata->ResetImageResult(z);
3005         }
3006
3007
3008 // For each slice..
3009         for ( z=minZ ; z<=maxZ ; z++)
3010         {
3011
3012                 porcent = 100.0* (z-minZ)/totalZ;
3013                 tmpString.Printf(_T("Saving Values"));
3014                 tmpString.Printf(_T("%d %c            %d/%d             %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
3015                 interfMainPanel::getInstance()->setStringInfoPanel(tmpString);
3016
3017                 //Extraction data from contours of each slice
3018                 _contourextractdata->SetZtoBeAnalys( z);
3019
3020                 tempVector[1]=z;
3021                 Instant instant(&tempVector);
3022                 std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant( &instant );
3023                 sizeLstContourThings = lstContourThings.size();
3024
3025                 lstManConMod.clear();
3026                 for (ii=0 ; ii<sizeLstContourThings ; ii++)
3027                 {
3028                         ContourThing **contourthing = lstContourThings[ii];
3029                         lstManConMod.push_back( (*contourthing)->getModel() );
3030                 }
3031                 lstManConModExp =  kernelManager->ExploseEachModel( lstManConMod );
3032
3033
3034                 int iContourGroup,sizeContourGroup;
3035                 if (typeContourGroup==3) // contour separete
3036                 {
3037                         sizeContourGroup=lstManConModExp.size();
3038                 } else {  // contour AND OR XOR
3039                         sizeContourGroup=1;
3040                 }
3041
3042                 for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
3043                         lstManConModTmp.clear();
3044                         if (typeContourGroup==3) // contour separete
3045                         {
3046                                 lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
3047                         } else {  // contour AND OR XOR
3048                                 lstManConModTmp = lstManConModExp;
3049                         }
3050
3051                         _contourextractdata->SetLstManualContourModel( lstManConModTmp );
3052                         _contourextractdata->CalculateImageResult(); // with actual Z
3053
3054                 } // for  iContourGroup
3055         } // for z
3056
3057         (*value) = _contourextractdata->GetVtkImageValueResult();
3058         (*mask)  = _contourextractdata->GetVtkImageMaskResult();
3059
3060 }
3061
3062 void wxContourMainFrame::SaveImageResult(std::string directory,std::string namefile, vtkImageData* mask,vtkImageData* value)
3063 {
3064
3065         double spc[3];
3066         kernelManager->GetSpacing(spc,0);   // returns the spacing of the first image
3067
3068         std::string temp = directory + "/" + namefile + "-image-Value.mhd";
3069
3070         wxString filename = crea::std2wx(temp);
3071
3072 // Image Value
3073
3074         vtkImageChangeInformation *valueChInfo = vtkImageChangeInformation::New();
3075         valueChInfo->SetInput(value);
3076         valueChInfo->SetSpacingScale(spc);
3077         vtkMetaImageWriter *writerValueImage = vtkMetaImageWriter::New( );
3078         writerValueImage->SetInput( valueChInfo->GetOutput() );
3079         writerValueImage->SetFileName( (const char *)filename.mb_str() );
3080         writerValueImage->SetFileDimensionality( 3 );
3081         writerValueImage->SetCompression(false);
3082         writerValueImage->Write( );
3083
3084 // Image Mask
3085         temp = directory + "/" + namefile + "-image-Mask.mhd";
3086
3087         // LG 14/01/09 : using crea
3088         filename = crea::std2wx(temp);
3089         //      filename.Printf(_T(temp.c_str()));
3090
3091
3092         vtkImageChangeInformation *maskChInfo = vtkImageChangeInformation::New();
3093         maskChInfo->SetInput(mask);
3094         maskChInfo->SetSpacingScale(spc);
3095         vtkMetaImageWriter *writerMaskImage = vtkMetaImageWriter::New( );
3096         writerMaskImage->SetInput( maskChInfo->GetOutput() );
3097         writerMaskImage->SetFileName( (const char *)filename.mb_str() );
3098         writerMaskImage->SetFileDimensionality( 3 );
3099         writerMaskImage->SetCompression(false);
3100         writerMaskImage->Write( );
3101
3102         interfMainPanel::getInstance()->setStringInfoPanel( _T("") );
3103
3104 }
3105
3106
3107
3108 void wxContourMainFrame::onChangeInstantInstantPanel(std::string name,int value, int minshow, int maxshow){
3109         if( name.compare( _theViewPanel->getVerticalConceptName() ) == 0){
3110                 _theViewPanel->setActualVertical( value);
3111         }
3112         else if( name.compare( _theViewPanel->getHorizontalConceptName() ) == 0|| _instantPanel->getIfConceptCheckedAt( name, 0 ) )     {
3113                 _theViewPanel->setHorizontalConcept( name, minshow, maxshow, minshow, maxshow, value);
3114         }
3115
3116         changeInstant();
3117 }
3118
3119 void wxContourMainFrame::onSnakePressed(){
3120         std::vector<double> vecX;
3121         std::vector<double> vecY;
3122         std::vector<double> vecZ;
3123         _theViewPanel->GetPointsOfActualContour( &vecX , &vecY , &vecZ );
3124
3125         if (vecX.size()!=0){
3126                 std::vector<int> tempVector;
3127                 _instantPanel->getInstant( tempVector );
3128                 int i,size=vecZ.size();
3129                 int actualSlice = tempVector[1];
3130                 for ( i=0 ; i<size ; i++ )
3131                 {
3132                         vecZ[i] = actualSlice;
3133                 } // for
3134
3135                 wxDialog* dialog = new wxDialog(this, -1, wxString(_T("Snake")));
3136                 wxPanel* panel = new wxPanel(dialog,-1);
3137                 //              wxStaticText* sttext = new wxStaticText(panel, -1, wxString(_T("Panel para snake")));
3138          new wxStaticText(panel, -1, wxString(_T("Panel para snake")));
3139                 dialog->ShowModal();
3140         } // if
3141
3142 }
3143
3144 void wxContourMainFrame::saveFileWithContoursAutomatique(){
3145         std::string filename = kernelManager->getCurrentFileName();
3146         if(filename.compare("")!=0){
3147                 saveFileWithContours(filename);
3148         }else{
3149                 onSave();
3150         }
3151 }
3152 void wxContourMainFrame::ShowToolsPanel(bool show){
3153         _pannew->Show(show);
3154 }
3155
3156
3157
3158 void wxContourMainFrame::SetContourGroup(int contourGroup)
3159 {
3160         _contourGroup = contourGroup;
3161 }
3162
3163
3164 wxPanel *wxContourMainFrame::getMaskImageViewPanel(wxWindow *parent)
3165 {
3166
3167         if      (_viewMaskImagePanel==NULL)
3168         {
3169                 _contourextractdata = new ContourExtractData(true);
3170                 _contourextractdata->SetImage( _theViewPanel->getImageData() );
3171 //              double range[2];
3172 //              _theViewPanel->getImageData()->GetScalarRange(range);
3173                 //int min = (int)floor (range[0]);
3174                 //int max = (int)ceil (range[1]);
3175                 int min = 254;
3176                 int max = 256;
3177                 _viewMaskImagePanel = new ThresholdImageViewPanel( parent, -1, -1 , 0);
3178                 _viewMaskImage = new ThresholdImageView();
3179                 _viewMaskImage->SetImage(_contourextractdata->GetVtkImageMaskResult() );
3180                 _viewMaskImage->SetminMaxValue( min, max);
3181                 _viewMaskImage->SetBaseColor( 0,0,1 );
3182                 _viewMaskImagePanel->SetThresholdImageView( _viewMaskImage );
3183                 _viewMaskImage->SetwxVtkBaseView( _theViewPanel->getWxVtkBaseView() );
3184         }
3185         return _viewMaskImagePanel;
3186 }
3187
3188
3189 wxPanel *wxContourMainFrame::getColorLayerImageViewPanel(wxWindow *parent)
3190 {
3191         if      (_viewColorLayerImagePanel==NULL)
3192         {
3193                 double range[2];
3194                 _theViewPanel->getImageData()->GetScalarRange(range);
3195                 int min = (int)floor (range[0]);
3196                 int max = (int)ceil (range[1]);
3197                 _viewColorLayerImagePanel = new ColorLayerImageViewPanel( parent, min, max , 1);
3198                 _viewColorLayerImage = new ColorLayerImageView();
3199 //              _viewColorLayerImage->SetImage( _theViewPanel->getImageData() );
3200                 _viewColorLayerImage->SetImage( NULL );
3201                 _viewColorLayerImagePanel->SetColorLayerImageView( _viewColorLayerImage );
3202                 _viewColorLayerImage->SetwxVtkBaseView( _theViewPanel->getWxVtkBaseView() );
3203         }
3204         return _viewColorLayerImagePanel;
3205 }
3206
3207
3208 wxPanel *wxContourMainFrame::getThresholdImageViewPanel(wxWindow *parent)
3209 {
3210         if      (_viewThresholdImagePanel==NULL)
3211         {
3212                 double range[2];
3213                 _theViewPanel->getImageData()->GetScalarRange(range);
3214                 int min = (int)floor (range[0]);
3215                 int max = (int)ceil (range[1]);
3216                 _viewThresholdImagePanel = new ThresholdImageViewPanel( parent, min, max , 1);
3217                 _viewThresholdImage = new ThresholdImageView();
3218                 _viewThresholdImage->SetImage( _theViewPanel->getImageData() );
3219                 _viewThresholdImage->SetminMaxValue( min, max);
3220                 _viewThresholdImage->SetBaseColor( 1,0,0 );
3221                 _viewThresholdImagePanel->SetThresholdImageView( _viewThresholdImage );
3222                 _viewThresholdImage->SetwxVtkBaseView( _theViewPanel->getWxVtkBaseView() );
3223         }
3224         return _viewThresholdImagePanel;
3225 }
3226
3227 //CMRU 17-08-09-----------------------------------------------------------------------------------------------
3228 int wxContourMainFrame::getType ()
3229 {
3230         int tipo = 0;
3231         std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();
3232
3233         if(!currentSelection.empty())
3234         {
3235                 std::string cloneName = currentSelection [0];
3236                 manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(cloneName);
3237                 tipo = manualModel-> GetTypeModel();
3238         }
3239         return tipo;
3240 }
3241
3242 double wxContourMainFrame::getContourSizeInPixels()
3243 {
3244         double contourSize = 0;
3245
3246         std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();        if(!currentSelection.empty())
3247         if(!currentSelection.empty())
3248         {
3249                 std::string cloneName = currentSelection [0];
3250
3251                 manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(cloneName);//_modelManager->getOutlineByKeyName( cloneName )->getModel();
3252                 contourSize = manualModel-> GetPathSize();
3253         }
3254         return contourSize;
3255 }
3256 manualBaseModel * wxContourMainFrame::getContour ()
3257 {
3258         std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();
3259
3260         if(!currentSelection.empty())
3261         {
3262                 std::string cloneName = currentSelection [0];
3263                 manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(cloneName);//_modelManager->getOutlineByKeyName( cloneName )->getModel();
3264                 return manualModel;
3265         }
3266         return NULL;
3267 }
3268 void wxContourMainFrame::onPrintLabel (wxString label, manualBaseModel* manualModel)
3269 {
3270         std::string labelAscii(label.ToAscii());
3271         int pos = labelAscii.find(" ");
3272
3273         int j;
3274
3275         for (j=0 ; pos != string::npos;j++)
3276         {
3277                 labelAscii.replace( pos, 1, "_" );
3278                 pos= labelAscii.find(" ");
3279         }
3280
3281         manualModel -> SetLabel(labelAscii);
3282 }
3283 void wxContourMainFrame::onInsertCalculation(manualBaseModel* manualModel)
3284 {
3285         double sizeInPixel = manualModel ->GetPathSize();
3286         double onePixelRealSize = interfMainPanel::getInstance()->GetPixelValue();;
3287         double realContourSize = sizeInPixel*onePixelRealSize;
3288         manualModel ->SetRealSize(realContourSize);
3289 }
3290
3291 double wxContourMainFrame::onePixelSize( double value)
3292 {
3293         return _onePixelSize = value;
3294 }
3295
3296 std::string wxContourMainFrame::GetFileLocation()
3297 {
3298         return _fileLocation;
3299 }
3300
3301 void wxContourMainFrame::SetFileLocation(std::string newFileLocation)
3302 {
3303         _fileLocation = newFileLocation;
3304         std::cout<<"GETFILELOCATION:"<<_fileLocation<<std::endl;
3305 }
3306 //------------------------------------------------------------------------------------------------------------
3307
3308
3309
3310
3311
3312
3313
3314
3315 void wxContourMainFrame::FlipSelectedContours(int flipDirection)
3316 {
3317         printf("EED wxContourMainFrame::FlipSelectedContours  flipDirection=%d  \n",  flipDirection );
3318         FlipLstOfContours(
3319                             (std::vector<std::string>)_theViewPanel->getSceneManager()->getSelectedObjects() ,
3320                             flipDirection
3321                           );
3322
3323 }
3324
3325 void wxContourMainFrame::FlipActualSliceContours(int flipDirection)
3326 {
3327         printf("EED wxContourMainFrame::FlipActualSliceContours  flipDirection=%d  \n",  flipDirection );
3328         FlipLstOfContours(
3329                             (std::vector<std::string>)_theViewPanel->getSceneManager()->GetlstContoursNameActualSlice() ,
3330                             flipDirection
3331                           );
3332 }
3333
3334 void wxContourMainFrame::FlipAllContours(int flipDirection)
3335 {
3336         printf("EED wxContourMainFrame::FlipAllContours  flipDirection=%d  \n",  flipDirection );
3337         FlipLstOfContours(
3338                             kernelManager->GetLstNameThings() ,
3339                             flipDirection
3340                           );
3341 }
3342
3343 void wxContourMainFrame::FlipLstOfContours(std::vector<std::string> lstNameThings, int flipDirection)
3344 {
3345         int ext[6];
3346         getImageData()->GetExtent(ext);
3347         int sizeX = ext[1]-ext[0];
3348         int sizeY = ext[3]-ext[2];
3349
3350
3351         int i,sizeLstNameThings;
3352         int ii,sizeLstPoints;
3353
3354         sizeLstNameThings       = lstNameThings.size();
3355         for (i=0 ; i<sizeLstNameThings ; i++)
3356         {
3357                 printf("EED wxContourMainFrame::FlipAllContours contour=%d \n", i );
3358                 manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(lstNameThings[i]);
3359                 if (flipDirection==0)
3360                 {
3361                         manualModel->Transform_Ax_Plus_B(-1,sizeX,1,0 );
3362                 } else {
3363                         manualModel->Transform_Ax_Plus_B(1,0,-1,sizeY );
3364                 }
3365         }// for i  list of Things
3366
3367         //-- Static Contours
3368
3369         lstNameThings           = kernelManager->GetLstNameThingsStatic();
3370         sizeLstNameThings       = lstNameThings.size();
3371         for (i=0 ; i<sizeLstNameThings ; i++)
3372         {
3373                 manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(lstNameThings[i]);
3374                 if (flipDirection==0)
3375                 {
3376                         manualModel->Transform_Ax_Plus_B(-1,sizeX,1,0 );
3377                 } else {
3378                         manualModel->Transform_Ax_Plus_B(1,0,-1,sizeY );
3379                 }
3380         }// for i  list of static things
3381 }
3382
3383 void wxContourMainFrame::FlipContours(int typeContourFlip, int flipDirection)
3384 {
3385         printf("EED wxContourMainFrame::FlipContours( %d , %d ) \n",typeContourFlip,  flipDirection );
3386
3387         saveState();
3388
3389         if (typeContourFlip==0) //
3390         {
3391                 FlipSelectedContours(flipDirection);
3392         }
3393
3394         if (typeContourFlip==1) //
3395         {
3396                 FlipActualSliceContours(flipDirection);
3397         }
3398
3399         if (typeContourFlip==2) //
3400         {
3401                 FlipAllContours(flipDirection);
3402         }
3403         RefreshInterface();
3404 }
3405
3406
3407
3408
3409