lib/Interface_ManagerContour_NDimensions/wxContourEventHandler.cxx

   1
   2
   3 /*  Diagrama de Secuaencia de cambiar un instante
   4 wxContourEventHandler :: changeInstant()
   5         OutlineModelManager :: ->setInstant( _actualInstant );
   6                 OutlineModelManager :: updateToActualInstant()
   7                   OutlineModelManager :: getOutlinesAtInstant(Instant * anInstant, bool ifAnnotate)
   8                     OutlineModelManager :: annotateOutlinesWrap(std::vector<std::string> kNamesVector, std::vector<ContourThing **> theOutlinesVector)
   9         wxContourEventHandler :: updateInstantOutlines()
  10                 OutlineModelManager :: getActualInstantOutlines ()
  11                 wxVtkBaseView_SceneManager :: addToScene( std::vector< std::string> theKeyNameVector, bool append, bool visualization, bool control, bool ifActive, bool ifShowCtrlPoints )
  12                         wxVtkBaseView_SceneManager :: addToScene( std::string theKeyName, bool append, bool visualization, bool control, bool ifActive, bool ifShowCtrlPoints )
  13                                 wxVtkBaseView_SceneManager :: getContourWrap_ViewControlOf
  14                                         MAP  find
  15                            void wxVtkBaseView_SceneManager :: addToScene( std::string theKeyName, ContourWrap_ViewControl * contourWRP, bool append, bool visualization, bool control, bool ifActive, bool ifShowCtrlPoints )
  16
  17 */
  18
  19
  20 /*!
  21  \mainpage NDimension with wxWidgets and maracas
  22
  23  \section intro Introduction
  24
  25  This is the introduction.
  26
  27
  28
  29   \dot
  30
  31
  32 digraph example_0 {
  33         graph [ ratio=fill];
  34     node [shape=record, fontname=Helvetica, fontsize=10];
  35
  36         _wxContourGUIExample                    [ label="wxContourGUIExample"                   URL="\ref wxContourGUIExample"];
  37         _wxContourEventHandler                  [ label="wxContourEventHandler"                 URL="\ref wxContourEventHandler"];
  38
  39         _OutlineModelManager                    [ label="OutlineModelManager"                   URL="\ref OutlineModelManager"];
  40         _wxInstantChooserPanel                  [ label="wxInstantChooserPanel"                 URL="\ref wxInstantChooserPanel"];
  41         _wxContourViewPanel                             [ label="wxContourViewPanel"                    URL="\ref wxContourViewPanel"];
  42         _wxContour_ButtonsBar                   [ label="wxContour_ButtonsBar"                  URL="\ref wxContour_ButtonsBar"];
  43         _OutlineModelManager                    [ label="OutlineModelManager"                   URL="\ref OutlineModelManager"];
  44         _wxVtkBaseView_SceneManager             [ label="wxVtkBaseView_SceneManager"    URL="\ref wxVtkBaseView_SceneManager"];
  45         _SomeEnvironment                                [ label="SomeEnvironment"                               URL="\ref SomeEnvironment"];
  46
  47
  48         _wxContourGUIExample                    ->      _wxContourEventHandler                  [ arrowhead="open", style="dashed" ];
  49         _wxContourGUIExample                    ->      _OutlineModelManager                    [ arrowhead="open", style="dashed" ];
  50         _wxContourGUIExample                    ->      _wxInstantChooserPanel                  [ arrowhead="open", style="dashed" ];
  51         _wxContourGUIExample                    ->      _wxContourViewPanel                             [ arrowhead="open", style="dashed" ];
  52         _wxContourGUIExample                    ->      _wxContour_ButtonsBar                   [ arrowhead="open", style="dashed" ];
  53         _wxContourViewPanel                             ->      wxMaracas_N_ViewersWidget               [ arrowhead="open", style="dashed" ];
  54         _wxContourEventHandler                  ->      _OutlineModelManager                    [ arrowhead="open", style="dashed" ];
  55         _wxContourEventHandler                  ->      _wxVtkBaseView_SceneManager             [ arrowhead="open", style="dashed" ];
  56         _OutlineModelManager                    ->      _SomeEnvironment                                [ arrowhead="open", style="dashed" ];
  57
  58 }
  59
  60 \enddot
  61
  62
  63
  64 */
  65
  66
  67
  68 //----------------------------------------------------------------------------------------------------------------
  69 // Class definition include
  70 //----------------------------------------------------------------------------------------------------------------
  71 #include "wxContourEventHandler.h"
  72 #include <wx/filedlg.h>
  73 #include <wx/spinctrl.h>
  74 #include <iostream>
  75 #include <fstream>
  76
  77 //----------------------------------------------------------------------------------------------------------------
  78 // Class implementation
  79 //----------------------------------------------------------------------------------------------------------------
  80 /** @file wxContourEventHandler.cxx */
  81
  82
  83 //------------------------------------------------------------------------------------------------------------
  84 // Includes
  85 //------------------------------------------------------------------------------------------------------------
  86
  87 #include "wxContour_ActionCommandsID.h"
  88 #include "NameWrapper.h"
  89 #include "ConceptDataWrap.h"
  90 #include "OutlineGroup.h"
  91
  92 #include <manualContour.h>
  93 #include "Contour/ContourExtractData.h"
  94 #include "ImageSourceThing.h"
  95
  96 #include "vtkImageData.h"
  97 #include <vtkContourFilter.h>
  98 #include <vtkCleanPolyData.h>
  99 #include <vtkPolyDataConnectivityFilter.h>
 100 #include <vtkStripper.h>
 101 #include <vtkImageReslice.h>
 102 #include <vtkMetaImageWriter.h>
 103 #include <vtkImageMapToWindowLevelColors.h>
 104
 105
 106 //------------------------------------------------------------------------------------------------------------
 107 //------------------------------------------------------------------------------------------------------------
 108 //------------------------------------------------------------------------------------------------------------
 109
 110 PanelBullEyeOptions::PanelBullEyeOptions (wxWindow * parent, wxSize size) :
 111                  wxPanel(parent, -1, wxDefaultPosition, size)
 112 {
 113
 114         _maxLevels              = 5;
 115         _maxSections    = 10;
 116         wxSize sizepanel(190,300);
 117         wxPanel *panel = this;
 118
 119
 120         wxString lstOptions[2];
 121         lstOptions[0]= wxString("General options",wxConvUTF8);
 122         lstOptions[1]= wxString("Detail options",wxConvUTF8);
 123         _radioboxBullEyeGenOpt  = new wxRadioBox(panel, -1, wxString("General/Detail options",wxConvUTF8), wxDefaultPosition, wxSize(200,45), 2 , lstOptions,  2, wxRA_SPECIFY_COLS);
 124         _radioboxBullEyeGenOpt->SetSelection(0);
 125
 126         _spinctrlBullEyeNumOfCrowns = new wxSpinCtrl( panel , -1,_T("B"),wxDefaultPosition, wxSize(40,20) );
 127         _spinctrlBullEyeNumOfCrowns->SetRange(1,_maxLevels);
 128         _spinctrlBullEyeNumOfCrowns->SetValue(3);
 129
 130         _spinctrlBullEyeNumOfSec = new wxSpinCtrl( panel , -1,_T("A"),wxDefaultPosition, wxSize(40,20) );
 131         _spinctrlBullEyeNumOfSec->SetRange(1,_maxSections);
 132         _spinctrlBullEyeNumOfSec->SetValue(5);
 133
 134
 135         _sliderBullEyeAngle = new wxSlider( panel , -1 ,0,0,180, wxDefaultPosition, wxSize(200,35), wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
 136
 137         wxFlexGridSizer * sizerGeneralOptions                           = new wxFlexGridSizer(10);
 138
 139         wxFlexGridSizer * sizerGeneralOptionsA                          = new wxFlexGridSizer(1);
 140         wxFlexGridSizer * sizerGeneralOptionsB                          = new wxFlexGridSizer(1);
 141         wxFlexGridSizer * sizerGeneralOptionsC                          = new wxFlexGridSizer(1);
 142         sizerGeneralOptionsA -> Add( new wxStaticText(panel,-1,_T("Crowns")) , 1, wxGROW );
 143         sizerGeneralOptionsA -> Add( _spinctrlBullEyeNumOfCrowns , 1/*, wxGROW*/ );
 144         sizerGeneralOptionsB -> Add( new wxStaticText(panel,-1,_T("Sections")) , 1, wxGROW );
 145         sizerGeneralOptionsB -> Add( _spinctrlBullEyeNumOfSec , 1/*, wxGROW*/ );
 146         sizerGeneralOptionsC -> Add( new wxStaticText(panel,-1,_T("      Angle")) , 1, wxGROW );
 147         sizerGeneralOptionsC -> Add( _sliderBullEyeAngle , 1/*, wxGROW*/ );
 148
 149         sizerGeneralOptions -> Add( sizerGeneralOptionsA  , 1/*, wxGROW*/ );
 150         sizerGeneralOptions -> Add( new wxStaticText(panel,-1,_T("   ")) , 1, wxGROW );
 151         sizerGeneralOptions -> Add( sizerGeneralOptionsB  , 1/*, wxGROW*/ );
 152         sizerGeneralOptions -> Add( new wxStaticText(panel,-1,_T("   ")) , 1, wxGROW );
 153         sizerGeneralOptions -> Add( sizerGeneralOptionsC  , 1/*, wxGROW*/ );
 154
 155
 156         wxSpinCtrl      *tmpSpinSection;
 157         wxSlider        *tmpSliderRadio;
 158         wxSlider        *tmpSliderAng;
 159
 160         wxFlexGridSizer * sizerDetailOptions                            = new wxFlexGridSizer(6);
 161
 162         sizerDetailOptions -> Add( new wxStaticText(panel,-1,_T("Crown ")) , 1, wxGROW );
 163         sizerDetailOptions -> Add( new wxStaticText(panel,-1,_T("  Sections  ")) , 1, wxGROW );
 164         sizerDetailOptions -> Add( new wxStaticText(panel,-1,_T("  ")) , 1, wxGROW );
 165         sizerDetailOptions -> Add( new wxStaticText(panel,-1,_T("      Radio %")) , 1, wxGROW );
 166         sizerDetailOptions -> Add( new wxStaticText(panel,-1,_T("  ")) , 1, wxGROW );
 167         sizerDetailOptions -> Add( new wxStaticText(panel,-1,_T("      Angle")) , 1, wxGROW );
 168
 169         wxString tmpwxstring;
 170         int i;
 171         for (i=0;i<_maxLevels;i++){
 172                 tmpSpinSection = new wxSpinCtrl( panel  , -1,_T(""),wxDefaultPosition, wxSize(40,20) );
 173                 tmpSliderRadio = new wxSlider( panel    , -1 ,0,0,100, wxDefaultPosition, wxSize(110,35), wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
 174                 tmpSliderAng   = new wxSlider( panel    , -1 ,0,0,180, wxDefaultPosition, wxSize(200,35), wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
 175
 176                 tmpSpinSection ->SetRange(1,_maxSections);
 177
 178                 tmpwxstring.Printf(_T("  %d.  "),i+1);
 179                 sizerDetailOptions -> Add( new wxStaticText(panel,-1,tmpwxstring) , 1, wxGROW );
 180                 sizerDetailOptions -> Add( tmpSpinSection, 1 );
 181                 sizerDetailOptions -> Add( new wxStaticText(panel,-1,_T("  ")) , 1, wxGROW );
 182                 sizerDetailOptions -> Add( tmpSliderRadio, 1, wxGROW );
 183                 sizerDetailOptions -> Add( new wxStaticText(panel,-1,_T("  ")) , 1, wxGROW );
 184                 sizerDetailOptions -> Add( tmpSliderAng, 1, wxGROW );
 185
 186                 tmpSpinSection  -> SetValue(5);
 187                 tmpSliderRadio  -> SetValue( 100-(double)((i)*100.0/_maxLevels) );
 188                 tmpSliderAng    -> SetValue(0);
 189
 190                 Connect( tmpSliderRadio->GetId(),       wxEVT_SCROLL_THUMBRELEASE  , (wxObjectEventFunction) &PanelBullEyeOptions::onRefreshPanel );
 191                 Connect( tmpSliderRadio->GetId(),       wxEVT_SCROLL_CHANGED  , (wxObjectEventFunction) &PanelBullEyeOptions::onRefreshPanel );
 192
 193                 _lstBullEyeDetailNumOfSec.push_back( tmpSpinSection );
 194                 _lstBullEyeDetailRadio.push_back( tmpSliderRadio );
 195                 _lstBullEyeDetailAngle.push_back( tmpSliderAng );
 196
 197         } //for
 198
 199         wxFlexGridSizer * sizer                         = new wxFlexGridSizer(1);
 200         sizer -> Add( new wxStaticText(panel,-1,_T("")) , 1, wxGROW );
 201         sizer -> Add( new wxStaticText(panel,-1,_T("")) , 1, wxGROW );
 202         sizer -> Add( _radioboxBullEyeGenOpt , 1, wxGROW );
 203         sizer -> Add( new wxStaticText(panel,-1,_T("")) , 1, wxGROW );
 204         sizer -> Add( new wxStaticText(panel,-1,_T("      -- Bull Eye general options --")) , 1, wxGROW );
 205         sizer -> Add( new wxStaticText(panel,-1,_T("")) , 1, wxGROW );
 206         sizer -> Add(  sizerGeneralOptions , 1, wxGROW );
 207         sizer -> Add( new wxStaticText(panel,-1,_T("")) , 1, wxGROW );
 208         sizer -> Add( new wxStaticText(panel,-1,_T("")) , 1, wxGROW );
 209         sizer -> Add( new wxStaticText(panel,-1,_T("      -- Bull Eye detail options --")) , 1, wxGROW );
 210         sizer -> Add( new wxStaticText(panel,-1,_T("")) , 1, wxGROW );
 211         sizer -> Add(  sizerDetailOptions  , 1, wxGROW );
 212
 213         Connect( _radioboxBullEyeGenOpt->GetId(),       wxEVT_COMMAND_RADIOBOX_SELECTED , (wxObjectEventFunction) &PanelBullEyeOptions::onRefreshPanel );
 214         Connect( _spinctrlBullEyeNumOfCrowns->GetId(),  wxEVT_COMMAND_TEXT_UPDATED              , (wxObjectEventFunction) &PanelBullEyeOptions::onRefreshPanel );
 215
 216         panel->SetSizer( sizer );
 217         panel->SetSize( sizepanel );
 218         panel->SetAutoLayout( true );
 219         panel->Layout();
 220
 221         RefreshPanel();
 222
 223 }
 224
 225 //------------------------------------------------------------------------------------------------------------
 226 PanelBullEyeOptions::~PanelBullEyeOptions()
 227 {
 228 }
 229
 230 //------------------------------------------------------------------------------------------------------------
 231 void PanelBullEyeOptions::onRefreshPanel( wxCommandEvent& event )
 232 {
 233         RefreshPanel();
 234 }
 235
 236 //------------------------------------------------------------------------------------------------------------
 237 void PanelBullEyeOptions::RefreshPanel()
 238 {
 239         int i;
 240         bool ok;
 241         if (this->_radioboxBullEyeGenOpt->GetSelection()==0){
 242                 for (i=0; i<_maxLevels; i++)
 243                 {
 244                         _lstBullEyeDetailNumOfSec[i]    -> Enable(false);
 245                         _lstBullEyeDetailRadio[i]               -> Enable(false);
 246                         _lstBullEyeDetailAngle[i]               -> Enable(false);
 247                 } // for
 248         } else {
 249                 int spinSelec = _spinctrlBullEyeNumOfCrowns->GetValue();
 250                 for (i=0; i<_maxLevels; i++)
 251                 {
 252                         ok = (i < spinSelec);
 253                         _lstBullEyeDetailNumOfSec[i]    -> Enable(ok);
 254                         _lstBullEyeDetailRadio[i]               -> Enable(ok);
 255                         _lstBullEyeDetailAngle[i]               -> Enable(ok);
 256
 257                         if (i>0){
 258                                 if (_lstBullEyeDetailRadio[i]->GetValue() > _lstBullEyeDetailRadio[i-1]->GetValue())
 259                                 {
 260                                         _lstBullEyeDetailRadio[i]->SetValue( _lstBullEyeDetailRadio[i-1]->GetValue() );
 261                                 }
 262                         }// if i>0
 263                 } // for
 264         } // if
 265 }
 266
 267 //------------------------------------------------------------------------------------------------------------
 268 int PanelBullEyeOptions::GetNumberOfCrowns()
 269 {
 270         return this->_spinctrlBullEyeNumOfCrowns->GetValue();
 271 }
 272
 273 //------------------------------------------------------------------------------------------------------------
 274 int PanelBullEyeOptions::GetNumberOfSections(int nCrown)
 275 {
 276         int result;
 277         if (this->_radioboxBullEyeGenOpt->GetSelection()==0)
 278         {
 279                 result = this->_spinctrlBullEyeNumOfSec->GetValue();
 280         } else {
 281                 result = this->_lstBullEyeDetailNumOfSec[nCrown]->GetValue();
 282         }
 283         return result;
 284 }
 285
 286 //------------------------------------------------------------------------------------------------------------
 287 int PanelBullEyeOptions::GetRadioOfCrown(int nCrown)
 288 {
 289         int result;
 290         double sizeCrowns;
 291         if (this->_radioboxBullEyeGenOpt->GetSelection()==0)
 292         {
 293                 sizeCrowns = (double)( this->_spinctrlBullEyeNumOfCrowns->GetValue() );
 294                 result = 100.0 * (nCrown+1)/sizeCrowns ;
 295         } else {
 296                 result = this->_lstBullEyeDetailRadio[nCrown]->GetValue();
 297         }
 298         return result;
 299 }
 300
 301 //------------------------------------------------------------------------------------------------------------
 302 double PanelBullEyeOptions::GetAngOfCrownSection(int nCrown,int section)
 303 {
 304         double angle;
 305         if (this->_radioboxBullEyeGenOpt->GetSelection()==0)
 306         {
 307                 angle = this->_sliderBullEyeAngle->GetValue();
 308         } else {
 309                 angle = this->_lstBullEyeDetailAngle[nCrown]->GetValue();
 310         }
 311         double numOfSec = (double)GetNumberOfSections(nCrown);
 312         double deltaSec = GetAngDeltaOfCrownSection(nCrown);
 313         return angle + section*deltaSec ;
 314 }
 315
 316 //------------------------------------------------------------------------------------------------------------
 317 double PanelBullEyeOptions::GetAngDeltaOfCrownSection(int nCrown)
 318 {
 319         double numOfSec = (double)GetNumberOfSections(nCrown);
 320         return 360.0/numOfSec;
 321 }
 322
 323
 324
 325 //------------------------------------------------------------------------------------------------------------
 326 //------------------------------------------------------------------------------------------------------------
 327 //------------------------------------------------------------------------------------------------------------
 328
 329
 330         //------------------------------------------------------------------------------------------------------------
 331         // Constructors & Destructors
 332         //------------------------------------------------------------------------------------------------------------
 333
 334         wxContourEventHandler ::wxContourEventHandler()
 335                 :wxEvtHandler()
 336         {
 337         _creatingContoursActive                 = false;
 338                 _theViewPanel                                   = NULL;
 339                 _modelManager                                   = NULL;
 340                 _instantPanel                                   = NULL;
 341                 _buttonsBar                                             = NULL;
 342                 _gridPanel                                              = NULL;
 343                 _drawToolsPanel                                 = NULL;
 344                 _operationsToolsPanel                   = NULL;
 345                 _autoFormsPanel                                 = NULL;
 346                 _standardToolsPanel                             = NULL;
 347                 _editionToolsPanel                              = NULL;
 348                 _listViewPanel                                  = NULL;
 349                 _sceneManager                                   = NULL;
 350                 _actualInstant                                  = NULL;
 351                 _performingOperation                    = new PerformingOperation();
 352
 353                 // EED Interface and Spread
 354                 _spreadFrame                                    = NULL;
 355                 _segmentationFrame                              = NULL;
 356                 _contourPropagation                             = NULL;
 357                 _createContourFrame                             = NULL;
 358                 _deleteFrame                                    = NULL;
 359                 _InformationContourFrame                = NULL;
 360                 _interfaceConfigurationFrame    = NULL;
 361                 _TestFrame                                              = NULL;
 362                 _wxtextctrlTest                                 = NULL;
 363                 _panelBullEyeOptions                    = NULL;
 364
 365                 fileNameContourROI                              = "";
 366                 _numberOfVariablesStatistics=6+1;
 367
 368                 inundo = 0;
 369                 inredo = 0;
 370                 stundoredo = "data/temp";
 371 #if(WIN32)
 372                 mkdir(stundoredo.c_str());
 373 #else
 374                 mkdir(stundoredo.c_str(),755);
 375 #endif
 376                 stundoredo += "/cont";
 377         }
 378         //------------------------------------------------------------------------------------------------------------
 379         wxContourEventHandler :: ~ wxContourEventHandler()
 380         {
 381                 delete _actualInstant;
 382                 /*delete _theViewPanel;
 383                 delete _instantPanel;
 384                 delete _buttonsBar;
 385                 delete _actualInstant;
 386                 */
 387                 delete _sceneManager;
 388                 delete _performingOperation;
 389
 390
 391         }
 392         //------------------------------------------------------------------------------------------------------------
 393         // Configuration methods
 394         //------------------------------------------------------------------------------------------------------------
 395
 396         bool wxContourEventHandler :: configureEventsHandling()
 397         {
 398                 bool configured = true;
 399
 400                 return configured;
 401         }
 402
 403         //------------------------------------------------------------------------------------------------------------
 404         // Methods for capturing events
 405         //------------------------------------------------------------------------------------------------------------
 406         void wxContourEventHandler :: onProcessMessage( wxCommandEvent& event )
 407         {
 408
 409         }
 410         //------------------------------------------------------------------------------------------------------------
 411
 412         void wxContourEventHandler :: onActionButtonPressed( wxCommandEvent& event )
 413         {
 414                 const char buttonTool = *(char *)event.GetClientData();
 415                 executeActionCommand( buttonTool );
 416         }
 417         //------------------------------------------------------------------------------------------------------------
 418         void wxContourEventHandler :: onChangedDeep ( wxCommandEvent& event )
 419         {
 420                 double val = _theViewPanel->getCurrentDeep();
 421                 _instantPanel->setConceptValue( "Axe Depth", (int)val );
 422                 _theViewPanel->setActualVertical( (int)val );
 423                 changeInstant();
 424         }
 425
 426         //------------------------------------------------------------------------------------------------------------
 427         void wxContourEventHandler :: onChangeInstant( wxCommandEvent& event )
 428         {
 429                 ConceptDataWrap * dataConcept = NULL;
 430                 if ( _theViewPanel->GetId() == event.GetId() )
 431                 {
 432                         dataConcept = (ConceptDataWrap *)event.GetClientData();
 433                         int value = dataConcept->getActualValue();
 434                         _instantPanel->setConceptValue( dataConcept->getName(), value );
 435                 }
 436                 else
 437                 {
 438                         dataConcept = _instantPanel->getLastConceptData();
 439                         if( dataConcept->getName().compare( _theViewPanel->getVerticalConceptName() ) )
 440                         {
 441                                 _theViewPanel->setActualVertical( dataConcept->getActualValue());
 442                                 //_theViewPanel->setVerticalConcept( dataConcept->getName(), dataConcept->getMinShowedValue()/*dataConcept->getMinValue()*/, /*dataConcept->getMaxValue()*/ dataConcept->getMaxShowedValue(), dataConcept->getMinShowedValue(), dataConcept->getMaxShowedValue(), dataConcept->getActualValue());
 443                         }
 444                         else if( dataConcept->getName().compare( _theViewPanel->getHorizontalConceptName() ) || _instantPanel->getIfConceptCheckedAt( dataConcept->getName(), 0 ) )
 445                         {
 446                                 _theViewPanel->setHorizontalConcept( dataConcept->getName(), dataConcept->getMinShowedValue()/*dataConcept->getMinValue()*/, /*dataConcept->getMaxValue()*/ dataConcept->getMaxShowedValue(), dataConcept->getMinShowedValue(), dataConcept->getMaxShowedValue(), dataConcept->getActualValue());
 447                         }
 448                 }
 449                 changeInstant();
 450         }
 451         //------------------------------------------------------------------------------------------------------------
 452
 453         void wxContourEventHandler :: onCreateMultipleROI( wxCommandEvent& event )
 454         {
 455                 _creatingContoursActive = !_creatingContoursActive;
 456                 if( _creatingContoursActive )
 457                 {
 458                         createContour();
 459                 }
 460         }
 461         //------------------------------------------------------------------------------------------------------------
 462         void wxContourEventHandler :: onCreateROI( wxCommandEvent& event )
 463         {
 464                 if( _creatingContoursActive )
 465                 {
 466                         createContour();
 467                 }
 468         }
 469
 470         //------------------------------------------------------------------------------------------------------------
 471         void wxContourEventHandler :: onStopCreateROI( wxCommandEvent& event )
 472         {
 473
 474         }
 475
 476         //------------------------------------------------------------------------------------------------------------
 477         void wxContourEventHandler :: onDeleterROI( wxCommandEvent& event )
 478         {
 479
 480         }
 481         //------------------------------------------------------------------------------------------------------------
 482         void wxContourEventHandler :: onSelectROI( wxCommandEvent& event )
 483         {
 484
 485         }
 486         //------------------------------------------------------------------------------------------------------------
 487
 488
 489         void wxContourEventHandler :: onUnSelectROI( wxCommandEvent& event )
 490         {
 491
 492         }
 493         //------------------------------------------------------------------------------------------------------------
 494
 495         void wxContourEventHandler :: onManualHidedROI( wxCommandEvent& event )
 496         {
 497
 498         }
 499         //------------------------------------------------------------------------------------------------------------
 500
 501         void wxContourEventHandler :: onManualShowedROI( wxCommandEvent& event )
 502         {
 503
 504         }
 505         //------------------------------------------------------------------------------------------------------------
 506
 507         void wxContourEventHandler :: onEditingROI( wxCommandEvent& event )
 508         {
 509
 510         }
 511         //------------------------------------------------------------------------------------------------------------
 512
 513         void wxContourEventHandler :: onMovingROI( wxCommandEvent& event )
 514         {
 515
 516         }
 517
 518         //------------------------------------------------------------------------------------------------------------
 519         //  Model management methods
 520         //------------------------------------------------------------------------------------------------------------
 521
 522         void wxContourEventHandler::onSpreadReset( wxCommandEvent& event )
 523         {
 524                 _wxtextctrlSpread->SetValue(wxString("",wxConvUTF8));
 525                 _contourPropagation->resetAppend();
 526         }
 527
 528         //------------------------------------------------------------------------------------------------------------
 529         void wxContourEventHandler::onSpreadAdd( wxCommandEvent& event )
 530         {
 531                 std::vector<double> vecX;
 532                 std::vector<double> vecY;
 533                 std::vector<double> vecZ;
 534                 _sceneManager->GetPointsOfActualContour( &vecX , &vecY , &vecZ );
 535
 536                 if (vecX.size()!=0){
 537                         std::vector<int> tempVector;
 538                         _instantPanel->getInstant( tempVector );
 539                         int i,size=vecZ.size();
 540                         int actualSlice = tempVector[1];
 541                         for ( i=0 ; i<size ; i++ )
 542                         {
 543                                 vecZ[i] = actualSlice;
 544                         } // for
 545
 546                         _contourPropagation->appendContour(&vecX , &vecY , &vecZ);
 547                         wxString newstring;
 548                         //newstring.Printf("%s %d -",_wxtextctrlSpread->GetValue(), actualSlice );
 549                         newstring.append(wxString(_wxtextctrlSpread->GetValue(),wxConvUTF8));
 550                         newstring.append(wxString(" ",wxConvUTF8));
 551                         newstring.append(wxString(intToString(actualSlice).c_str(),wxConvUTF8));
 552                         _wxtextctrlSpread->SetValue(newstring);
 553                 } // if
 554         }
 555
 556
 557
 558         //------------------------------------------------------------------------------------------------------------
 559         void wxContourEventHandler::onSpreadGo( wxCommandEvent& event )
 560         {
 561
 562                 //JCP 20-10-08 Undo redo implementation
 563                 saveState();
 564                 //JCP 20-10-08 Undo redo implementation
 565
 566                 wxBusyCursor wait;
 567                 int typeMethodFindCtrlPoints=_spreadMethodRadiobox->GetSelection();
 568                 int typeofcontour = 1;
 569                 manualContourModel *manModelContour;
 570                 std::vector<double> vecCtrlPointX;
 571                 std::vector<double> vecCtrlPointY;
 572                 std::vector<double> vecCtrlPointZ;
 573                 double  minZ,maxZ;
 574                 int z,j,sizeCtrPt;
 575 //              double idTmp;
 576                 int idTmp;
 577
 578                 std::vector<int> tempVector;
 579                 _instantPanel->getInstant( tempVector );
 580 //              tempVector[1];
 581
 582                 _contourPropagation->getMaxMinZ(&minZ,&maxZ);
 583 //JSTG_16-07-08_----------------------------------------------------------------
 584                 //_contourPropagation->setInterpolationNumber(maxZ-minZ+1);
 585                 _contourPropagation->setInterpolationNumber(100);
 586                 _contourPropagation->CalculeSplinePropagation();
 587
 588                 double          totalZ = maxZ-minZ+1;
 589                 double          porcent;
 590                 wxString        tmpString;
 591 //--------------------------------------------------------------------
 592                 for ( z=(int)minZ ; z<=(int)maxZ ; z++ )
 593                 {
 594                         porcent = 100.0* (z-minZ)/totalZ;
 595                         int numero = (int)(z-minZ+1)/(int)totalZ;
 596                         std::string stringtemp = "  "+intToString(porcent)+"%            "+intToString(numero)+"            "+intToString(z);
 597                         tmpString.Append(wxString(stringtemp.c_str(),wxConvUTF8));
 598
 599                         //tmpString.Printf("  %d %c            %d/%d            %d", (int)porcent , 37 , (int)(z-minZ+1), (int)totalZ,z );
 600                         _staticTextSpread->SetLabel(tmpString);
 601
 602                         if (_contourPropagation->ifSliceKeyContourExist(z)==false)
 603                         {
 604                                 manModelContour = factoryManualContourModel( typeofcontour );
 605                                 idTmp = _contourPropagation->FindIdWithZ(z);
 606                                 if (typeMethodFindCtrlPoints==0) // Initial Points
 607                                 {
 608                                         _contourPropagation->GetInitialControlPoints( idTmp , &vecCtrlPointX,&vecCtrlPointY,&vecCtrlPointZ);
 609                                 }
 610                                 if (typeMethodFindCtrlPoints==1)  // Automatique Method
 611                                 {
 612                                         _contourPropagation->GetControlPoints( idTmp  ,&vecCtrlPointX,&vecCtrlPointY,&vecCtrlPointZ);
 613                                 }
 614                                 if (typeMethodFindCtrlPoints==2)  // sampling
 615                                 {
 616                                         _contourPropagation->GetControlPoints( idTmp , 20.0 ,&vecCtrlPointX,&vecCtrlPointY,&vecCtrlPointZ);
 617                                 }
 618         //--------------------------------------------------------------------
 619                                 sizeCtrPt = vecCtrlPointX.size();
 620                                 for (j=0 ; j<sizeCtrPt ; j++)
 621                                 {
 622         //JSTG_16-07-08_----------------------------------------------------------------
 623                                         manModelContour->AddPoint( vecCtrlPointX[j] , vecCtrlPointY[j] , -900  );
 624         //--------------------------------------------------------------------
 625                                 } // for j
 626
 627                                 tempVector[1]=z;
 628                                 std::string theName;
 629                                 theName = _modelManager->createOutline( manModelContour, tempVector );
 630                                 bool addedModel = theName.compare("") != 0;
 631                                 if( addedModel )
 632                                 {
 633                                         double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
 634                                         this->_theViewPanel->getSpacing(spc);
 635                                         //Adding the manualContourControler to interface objects structure
 636                                         //Adding the manualViewContour to interface objects structure
 637                                         //_sceneManager->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
 638                                         _sceneManager->configureViewControlTo( theName, manModelContour,spc,typeofcontour ) ;
 639                                 } // if addedModel
 640                         }// ifSliceKeyContourExist
 641                 } // for z
 642                 _staticTextSpread->SetLabel(wxString("   ",wxConvUTF8));
 643                 //RefreshInterface();
 644
 645
 646
 647         }
 648
 649         //------------------------------------------------------------------------------------------------------------
 650         void wxContourEventHandler :: onSpread( )
 651         {
 652                 if (_spreadFrame==NULL)
 653                 {
 654
 655                         _spreadFrame                            = new wxFrame (_theViewPanel, -1,_T(" Spread "), wxDefaultPosition, wxDefaultSize, wxFRAME_TOOL_WINDOW|wxSYSTEM_MENU | wxCAPTION |  wxCLIP_CHILDREN |wxFRAME_FLOAT_ON_PARENT );
 656
 657                         wxSize sizepanel(250,400);
 658                         _spreadFrame->SetSize( sizepanel );
 659                         _spreadFrame->SetEventHandler( this );
 660                         wxPanel *panel                          = getSpreadPanel(_spreadFrame);
 661                         panel->SetSize(sizepanel);
 662                         /**new wxPanel(_spreadFrame,-1);
 663
 664                         wxButton *spreadResetBtn        = new wxButton(panel,-1,_T("Reset"),wxDefaultPosition, wxSize(80,35) );
 665                         wxButton *spreadAddBtn          = new wxButton(panel,-1,_T("Add"),wxDefaultPosition, wxSize(80,35));
 666
 667                         wxString lstOptions[3];
 668                         lstOptions[0]="A";
 669                         lstOptions[1]="B";
 670                         lstOptions[2]="C";
 671                         _spreadMethodRadiobox                                           = new wxRadioBox(panel, -1, "Method (find ctrl. Points)", wxDefaultPosition, wxSize(200,45), 3 , lstOptions,  3, wxRA_SPECIFY_COLS);
 672                         _spreadMethodRadiobox->SetSelection(2);
 673
 674                         wxButton *spreadGoBtn           = new wxButton(panel,-1,_T("Go"),wxDefaultPosition, wxSize(80,35));
 675                         _staticTextSpread                       = new wxStaticText(panel,-1,_T("    "));
 676
 677                         _wxtextctrlSpread           = new wxTextCtrl(panel,-1, "",wxDefaultPosition, wxSize(200,150), wxTE_MULTILINE );
 678
 679                         _spreadFrame->SetEventHandler( this );
 680                         Connect( spreadResetBtn->GetId(),       wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSpreadReset );
 681                         Connect( spreadAddBtn->GetId(),         wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSpreadAdd );
 682                         Connect( spreadGoBtn->GetId(),          wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSpreadGo );
 683
 684                         wxFlexGridSizer * sizer         = new wxFlexGridSizer(1);
 685                         sizer -> Add( spreadResetBtn            , 1, wxGROW );
 686                         sizer -> Add( spreadAddBtn                      , 1, wxGROW );
 687                         sizer -> Add( _spreadMethodRadiobox     , 1, wxGROW );
 688                         sizer -> Add( spreadGoBtn                       , 1, wxGROW );
 689                         sizer -> Add( _staticTextSpread         , 1, wxGROW );
 690                         sizer -> Add( _wxtextctrlSpread         , 1, wxGROW );
 691
 692
 693                         panel->SetSizer( sizer );
 694                         panel->SetSize( sizepanel );
 695                         panel->SetAutoLayout( true );
 696                         panel->Layout();**/
 697                         _spreadFrame->Show();
 698                 } else {
 699                         if (_spreadFrame->IsShown()==true)
 700                         {
 701                                 _spreadFrame->Show(false);
 702                         } else  {
 703                                 _spreadFrame->Show(true);
 704                         }
 705                 }
 706         }
 707
 708         wxPanel* wxContourEventHandler::getSpreadPanel(wxWindow* parent){
 709                 //wxPanel *panel                                = new wxPanel(parent,-1);
 710
 711                 _contourPropagation                     = new ContourPropagation();
 712
 713                 wxPanel *panel                                                  = new wxPanel(parent,-1,wxDefaultPosition, wxDefaultSize,wxNO_BORDER, wxString("",wxConvUTF8));
 714
 715                 wxButton *spreadResetBtn        = new wxButton(panel,-1,_T("Reset"),wxDefaultPosition, wxDefaultSize );
 716                 wxButton *spreadAddBtn          = new wxButton(panel,-1,_T("Add"),wxDefaultPosition, wxDefaultSize);
 717
 718                 wxString lstOptions[3];
 719                 lstOptions[0]=_T("A");
 720                 lstOptions[1]=_T("B");
 721                 lstOptions[2]=_T("C");
 722                 _spreadMethodRadiobox                                           = new wxRadioBox(panel, -1, _T("Method (find ctrl. Points)"), wxDefaultPosition, wxDefaultSize, 3 , lstOptions,  3, wxRA_SPECIFY_COLS);
 723                 _spreadMethodRadiobox->SetSelection(2);
 724
 725                 wxButton *spreadGoBtn           = new wxButton(panel,-1,_T("Go"),wxDefaultPosition, wxDefaultSize);
 726                 _staticTextSpread                       = new wxStaticText(panel,-1,_T("    "));
 727
 728                 _wxtextctrlSpread           = new wxTextCtrl(panel,-1, _T(""),wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE );
 729
 730
 731                 Connect( spreadResetBtn->GetId(),       wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSpreadReset );
 732                 Connect( spreadAddBtn->GetId(),         wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSpreadAdd );
 733                 Connect( spreadGoBtn->GetId(),          wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSpreadGo );
 734
 735                 wxFlexGridSizer * sizer         = new wxFlexGridSizer(1);
 736                 sizer -> Add( spreadResetBtn            , 1, wxGROW );
 737                 sizer -> Add( spreadAddBtn                      , 1, wxGROW );
 738                 sizer -> Add( _spreadMethodRadiobox     , 1, wxGROW );
 739                 sizer -> Add( spreadGoBtn                       , 1, wxGROW );
 740                 sizer -> Add( _staticTextSpread         , 1, wxGROW );
 741                 sizer -> Add( _wxtextctrlSpread         , 1, wxGROW );
 742
 743
 744                 panel->SetSizer( sizer );
 745                 //panel->SetSize( wxDefaultSize );
 746                 panel->SetAutoLayout( true );
 747                 panel->Layout();
 748                 return panel;
 749         }
 750
 751         //------------------------------------------------------------------------------------------------------------
 752         void wxContourEventHandler::onSegmentationAllSlice( wxCommandEvent& event )
 753         {
 754                 //JCP 20-10-08 Undo redo implementation
 755                 saveState();
 756                 //JCP 20-10-08 Undo redo implementation
 757
 758                 wxBusyCursor wait;
 759                 int                                     x                                       = this->_theViewPanel->GetX();
 760                 int                                     y                                       = this->_theViewPanel->GetY();
 761                 int z,minZ,maxZ;
 762                 double porcent;
 763                 wxString tmpString;
 764                 minZ=_mbarrange->GetStart();
 765                 maxZ=_mbarrange->GetEnd();
 766                 double totalZ = maxZ-minZ+1;
 767                 for( z=minZ ; z<=maxZ ; z++ )
 768                 {
 769                         porcent = 100.0* (z-minZ)/totalZ;
 770                         tmpString.Printf(_T("  %d %c            %d/%d            %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ,z );
 771                         _staticTextSegmentation->SetLabel(tmpString);
 772                         SegmentationOneSlice( x,y,z );
 773                 }
 774                 _staticTextSegmentation->SetLabel(_T("   "));
 775                 RefreshInterface();
 776
 777
 778         }
 779
 780         //------------------------------------------------------------------------------------------------------------
 781         void wxContourEventHandler::onSegmentationOneSlice( wxCommandEvent& event )
 782         {
 783                 //JCP 20-10-08 Undo redo implementation
 784                 saveState();
 785                 //JCP 20-10-08 Undo redo implementation
 786
 787                 wxBusyCursor wait;
 788                 int                                     x                                       = this->_theViewPanel->GetX();
 789                 int                                     y                                       = this->_theViewPanel->GetY();
 790                 int                                     z                                       = this->_theViewPanel->GetZ();
 791                 SegmentationOneSlice( x,y,z );
 792                 RefreshInterface();
 793
 794
 795         }
 796         //------------------------------------------------------------------------------------------------------------
 797         void wxContourEventHandler::SegmentationOneSlice( int x, int y, int z )
 798         {
 799                 int typeofcontour = 1;
 800                 //--Extracting Contour
 801                 vtkImageData    *imagedata      = _sceneManager->GetImageData();
 802 //              double                  *range          = imagedata->GetScalarRange();
 803 //              double                  thr                     = 1;
 804                 int                             isovalue        = _isovalue->GetValue();
 805                 int                             sampling        = _sampling->GetValue();
 806
 807                 vtkImageReslice *imageReslice = vtkImageReslice::New();
 808 //EED
 809 //              double spc[3];
 810 //              imagedata->GetSpacing(spc);
 811 //              x = x*spc[0];
 812 //              y = y*spc[1];
 813 //              z = z*spc[3];
 814
 815                 imageReslice->SetInput( imagedata );
 816                 imageReslice->SetInformationInput(imagedata);
 817                 imageReslice->SetResliceAxesDirectionCosines(1,0,0, 0,1,0 ,0,0,1);
 818                 imageReslice->SetResliceAxesOrigin(0,0,z);
 819                 imageReslice->SetOutputDimensionality(2);
 820                 imageReslice->SetInterpolationModeToLinear();
 821
 822                 imagedata = imageReslice->GetOutput();
 823                 imagedata->Update();
 824                 imagedata->UpdateInformation();
 825
 826                 vtkContourFilter* cntVTK = vtkContourFilter::New( );
 827                 cntVTK->SetInput( imagedata );
 828
 829                 cntVTK->SetNumberOfContours( 1 );
 830                 //cntVTK->SetValue( 0, vmin );
 831 //              cntVTK->SetValue( 0, (range[1]*thr/100) );
 832                 cntVTK->SetValue( 1, isovalue );
 833         //      cntVTK->SetValue( 1, vmax );
 834                 cntVTK->Update( );
 835                 cntVTK->UpdateInformation();
 836
 837                 vtkCleanPolyData* cpd = vtkCleanPolyData::New( );
 838                 cpd->SetInput( cntVTK->GetOutput( ) );
 839                 cpd->ConvertLinesToPointsOff( );
 840                 cpd->Update( );
 841                 cpd->UpdateInformation();
 842
 843                 vtkPolyDataConnectivityFilter* conn = vtkPolyDataConnectivityFilter::New( );
 844                 conn->SetExtractionModeToClosestPointRegion( );
 845                 //conn->SetMaxRecursionDepth( 3000 );
 846
 847                 conn->SetInput( cpd->GetOutput( ) );
 848
 849                 conn->SetClosestPoint( x, y, 0 );
 850                 conn->Update( );
 851                 conn->UpdateInformation();
 852
 853                 vtkCleanPolyData* cpd2 = vtkCleanPolyData::New( );
 854                 cpd2->SetInput( conn->GetOutput( ) );
 855                 cpd2->Update();
 856                 cpd2->UpdateInformation();
 857
 858                 vtkStripper* vtkstripper = vtkStripper::New( );
 859                 vtkstripper->SetInput( cpd2->GetOutput() );
 860                 vtkstripper->Update();
 861                 vtkstripper->UpdateInformation();
 862
 863
 864                 vtkPolyData* polyDataResult =  vtkstripper->GetOutput();
 865
 866                 polyDataResult->Update( );
 867                 polyDataResult->UpdateInformation();
 868
 869 /* EED
 870 ofstream myfile;
 871 myfile.open ("c:/temp/example.txt");
 872 myfile << "\n";
 873 polyDataResult->Print(myfile);
 874 myfile << "-------------------------------------\n";
 875 polyDataResult->GetLines()->Print(myfile);
 876 myfile.close();
 877 */
 878
 879                 cntVTK          -> Delete();
 880                 cpd2            -> Delete();
 881                 cpd                     -> Delete();
 882                 conn            -> Delete();
 883
 884
 885 //--Calculating control points
 886
 887                 std::vector<double> vecX;
 888                 std::vector<double> vecY;
 889                 std::vector<double> vecZ;
 890
 891                 std::vector<double> vecCtrlPointX;
 892                 std::vector<double> vecCtrlPointY;
 893                 std::vector<double> vecCtrlPointZ;
 894
 895
 896                 double *p;
 897                 int ii,size=polyDataResult->GetNumberOfPoints();
 898                 int id;
 899                 for (ii=1;ii<=size;ii++)
 900                 {
 901                         id      = polyDataResult->GetLines()->GetData()->GetValue(ii);
 902                         p       = polyDataResult->GetPoint(id);
 903                         double x=p[0];
 904                         double y=p[1];
 905                         vecX.push_back( p[0] );
 906                         vecY.push_back( p[1] );
 907                         vecZ.push_back( -900 );
 908 //                      vecZ.push_back( p[2] );
 909                 }
 910
 911
 912                 ExtractControlPoints2D *extractcontrolpoints2d = new ExtractControlPoints2D();
 913                 extractcontrolpoints2d->SetContour( &vecX , &vecY , &vecZ );
 914
 915 //PROOFS
 916                 if (methodRadiobox->GetSelection()==0){
 917                         extractcontrolpoints2d->GetInitialControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
 918                 }
 919                 if (methodRadiobox->GetSelection()==1){
 920                         extractcontrolpoints2d->GetControlPoints(  &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
 921                 }
 922                 if (methodRadiobox->GetSelection()==2){
 923                         extractcontrolpoints2d->SetSamplingControlPoints( sampling );
 924                         extractcontrolpoints2d->GetSamplingControlPoints(  &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
 925                 }
 926
 927                 //--Adding contour to the system
 928
 929                 std::vector<int> actualInstantVector;
 930                 _instantPanel->getInstant( actualInstantVector );
 931                 actualInstantVector[1]=z;
 932
 933                 int j,sizeCtrPt = vecCtrlPointX.size();
 934                 manualContourModel *manModelContour =  factoryManualContourModel( typeofcontour );
 935                 manModelContour->SetNumberOfPointsSpline( ((sizeCtrPt/100)+1)*100 );
 936                 if (sizeCtrPt>=3){
 937                         for (j=0 ; j<sizeCtrPt ; j++)
 938                         {
 939                                 manModelContour->AddPoint( vecCtrlPointX[j] , vecCtrlPointY[j] , vecCtrlPointZ[j]  );
 940                         } // for
 941                         std::string theName;
 942                         theName = _modelManager->createOutline( manModelContour, actualInstantVector );
 943                         bool addedModel = theName.compare("") != 0;
 944                         if( addedModel )
 945                         {
 946                                 double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
 947                                 this->_theViewPanel->getSpacing(spc);
 948                                 //Adding the manualContourControler to interface objects structure
 949                                 //Adding the manualViewContour to interface objects structure
 950                                 //_sceneManager->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
 951                                 _sceneManager->configureViewControlTo( theName, manModelContour,spc, typeofcontour ) ;
 952                         }       // if addedModel
 953                 } // if sizeCtrPt
 954         }
 955
 956         //------------------------------------------------------------------------------------------------------------
 957         void wxContourEventHandler :: onAutomatiqueSegmentation( )
 958         {
 959                 if (_segmentationFrame==NULL)
 960                 {
 961                         //JCP 13-10-09
 962                         /*int sizeZ = _sceneManager->GetImageDataSizeZ();
 963                         double range[2];
 964                         _sceneManager->GetImageDataRange(range);*/
 965                         //JCP 13-10-09
 966
 967                          wxSize sizePanel( 300, 470);
 968                         _segmentationFrame                                      =  new wxFrame (_theViewPanel, -1,_T("  Segmentation  "), wxDefaultPosition, wxDefaultSize, wxFRAME_TOOL_WINDOW|wxSYSTEM_MENU | wxCAPTION |  wxCLIP_CHILDREN |wxFRAME_FLOAT_ON_PARENT );
 969                         _segmentationFrame->SetSize( sizePanel );
 970                         wxPanel *panel                                          = getSegmentationPanel(_segmentationFrame);
 971                                 /*new wxPanel(_segmentationFrame,-1);
 972                         wxButton *segmentationOneSliceBtn       = new wxButton(panel,-1,_T("Actual slice"), wxDefaultPosition, wxSize(200,35) );
 973                         wxButton *segmentationAllSliceBtn       = new wxButton(panel,-1,_T("All slices") ,wxDefaultPosition, wxSize(200,35) );
 974                         _isovalue                                                       = new wxSlider(panel, -1, 40 , (int)(range[0]), (int)(range[1]), wxDefaultPosition, wxSize(200,35), wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
 975                         _sampling                                                       = new wxSlider(panel, -1, 20 , 4, 50, wxDefaultPosition, wxSize(200,35), wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
 976                         wxString lstOptions[3];
 977                         lstOptions[0]="A";
 978                         lstOptions[1]="B";
 979                         lstOptions[2]="C";
 980                         methodRadiobox                                          = new wxRadioBox(panel, -1, "Method (find ctrl. Points)", wxDefaultPosition, wxSize(200,45), 3 , lstOptions,  3, wxRA_SPECIFY_COLS);
 981                         methodRadiobox->SetSelection(2);
 982                         _staticTextSegmentation                         = new wxStaticText(panel,-1,_T("    "));
 983
 984
 985                         _mbarrange                                      =  new mBarRange(panel,70, 65);
 986                         _mbarrange->SetMin(0);
 987                         _mbarrange->SetStart(0);
 988
 989                         _mbarrange-> SetOrientation( true );
 990                         _mbarrange-> setActiveStateTo(true);
 991                         _mbarrange-> setVisibleLabels( true );
 992                         _mbarrange-> setDeviceEndMargin(10);
 993                         _mbarrange-> setRepresentedValues( 0 , sizeZ );
 994                         _mbarrange-> setDeviceBlitStart(10,10);
 995                         _mbarrange-> setIfWithActualDrawed( false );
 996                         _mbarrange-> SetStart( 0 );
 997                         _mbarrange-> SetEnd( sizeZ );
 998
 999
1000 //                      _segmentationFrame->SetEventHandler( this );
1001                         segmentationOneSliceBtn->SetEventHandler( this );
1002                         segmentationAllSliceBtn->SetEventHandler( this );
1003                         Connect( segmentationOneSliceBtn->GetId(),   wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSegmentationOneSlice );
1004                         Connect( segmentationAllSliceBtn->GetId(),   wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSegmentationAllSlice );
1005
1006                         wxFlexGridSizer * sizer                         = new wxFlexGridSizer(1);
1007                         sizer -> Add( new wxStaticText(panel,-1,_T("Isovalue (Gray level)"))  , 1, wxGROW );
1008                         sizer -> Add( _isovalue , 1, wxGROW );
1009                         sizer -> Add( methodRadiobox , 1, wxGROW );
1010                         sizer -> Add( new wxStaticText(panel,-1,_T("Sampling (%)"))  , 1, wxGROW );
1011                         sizer -> Add( _sampling , 1, wxGROW );
1012                         sizer -> Add( segmentationOneSliceBtn , 1, wxGROW );
1013                         sizer -> Add( new wxStaticText(panel,-1,_T(" "))  , 1, wxGROW );
1014                         sizer -> Add( _staticTextSegmentation  , 1, wxGROW );
1015                         sizer -> Add( segmentationAllSliceBtn , 1, wxGROW );
1016                         sizer -> Add( _mbarrange  , 1, wxGROW );
1017
1018                         panel->SetSizer( sizer );
1019                         panel->SetSize( sizePanel );
1020                         panel->SetAutoLayout( true );
1021                         panel->Layout();*/
1022
1023                         this->_theViewPanel->SetVisibleAxis(true);
1024                         this->_theViewPanel->Refresh();
1025                         _segmentationFrame->Show(true);
1026 //JCP 13-10-09 View the method getSegmentationPanel(), this two methods where moved to getSegmentationPanel
1027                         //this->_theViewPanel->SetVisibleAxis(true);
1028                         //this->_theViewPanel->Refresh();
1029                 } else {
1030                         if (_segmentationFrame->IsShown()==true)
1031                         {
1032                                 _segmentationFrame->Show(false);
1033                                 this->_theViewPanel->SetVisibleAxis(false);
1034                                 this->_theViewPanel->Refresh();
1035                         } else  {
1036                                 _segmentationFrame->Show(true);
1037                                 this->_theViewPanel->SetVisibleAxis(true);
1038                                 this->_theViewPanel->Refresh();
1039                         }
1040                 }
1041         }
1042
1043         void wxContourEventHandler::showAxis(bool show){
1044                 this->_theViewPanel->SetVisibleAxis(show);
1045                 this->_theViewPanel->Refresh();
1046         }
1047         wxPanel* wxContourEventHandler::getSegmentationPanel(wxWindow* parent){
1048                 int sizeZ = _sceneManager->GetImageDataSizeZ();
1049                 double range[2];
1050                 _sceneManager->GetImageDataRange(range);
1051
1052                 wxPanel *panel                                          = new wxPanel(parent,-1);
1053                 wxButton *segmentationOneSliceBtn       = new wxButton(panel,-1,_T("Actual slice"), wxDefaultPosition, wxSize(200,35) );
1054                 wxButton *segmentationAllSliceBtn       = new wxButton(panel,-1,_T("All slices") ,wxDefaultPosition, wxSize(200,35) );
1055                 _isovalue                                                       = new wxSlider(panel, -1, 40 , (int)(range[0]), (int)(range[1]), wxDefaultPosition, wxSize(200,35), wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
1056                 _sampling                                                       = new wxSlider(panel, -1, 20 , 4, 50, wxDefaultPosition, wxSize(200,35), wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
1057                 wxString lstOptions[3];
1058                 lstOptions[0]=_T("A");
1059                 lstOptions[1]=_T("B");
1060                 lstOptions[2]=_T("C");
1061                 methodRadiobox                                          = new wxRadioBox(panel, -1, _T("Method (find ctrl. Points)"), wxDefaultPosition, wxSize(200,45), 3 , lstOptions,  3, wxRA_SPECIFY_COLS);
1062                 methodRadiobox->SetSelection(2);
1063                 _staticTextSegmentation                         = new wxStaticText(panel,-1,_T("    "));
1064
1065
1066                 _mbarrange                                      =  new mBarRange(panel,70, 65);
1067                 _mbarrange->SetMin(0);
1068                 _mbarrange->SetStart(0);
1069
1070                 _mbarrange-> SetOrientation( true );
1071                 _mbarrange-> setActiveStateTo(true);
1072                 _mbarrange-> setVisibleLabels( true );
1073                 _mbarrange-> setDeviceEndMargin(10);
1074                 _mbarrange-> setRepresentedValues( 0 , sizeZ );
1075                 _mbarrange-> setDeviceBlitStart(10,10);
1076                 _mbarrange-> setIfWithActualDrawed( false );
1077                 _mbarrange-> SetStart( 0 );
1078                 _mbarrange-> SetEnd( sizeZ );
1079
1080
1081 //                      _segmentationFrame->SetEventHandler( this );
1082                 segmentationOneSliceBtn->SetEventHandler( this );
1083                 segmentationAllSliceBtn->SetEventHandler( this );
1084                 Connect( segmentationOneSliceBtn->GetId(),   wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSegmentationOneSlice );
1085                 Connect( segmentationAllSliceBtn->GetId(),   wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSegmentationAllSlice );
1086
1087                 wxFlexGridSizer * sizer                         = new wxFlexGridSizer(1);
1088                 sizer -> Add( new wxStaticText(panel,-1,_T("Isovalue (Gray level)"))  , 1, wxGROW );
1089                 sizer -> Add( _isovalue , 1, wxGROW );
1090                 sizer -> Add( methodRadiobox , 1, wxGROW );
1091                 sizer -> Add( new wxStaticText(panel,-1,_T("Sampling (%)"))  , 1, wxGROW );
1092                 sizer -> Add( _sampling , 1, wxGROW );
1093                 sizer -> Add( segmentationOneSliceBtn , 1, wxGROW );
1094                 sizer -> Add( new wxStaticText(panel,-1,_T(" "))  , 1, wxGROW );
1095                 sizer -> Add( _staticTextSegmentation  , 1, wxGROW );
1096                 sizer -> Add( segmentationAllSliceBtn , 1, wxGROW );
1097                 sizer -> Add( _mbarrange  , 1, wxGROW );
1098
1099                 panel->SetSizer( sizer );
1100 //              panel->SetSize( sizePanel );
1101                 panel->SetSize( wxDefaultSize );
1102                 panel->SetAutoLayout( true );
1103                 panel->Layout();
1104
1105                 return panel;
1106         }
1107         void wxContourEventHandler :: onInterfaceTestFrame( )
1108         {
1109                 if (_TestFrame==NULL)
1110                 {
1111                         _contourPropagation                     = new ContourPropagation();
1112                         _TestFrame                                      = new wxFrame (_theViewPanel, -1,_T("  Test Segmentation  "), wxDefaultPosition, wxDefaultSize, wxFRAME_TOOL_WINDOW|wxSYSTEM_MENU | wxCAPTION |  wxCLIP_CHILDREN |wxFRAME_FLOAT_ON_PARENT );
1113                         wxSize sizepanel(200,300);
1114                         _TestFrame->SetSize( sizepanel );
1115                         wxPanel *panel                          = new wxPanel(_TestFrame,-1);
1116                         wxButton *spreadResetBtn        = new wxButton(panel,-1,_T("Reset"),wxDefaultPosition, wxSize(80,35) );
1117                         wxButton *spreadAddBtn          = new wxButton(panel,-1,_T("Add"),wxDefaultPosition, wxSize(80,35));
1118                         wxButton *spreadGoBtn           = new wxButton(panel,-1,_T("GoA"),wxDefaultPosition, wxSize(80,35));
1119                         _wxtextctrlTest                         = new wxTextCtrl(panel,-1, _T(""),wxDefaultPosition, wxSize(200,150), wxTE_MULTILINE );
1120
1121                         _TestFrame->SetEventHandler( this );
1122                         Connect( spreadResetBtn->GetId(),       wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onTestReset );
1123                         Connect( spreadAddBtn->GetId(),         wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onTestAdd );
1124                         Connect( spreadGoBtn->GetId(),          wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onTestGo );
1125
1126                         wxFlexGridSizer * sizer         = new wxFlexGridSizer(1);
1127                         sizer -> Add( spreadResetBtn    , 1, wxGROW );
1128                         sizer -> Add( spreadAddBtn              , 1, wxGROW );
1129                         sizer -> Add( spreadGoBtn               , 1, wxGROW );
1130                         sizer -> Add( _wxtextctrlTest , 1, wxGROW );
1131
1132                         panel->SetSizer( sizer );
1133                         panel->SetSize( sizepanel );
1134                         panel->SetAutoLayout( true );
1135                         panel->Layout();
1136                         _TestFrame->Show();
1137                 } else {
1138                         if (_TestFrame->IsShown()==true)
1139                         {
1140                                 _TestFrame->Show(false);
1141                         } else  {
1142                                 _TestFrame->Show(true);
1143                         }
1144                 }
1145         }
1146
1147         void wxContourEventHandler::onTestReset( wxCommandEvent& event )
1148         {
1149                 _wxtextctrlTest->SetValue(_T(""));
1150                 _contourPropagation->resetAppend();
1151         }
1152
1153         //------------------------------------------------------------------------------------------------------------
1154         void wxContourEventHandler::onTestAdd( wxCommandEvent& event )
1155         {
1156                 std::vector<double> vecX;
1157                 std::vector<double> vecY;
1158                 std::vector<double> vecZ;
1159                 _sceneManager->GetPointsOfActualContour( &vecX , &vecY , &vecZ );
1160
1161                 if (vecX.size()!=0){
1162                         std::vector<int> tempVector;
1163                         _instantPanel->getInstant( tempVector );
1164                         int i,size=vecZ.size();
1165                         int actualSlice = tempVector[1];
1166                         for ( i=0 ; i<size ; i++ )
1167                         {
1168                                 vecZ[i] = actualSlice;
1169                         } // for
1170
1171                         _contourPropagation->appendContour(&vecX , &vecY , &vecZ);
1172                         wxString newstring;
1173                         newstring.append(_wxtextctrlTest->GetValue());
1174                         newstring.append(_T(" "));
1175                         newstring.append(wxString(intToString(actualSlice).c_str(),wxConvUTF8));
1176                         //newstring.Printf(_T("%s %d -"),,  );
1177                         newstring.append(_T(" -"));
1178                         _wxtextctrlTest->SetValue(newstring);
1179                 } // if
1180         }
1181
1182         //------------------------------------------------------------------------------------------------------------
1183         void wxContourEventHandler::onTestGo( wxCommandEvent& event )
1184         {
1185                 std::vector<double> vecX;
1186                 std::vector<double> vecY;
1187                 std::vector<double> vecZ;
1188                 std::vector<int> size;
1189
1190                 std::vector<double> vecCtrlPointX;
1191                 std::vector<double> vecCtrlPointY;
1192                 std::vector<double> vecCtrlPointZ;
1193
1194                 //Getting the points of the actual contour
1195
1196                 _contourPropagation->GetKeyContours(&vecX , &vecY , &vecZ, &size);
1197                 for(int i = 0; i < vecX.size();i++){
1198                         vecZ[i] = -900;
1199                 }
1200
1201                 /*std::vector<double> vecX1;
1202                 std::vector<double> vecY1;
1203                 std::vector<double> vecZ1;
1204                 _sceneManager->GetPointsOfActualContour( &vecX1 , &vecY1 , &vecZ1 );
1205
1206                 std::ofstream file1;
1207         file1.open( "Temp.txt" );
1208                 if(file1.is_open())
1209                 {
1210                         for(int i = 0; i < vecX.size(); i++){
1211                                 file1<<vecX[i] <<" X1 "<< vecX1[i] <<" Y "<<vecY[i] <<" Y1 "<< vecY1[i]  <<" Z "<<vecZ[i] <<" Z1 "<< vecZ1[i]<<std::endl;
1212
1213                         }
1214                         file1.close();
1215                 }*/
1216
1217
1218
1219                 //Setting the points of the contour
1220
1221                 ExtractControlPoints2D *extractcontrolpoints2d = new ExtractControlPoints2D();
1222                 extractcontrolpoints2d->SetContour( &vecX , &vecY , &vecZ );
1223
1224                 //Getting the control points of the contour by method A
1225
1226                 extractcontrolpoints2d->GetInitialControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
1227
1228                 std::vector<int> actualInstantVector;
1229                 _instantPanel->getInstant( actualInstantVector );
1230                 actualInstantVector[1]= this->_theViewPanel->GetZ();
1231
1232
1233
1234
1235
1236                 //Adding the Contour to the scene
1237
1238                 manualContourModel *manModelContour = new manualContourModel();
1239                 int j,sizeCtrPt = vecCtrlPointX.size();
1240                 if (sizeCtrPt>=3){
1241                         for (j=0 ; j<sizeCtrPt ; j++)
1242                         {
1243                                 manModelContour->AddPoint( vecCtrlPointX[j] , vecCtrlPointY[j] , vecCtrlPointZ[j]  );
1244                         } // for
1245                         std::string theName;
1246                         theName = _modelManager->createOutline( manModelContour, actualInstantVector );
1247                         bool addedModel = theName.compare("") != 0;
1248                         if( addedModel )
1249                         {
1250                                 double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
1251                                 this->_theViewPanel->getSpacing(spc);
1252                                 //Adding the manualContourControler to interface objects structure
1253                                 //Adding the manualViewContour to interface objects structure
1254                                 //_sceneManager->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
1255                                 _sceneManager->configureViewControlTo( theName, manModelContour,spc,1 ) ;
1256                         }       // if addedModel
1257                 } // if sizeCtrPt
1258         }
1259
1260         //------------------------------------------------------------------------------------------------------------
1261         void wxContourEventHandler::FillGridWithContoursInformation()
1262         {
1263                 wxString tempString;
1264                 _grid->ClearGrid();
1265                 _grid->SetColLabelValue(0, _T("A") );
1266                 _grid->SetColLabelValue(1, _T("B") );
1267                 _grid->SetColLabelValue(2, _T("C") );
1268                 _grid->SetColLabelValue(3, _T("D") );
1269                 _grid->SetColLabelValue(4, _T("E") );
1270                 _grid->SetColLabelValue(5, _T("F") );
1271
1272                 std::vector<int> tempVector;
1273                 _instantPanel->getInstant( tempVector );
1274
1275                 int z,sizeZ = _sceneManager->GetImageDataSizeZ();
1276                 int ii,sizeLstContourThings;
1277                 for ( z=0 ; z<sizeZ ; z++)
1278                 {
1279                         tempVector[1]=z;
1280                         Instant instant(&tempVector);
1281                         std::vector<ContourThing**> lstContourThings = this->_modelManager->getOutlinesAtInstant( &instant );
1282
1283                         sizeLstContourThings = lstContourThings.size();
1284                         tempString.Printf(_T("%d - %d"),z, sizeLstContourThings);
1285                         _grid->SetRowLabelValue(z, tempString );
1286
1287                         for (ii=0 ; ii<sizeLstContourThings ; ii++)
1288                         {
1289                                 ContourThing **contourthing = lstContourThings[ii];
1290                                 tempString = wxString((*contourthing)->getName().c_str(),wxConvUTF8) ;
1291                                 _grid->SetCellValue( z, ii, tempString );
1292                         }
1293                 }
1294
1295
1296         }
1297
1298         //------------------------------------------------------------------------------------------------------------
1299         std::vector<manualContourModel*> wxContourEventHandler::ExploseEachModel( std::vector<manualContourModel*> lstManConMod )
1300         {
1301                 std::vector<manualContourModel*> lstTmp;
1302                 std::vector<manualContourModel*> lstResult;
1303                 int j,jSize;
1304                 int i,iSize=lstManConMod.size();
1305                 for (i=0;i<iSize;i++)
1306                 {
1307                         lstTmp = lstManConMod[i]->ExploseModel();
1308                         jSize=lstTmp.size();
1309                         for (j=0;j<jSize;j++)
1310                         {
1311                                 lstResult.push_back( lstTmp[j] );
1312                         }
1313                 }
1314                 return lstResult;
1315         }
1316
1317         //------------------------------------------------------------------------------------------------------------
1318         void wxContourEventHandler::onExtractInformation( wxCommandEvent& event )
1319         {
1320                 wxBusyCursor wait;
1321                 int maxContourGroup     =       0;
1322
1323                 _grid->ClearGrid();
1324
1325                 ContourExtractData      *contourextractdata = new ContourExtractData();
1326                 int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
1327                 contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
1328
1329                 std::vector<manualContourModel*> lstManConMod;
1330                 std::vector<manualContourModel*> lstManConModTmp;
1331                 std::vector<manualContourModel*> lstManConModExp;
1332                 std::vector<double> pLstValue;
1333                 std::vector<double> pLstValuePosX;
1334                 std::vector<double> pLstValuePosY;
1335                 std::vector<double> pLstValuePosZ;
1336
1337                 int             resultSize;
1338                 int             resultGrayRangeCount;
1339                 double  resultMin;
1340                 double  resultMax;
1341                 double  resultAverage;
1342                 double  resultStandardeviation;
1343
1344                 std::vector<int> tempVector;
1345                 _instantPanel->getInstant( tempVector );
1346
1347                 vtkImageData *imagedata = _sceneManager->GetImageData();
1348                 int sizeZ = _sceneManager->GetImageDataSizeZ();
1349                 int z;
1350                 int ii,sizeLstContourThings;
1351
1352
1353                 int minZ,maxZ;
1354                 double totalZ;
1355                 double porcent;
1356                 wxString tmpString;
1357
1358
1359                 if (_informationRadiobox->GetSelection()==0 ) // actual slice
1360                 {
1361                         std::vector<int> tempVector;
1362                         _instantPanel->getInstant( tempVector );
1363                         int actualSlice = tempVector[1];
1364                         minZ    = actualSlice;
1365                         maxZ    = actualSlice;
1366                 }
1367                 if (_informationRadiobox->GetSelection()==1 ) // slice range
1368                 {
1369                         minZ    = _mbarrangeSliceInformation->GetStart();
1370                         maxZ    = _mbarrangeSliceInformation->GetEnd();
1371                 }
1372                 if (_informationRadiobox->GetSelection()==2 ) // All slices
1373                 {
1374                         minZ    = 0;
1375                         maxZ    = sizeZ-1;
1376                 }
1377
1378                 totalZ  = maxZ-minZ+1;
1379                 contourextractdata->SetImage( imagedata);
1380
1381         // For each slice..
1382                 for ( z=minZ ; z<=maxZ ; z++ )
1383                 {
1384                         porcent = 100.0* (z-minZ)/totalZ;
1385                         tmpString.Printf(_T("  %d %c            %d/%d             %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
1386                         _staticTextInformation->SetLabel(tmpString);
1387
1388                         //Extraction data from contours of each slice
1389                         contourextractdata->SetZtoBeAnalys( z);
1390
1391                         tempVector[1]=z;
1392                         Instant instant(&tempVector);
1393                         std::vector<ContourThing**> lstContourThings = this->_modelManager->getOutlinesAtInstant( &instant );
1394                         sizeLstContourThings = lstContourThings.size();
1395
1396                         lstManConMod.clear();
1397                         for (ii=0 ; ii<sizeLstContourThings ; ii++)
1398                         {
1399                                 ContourThing **contourthing = lstContourThings[ii];
1400                                 lstManConMod.push_back( (*contourthing)->getModel() );
1401                         }
1402                         lstManConModExp =  ExploseEachModel( lstManConMod );
1403
1404
1405                         wxString tempString;
1406                         tempString.Printf(_T("%d - %d"),z, sizeLstContourThings);
1407                         _grid->SetRowLabelValue(z, tempString );
1408 //EED004
1409                         int iContourGroup,sizeContourGroup;
1410                         if (typeContourGroup==3) // contour separete
1411                         {
1412                                 sizeContourGroup=lstManConModExp.size();
1413                                 if ( maxContourGroup<sizeContourGroup )
1414                                 {
1415                                         maxContourGroup=sizeContourGroup;
1416                                 }
1417                         } else {  // contour AND OR XOR
1418                                 sizeContourGroup=1;
1419                                 maxContourGroup=1;
1420                         }
1421
1422                         int tmpIntA;
1423
1424
1425
1426                         for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
1427                                 lstManConModTmp.clear();
1428                                 if (typeContourGroup==3) // contour separete
1429                                 {
1430                                         lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
1431                                 } else {  // contour AND OR XOR
1432                                         lstManConModTmp = lstManConModExp;
1433                                 }
1434
1435                                 contourextractdata->SetLstManualContourModel( lstManConModTmp );
1436
1437                                 pLstValue.clear();
1438                                 pLstValuePosX.clear();
1439                                 pLstValuePosY.clear();
1440                                 pLstValuePosZ.clear();
1441                                 contourextractdata->GetValuesInsideCrown(       &pLstValue,
1442                                                                                                                         &pLstValuePosX,
1443                                                                                                                         &pLstValuePosY,
1444                                                                                                                         &pLstValuePosZ);
1445                                 // Statistics of each slice.
1446                                 contourextractdata->Statistics( &pLstValue,
1447                                                                                                 _mbarrangeRangeInformation->GetStart(),
1448                                                                                                 _mbarrangeRangeInformation->GetEnd(),
1449                                                                                                 &resultGrayRangeCount,
1450                                                                                                 &resultSize,
1451                                                                                                 &resultMin,
1452                                                                                                 &resultMax,
1453                                                                                                 &resultAverage,
1454                                                                                                 &resultStandardeviation);
1455                                 if (_grid->GetNumberCols()<_numberOfVariablesStatistics*(iContourGroup+1)  )
1456                                 {
1457                                         _grid->AppendCols(_numberOfVariablesStatistics);
1458                                 }
1459
1460                                 tmpIntA=_numberOfVariablesStatistics*iContourGroup ;
1461
1462                                 tempString.Printf(_T("%d"),resultSize);
1463                                 _grid->SetCellValue( z, tmpIntA + 0, tempString );
1464                                 tempString.Printf(_T("%d"),resultGrayRangeCount);
1465                                 _grid->SetCellValue( z, tmpIntA + 1, tempString );
1466                                 tempString.Printf(_T("%f"),resultMin);
1467                                 _grid->SetCellValue( z, tmpIntA + 2, tempString );
1468                                 tempString.Printf(_T("%f"),resultMax);
1469                                 _grid->SetCellValue( z, tmpIntA + 3, tempString );
1470                                 tempString.Printf(_T("%f"),resultAverage);
1471                                 _grid->SetCellValue( z, tmpIntA + 4, tempString );
1472                                 tempString.Printf(_T("%f"),resultStandardeviation);
1473                                 _grid->SetCellValue( z, tmpIntA + 5, tempString );
1474
1475                         } // for iContourGroup
1476                 } // for z
1477
1478                 int iTitleGroup;
1479                 wxString tmpTitleString;
1480                 int tmpIntB;
1481                 for ( iTitleGroup=0 ; iTitleGroup<maxContourGroup ; iTitleGroup++ )
1482                 {
1483                         tmpIntB =_numberOfVariablesStatistics*iTitleGroup;
1484                         tmpTitleString.Printf(_T("%d-Size Data"),iTitleGroup);
1485                         _grid->SetColLabelValue( tmpIntB + 0, tmpTitleString );
1486                         _grid->SetColLabelValue( tmpIntB + 1, _T("Size Range") );
1487                         _grid->SetColLabelValue( tmpIntB + 2, _T("Min") );
1488                         _grid->SetColLabelValue( tmpIntB + 3, _T("Max") );
1489                         _grid->SetColLabelValue( tmpIntB + 4, _T("Average") );
1490                         _grid->SetColLabelValue( tmpIntB + 5, _T("St.Dev.") );
1491                         _grid->SetColLabelValue( tmpIntB + 6, _T(" ") );
1492                 }
1493
1494                 _staticTextInformation->SetLabel( _T("") );
1495                 delete contourextractdata;
1496         }
1497
1498
1499         //------------------------------------------------------------------------------------------------------------
1500         void wxContourEventHandler::SaveValuesXYZ(std::string directory,std::string namefile)
1501         {
1502                 wxBusyCursor wait;
1503                 ContourExtractData      *contourextractdata = new ContourExtractData();
1504                 int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
1505                 contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
1506
1507                 std::vector<manualContourModel*> lstManConMod;
1508                 std::vector<manualContourModel*> lstManConModTmp;
1509                 std::vector<manualContourModel*> lstManConModExp;
1510                 std::vector<double> pLstValue;
1511                 std::vector<double> pLstValuePosX;
1512                 std::vector<double> pLstValuePosY;
1513                 std::vector<double> pLstValuePosZ;
1514
1515                 std::vector<int> tempVector;
1516                 _instantPanel->getInstant( tempVector );
1517
1518                 vtkImageData *imagedata = _sceneManager->GetImageData();
1519                 int sizeZ = _sceneManager->GetImageDataSizeZ();
1520                 int z;
1521                 int ii,sizeLstContourThings;
1522
1523
1524                 int minZ,maxZ;
1525                 double totalZ;
1526                 double porcent;
1527                 wxString tmpString;
1528                 minZ    = 0;// _mbarrange->GetStart();
1529                 maxZ    = sizeZ;//_mbarrange->GetEnd();
1530                 totalZ  = maxZ-minZ+1;
1531
1532                 contourextractdata->SetImage( imagedata);
1533
1534         // For each slice..
1535                 for ( z=0 ; z<sizeZ ; z++)
1536                 {
1537
1538                         porcent = 100.0* (z-minZ)/totalZ;
1539
1540                         tmpString.Printf(_T("Saving Values"));
1541                         tmpString.Printf(_T("  %d %c            %d/%d             %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
1542                         _staticTextInformation->SetLabel(tmpString);
1543
1544
1545                         //Extraction data from contours of each slice
1546                         contourextractdata->SetZtoBeAnalys( z);
1547
1548                         tempVector[1]=z;
1549                         Instant instant(&tempVector);
1550                         std::vector<ContourThing**> lstContourThings = this->_modelManager->getOutlinesAtInstant( &instant );
1551                         sizeLstContourThings = lstContourThings.size();
1552
1553                         lstManConMod.clear();
1554                         for (ii=0 ; ii<sizeLstContourThings ; ii++)
1555                         {
1556                                 ContourThing **contourthing = lstContourThings[ii];
1557                                 lstManConMod.push_back( (*contourthing)->getModel() );
1558                         }
1559                         lstManConModExp =  ExploseEachModel( lstManConMod );
1560
1561
1562 //EED004
1563
1564                         int iContourGroup,sizeContourGroup;
1565                         if (typeContourGroup==3) // contour separete
1566                         {
1567                                 sizeContourGroup=lstManConModExp.size();
1568                         } else {  // contour AND OR XOR
1569                                 sizeContourGroup=1;
1570                         }
1571
1572                         for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
1573                                 lstManConModTmp.clear();
1574                                 if (typeContourGroup==3) // contour separete
1575                                 {
1576                                         lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
1577                                 } else {  // contour AND OR XOR
1578                                         lstManConModTmp = lstManConModExp;
1579                                 }
1580
1581                                 contourextractdata->SetLstManualContourModel( lstManConModTmp );
1582
1583                                 pLstValue.clear();
1584                                 pLstValuePosX.clear();
1585                                 pLstValuePosY.clear();
1586                                 pLstValuePosZ.clear();
1587                                 contourextractdata->GetValuesInsideCrown(       &pLstValue,
1588                                                                                                                         &pLstValuePosX,
1589                                                                                                                         &pLstValuePosY,
1590                                                                                                                         &pLstValuePosZ);
1591
1592                                 wxString filename;
1593                                 filename.Printf(_T("%s"),directory.c_str());
1594                                 filename.Printf(_T("\\"));
1595                                 filename.Printf(_T("%s"),namefile.c_str());
1596                                 filename.Printf(_T("-slice"));
1597                                 filename.Printf(_T("%d"),z);
1598                                 filename.Printf(_T("-cont"));
1599                                 filename.Printf(_T("%d"),iContourGroup);
1600                                 filename.Printf(_T(".txt"));
1601                                 FILE *pFile=fopen((const char *)filename.mb_str(),"w+");
1602                                 fprintf(pFile,"value \t x \t y \t z\n"  );
1603                                 int iLstValue,sizeLstValue=pLstValue.size();
1604                                 for (iLstValue=0 ; iLstValue<sizeLstValue ; iLstValue++ )
1605                                 {
1606                                         fprintf(pFile,"%f\t %f\t %f\t %f\n", (float)pLstValue[iLstValue] , (float)pLstValuePosX[iLstValue], (float)pLstValuePosY[iLstValue], (float)z );
1607                                 }
1608                                 fclose(pFile);
1609                         } // for  iContourGroup
1610                 } // for z
1611                 _staticTextInformation->SetLabel( _T("") );
1612                 delete contourextractdata;
1613         }
1614
1615
1616         //------------------------------------------------------------------------------------------------------------
1617         void wxContourEventHandler::SaveImageResult(std::string directory,std::string namefile)
1618         {
1619                 wxBusyCursor wait;
1620                 ContourExtractData      *contourextractdata = new ContourExtractData( true );
1621                 int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
1622                 if (typeContourGroup==3)
1623                 {
1624                         typeContourGroup=1;
1625                 }
1626                 contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
1627
1628                 std::vector<manualContourModel*> lstManConMod;
1629                 std::vector<manualContourModel*> lstManConModTmp;
1630                 std::vector<manualContourModel*> lstManConModExp;
1631
1632                 std::vector<int> tempVector;
1633                 _instantPanel->getInstant( tempVector );
1634
1635                 vtkImageData *imagedata = _sceneManager->GetImageData();
1636                 int sizeZ = _sceneManager->GetImageDataSizeZ();
1637                 int z;
1638                 int ii,sizeLstContourThings;
1639
1640
1641                 int minZ,maxZ;
1642                 double totalZ;
1643                 double porcent;
1644
1645                 wxString tmpString;
1646
1647                 minZ    = 0;// _mbarrange->GetStart();
1648                 maxZ    = sizeZ;//_mbarrange->GetEnd();
1649                 totalZ  = maxZ-minZ+1;
1650
1651                 contourextractdata->SetImage( imagedata);
1652
1653         // For each slice..
1654                 for ( z=0 ; z<sizeZ ; z++)
1655                 {
1656
1657                         porcent = 100.0* (z-minZ)/totalZ;
1658                         tmpString.Printf(_T("Saving Values"));
1659                         tmpString.Printf(_T("%d %c            %d/%d             %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
1660                         _staticTextInformation->SetLabel(tmpString);
1661
1662                         //Extraction data from contours of each slice
1663                         contourextractdata->SetZtoBeAnalys( z);
1664
1665                         tempVector[1]=z;
1666                         Instant instant(&tempVector);
1667                         std::vector<ContourThing**> lstContourThings = this->_modelManager->getOutlinesAtInstant( &instant );
1668                         sizeLstContourThings = lstContourThings.size();
1669
1670                         lstManConMod.clear();
1671                         for (ii=0 ; ii<sizeLstContourThings ; ii++)
1672                         {
1673                                 ContourThing **contourthing = lstContourThings[ii];
1674                                 lstManConMod.push_back( (*contourthing)->getModel() );
1675                         }
1676                         lstManConModExp =  ExploseEachModel( lstManConMod );
1677
1678
1679                         int iContourGroup,sizeContourGroup;
1680                         if (typeContourGroup==3) // contour separete
1681                         {
1682                                 sizeContourGroup=lstManConModExp.size();
1683                         } else {  // contour AND OR XOR
1684                                 sizeContourGroup=1;
1685                         }
1686
1687                         for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
1688                                 lstManConModTmp.clear();
1689                                 if (typeContourGroup==3) // contour separete
1690                                 {
1691                                         lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
1692                                 } else {  // contour AND OR XOR
1693                                         lstManConModTmp = lstManConModExp;
1694                                 }
1695
1696                                 contourextractdata->SetLstManualContourModel( lstManConModTmp );
1697
1698
1699 //                              for (ii=0 ; ii<sizeLstContourThings ; ii++)
1700 //                              {
1701 //                                      ContourThing **contourthing = lstContourThings[ii];
1702 //                                      lstManConMod.push_back( (*contourthing)->getModel() );
1703 //                              }
1704 //                              contourextractdata->SetLstManualContourModel( lstManConMod );
1705
1706                                 contourextractdata->CalculateImageResult(); // with actual Z
1707
1708                         } // for  iContourGroup
1709                 } // for z
1710
1711
1712                 wxString filename;
1713                 //filename.Printf(_T("%s\\%s-Value.mhd",directory.c_str(),namefile.c_str(),z);
1714                 filename.Printf(_T("%s"),directory.c_str());
1715                 filename.Printf(_T("\\"));
1716                 filename.Printf(_T("%s"),namefile.c_str());
1717                 filename.Printf(_T("-Value.mhd"));
1718
1719 // Image Value
1720                 vtkMetaImageWriter *writerValueImage = vtkMetaImageWriter::New( );
1721                 writerValueImage->SetInput( contourextractdata->GetVtkImageValueResult() );
1722                 writerValueImage->SetFileName( (const char *)filename.mb_str() );
1723                 writerValueImage->SetFileDimensionality( 3 );
1724                 writerValueImage->Write( );
1725
1726 // Image Mask
1727                 //              filename.Printf("%s\\%s-Mask.mhd",directory.c_str(),namefile.c_str(),z);
1728                 filename.Printf(_T("%s"),directory.c_str());
1729                 filename.Printf(_T("\\"));
1730                 filename.Printf(_T("%s"),namefile.c_str());
1731                 filename.Printf(_T("-Mask.mhd"));
1732                 vtkMetaImageWriter *writerMaskImage = vtkMetaImageWriter::New( );
1733                 writerMaskImage->SetInput( contourextractdata->GetVtkImageMaskResult() );
1734                 writerMaskImage->SetFileName( (const char *)filename.mb_str() );
1735                 writerMaskImage->SetFileDimensionality( 3 );
1736                 writerMaskImage->Write( );
1737
1738                 _staticTextInformation->SetLabel( _T("") );
1739                 delete contourextractdata;
1740         }
1741
1742
1743         //------------------------------------------------------------------------------------------------------------
1744         void wxContourEventHandler::onInformationContourLabels( wxCommandEvent& event )
1745         {
1746                 wxBusyCursor wait;
1747                 FillGridWithContoursInformation();
1748         }
1749
1750
1751         //------------------------------------------------------------------------------------------------------------
1752         void wxContourEventHandler::onSaveResults( wxCommandEvent& event )
1753         {
1754                 wxFileDialog dialog(_InformationContourFrame, _T("Choose a file"), _T(""), _T(""), _T("*.txt"), wxSAVE );
1755                 if (dialog.ShowModal() == wxID_OK)
1756                 {
1757                         onExtractInformation( event );
1758                         std::string directory=(const char *)(dialog.GetDirectory().mb_str());
1759                         std::string namefile=(const char *)(dialog.GetFilename().mb_str());
1760
1761                         SaveValuesXYZ( directory , namefile );
1762                         SaveImageResult( directory , namefile );
1763
1764                         std::string filename = (const char *)(dialog.GetPath().mb_str() );
1765                         FILE *pFile=fopen(filename.c_str(),"w+");
1766
1767                         int sizeZ = _sceneManager->GetImageDataSizeZ();
1768
1769                         wxString tmpString;
1770                         int i,j,maxX,maxY=sizeZ;
1771                         maxX=this->_grid->GetNumberCols();
1772
1773                         int iTitle,sizeTitle = (maxX / _numberOfVariablesStatistics);
1774                         for ( iTitle=0; iTitle<sizeTitle ; iTitle++)
1775                         {
1776                                 fprintf(pFile,"-- \t %d-Size \t SizeRange \t Min \t Max \t Ave \t StDv \t" , iTitle,tmpString.char_str() );
1777                         }
1778                         fprintf(pFile,"\n" );
1779
1780
1781
1782                         for ( j=0; j<maxY ; j++)
1783                         {
1784                                 fprintf(pFile,"%d\t" , j );
1785                                 for (i=0 ; i<maxX ; i++){
1786                                         tmpString = _grid->GetCellValue( j , i );
1787                                         fprintf(pFile,"%s\t" , (const char *)(tmpString.mb_str()) );
1788                                 } // for i
1789                                 fprintf(pFile,"\n"  );
1790                         } // for j
1791
1792                         fclose(pFile);
1793                 } // if  ShowModal
1794
1795
1796         }
1797
1798
1799         //------------------------------------------------------------------------------------------------------------
1800         void wxContourEventHandler::onInformationContourFrame()
1801         {
1802                 if (_InformationContourFrame==NULL)
1803                 {
1804                         _InformationContourFrame                                                = new wxFrame (_theViewPanel, -1,_T("  Information  "), wxDefaultPosition, wxDefaultSize, wxFRAME_TOOL_WINDOW|wxSYSTEM_MENU | wxCAPTION |  wxCLIP_CHILDREN |wxFRAME_FLOAT_ON_PARENT | wxRESIZE_BORDER  );
1805                         _InformationContourFrame->SetSize( wxSize(500,450) );
1806                         wxSize sizepanel(200,300);
1807                         wxPanel *panel                                                                  = getInformationPanel(_InformationContourFrame);
1808 //JCP 13-10-09  Grouping the panel in a method
1809                         /*new wxPanel(_InformationContourFrame,-1,wxDefaultPosition, wxDefaultSize,wxTAB_TRAVERSAL);
1810
1811                         wxString lstOptions[4];
1812                         lstOptions[0]=_T("Actual Slice");
1813                         lstOptions[1]=_T("Range Slices");
1814                         lstOptions[2]=_T("All Slices");
1815                         _informationRadiobox                                                    = new wxRadioBox(panel, -1, _T("Slice analysis"), wxDefaultPosition, wxSize(270,45), 3 , lstOptions,  3, wxRA_SPECIFY_COLS);
1816
1817                         wxString lstOptContOperation[5];
1818                         lstOptContOperation[0]=_T("AND");
1819                         lstOptContOperation[1]=_T("OR");
1820                         lstOptContOperation[2]=_T("XOR");
1821                         lstOptContOperation[3]=_T("ALL");
1822                         _radiolstboxContourGroup                                                = new wxRadioBox(panel, -1, _T("Contour group"), wxDefaultPosition, wxSize(270,45), 4 , lstOptContOperation,  4, wxRA_SPECIFY_COLS);
1823
1824                         wxButton *informationContourLabelsBtn                   = new wxButton(panel,-1,_T("Contour labels"),wxDefaultPosition, wxSize(140,35) );
1825                         informationContourLabelsBtn->SetEventHandler( this );
1826                         Connect( informationContourLabelsBtn->GetId(),          wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onInformationContourLabels );
1827
1828                         wxButton *statisticsContourBtn                                  = new wxButton(panel,-1,_T("Contour statistics"),wxDefaultPosition, wxSize(140,35) );
1829                         statisticsContourBtn->SetEventHandler( this );
1830                         Connect( statisticsContourBtn->GetId(),         wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onExtractInformation );
1831
1832                         wxButton *saveResultsBtn                                                = new wxButton(panel,-1,_T("Save statistics results"),wxDefaultPosition, wxSize(140,35) );
1833                         saveResultsBtn->SetEventHandler( this );
1834                         Connect( saveResultsBtn->GetId(),               wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSaveResults );
1835
1836
1837                         int sizeZ = this->_sceneManager->GetImageDataSizeZ();
1838                         _mbarrangeSliceInformation                                      =  new mBarRange(panel,65,65);
1839                         _mbarrangeSliceInformation->SetMin(0);
1840                         _mbarrangeSliceInformation->SetStart(0);
1841                         _mbarrangeSliceInformation-> SetOrientation( true );
1842                         _mbarrangeSliceInformation-> setActiveStateTo(true);
1843                         _mbarrangeSliceInformation-> setVisibleLabels( true );
1844                         _mbarrangeSliceInformation-> setDeviceEndMargin(10);
1845                         _mbarrangeSliceInformation-> setRepresentedValues( 0 , sizeZ-1 );
1846                         _mbarrangeSliceInformation-> setDeviceBlitStart(10,10);
1847                         _mbarrangeSliceInformation-> setIfWithActualDrawed( false );
1848                         _mbarrangeSliceInformation-> SetStart( 0 );
1849                         _mbarrangeSliceInformation-> SetEnd( sizeZ-1 );
1850
1851
1852                         double range[2];
1853                         this->_sceneManager->GetImageDataRange(range);
1854                         _mbarrangeRangeInformation                                      =  new mBarRange(panel,65,65);
1855                         _mbarrangeRangeInformation->SetMin(0);
1856                         _mbarrangeRangeInformation->SetStart(0);
1857                         _mbarrangeRangeInformation-> SetOrientation( true );
1858                         _mbarrangeRangeInformation-> setActiveStateTo(true);
1859                         _mbarrangeRangeInformation-> setVisibleLabels( true );
1860                         _mbarrangeRangeInformation-> setDeviceEndMargin(10);
1861                         _mbarrangeRangeInformation-> setRepresentedValues( range[0] , range[1] );
1862                         _mbarrangeRangeInformation-> setDeviceBlitStart(10,10);
1863                         _mbarrangeRangeInformation-> setIfWithActualDrawed( false );
1864                         _mbarrangeRangeInformation-> SetStart( range[0] );
1865                         _mbarrangeRangeInformation-> SetEnd( range[1] );
1866
1867
1868                         _staticTextInformation                                                  = new wxStaticText(panel,-1,_T("    "));
1869
1870
1871 //                      wxButton *XXXXXXXBtn                    = new wxButton(panel,-1,_T("Statistics"),wxDefaultPosition, wxSize(180,35) );
1872 //                      XXXXXXXBtn->SetEventHandler( this );
1873 //                      Connect( XXXXXXXBtn->GetId(),           wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onXXXXX );
1874
1875
1876                         _grid = new wxGrid( panel,
1877                        wxID_ANY,
1878                        wxPoint( 0, 0 ),
1879                        wxSize( 100, 100 ) );
1880
1881                         int i,gridCol=10,gridRow=sizeZ;
1882                         _grid->CreateGrid( 0, 0 );
1883                         _grid->AppendRows(gridRow);
1884                         _grid->AppendCols(gridCol);
1885
1886                         for (i=0;i<gridRow;i++)
1887                         {
1888                                 _grid->SetRowLabelValue(i, _T(" ") );
1889                         }
1890 //                      _grid->SetColLabelSize(0);
1891
1892
1893                         FillGridWithContoursInformation();
1894
1895                         wxFlexGridSizer * sizerA                = new wxFlexGridSizer(10);
1896                         sizerA->Add( _informationRadiobox                       , 1, wxALL ,2 );
1897                         sizerA->Add( _radiolstboxContourGroup           , 1, wxALL ,2 );
1898
1899                         wxFlexGridSizer * sizerB                = new wxFlexGridSizer(10);
1900                         sizerB->Add( informationContourLabelsBtn        , 1, wxALL ,2 );
1901                         sizerB->Add( statisticsContourBtn                       , 1, wxALL ,2 );
1902                         sizerB->Add( saveResultsBtn                                     , 1, wxALL ,2 );
1903
1904                         wxFlexGridSizer * sizer         = new wxFlexGridSizer(1);
1905                         sizer->AddGrowableCol(0);
1906                         sizer->AddGrowableRow(7);
1907                         sizer->Add( sizerA                                              , 1, wxALL              , 0 );
1908                         sizer->Add( new wxStaticText(panel              ,-1,_T("Slice Range"))  , 1, wxALL              , 0 );
1909                         sizer->Add( _mbarrangeSliceInformation  , 1, wxALL|wxGROW               , 2 );
1910                         sizer->Add( new wxStaticText(panel              ,-1,_T("Gray Range"))   , 1, wxALL              , 0 );
1911                         sizer->Add( _mbarrangeRangeInformation  , 1, wxALL|wxGROW               , 2 );
1912                         sizer->Add( sizerB                                              , 1, wxALL              , 0 );
1913                         sizer->Add( _staticTextInformation              , 1, wxALL              , 0 );
1914                         sizer->Add( _grid                                               , 1, wxEXPAND   , 0 );
1915
1916
1917
1918                         panel->SetSizer( sizer );
1919                         panel->SetSize( wxSize(1500,1500) );
1920                         //panel->SetBackgroundColour( wxColour(100,100,100) );
1921                         panel->SetAutoLayout( true );
1922                         panel->Layout();*/
1923
1924                         wxBoxSizer * sizerPanel         = new wxBoxSizer(wxHORIZONTAL);
1925
1926 //                      sizerPanel->AddGrowableCol(0);
1927 //                      sizerPanel->AddGrowableRow(0);
1928
1929 //JCP 14-10-09
1930                         //sizerPanel -> Add( sizer              , 1, wxEXPAND ,0);
1931                         sizerPanel -> Add( panel->GetSizer()            , 1, wxEXPAND ,0);
1932 //JCP 14-10-09
1933
1934
1935
1936                         _InformationContourFrame->SetSizer( sizerPanel );
1937                         _InformationContourFrame->SetAutoLayout( true );
1938                         _InformationContourFrame->Layout();
1939
1940                         _InformationContourFrame->Show();
1941                 } else {
1942                         if (_InformationContourFrame->IsShown()==true)
1943                         {
1944                                 _InformationContourFrame->Show(false);
1945                         } else  {
1946                                 FillGridWithContoursInformation();
1947                                 _InformationContourFrame->Show(true);
1948                         }
1949                 }
1950         }
1951
1952         wxPanel* wxContourEventHandler::getInformationPanel(wxWindow* parent){
1953         wxPanel *panel                                                                  = new wxPanel(parent,-1,wxDefaultPosition, wxDefaultSize,wxTAB_TRAVERSAL);
1954
1955                 wxString lstOptions[4];
1956                 lstOptions[0]=_T("Actual Slice");
1957                 lstOptions[1]=_T("Range Slices");
1958                 lstOptions[2]=_T("All Slices");
1959                 _informationRadiobox                                                    = new wxRadioBox(panel, -1, _T("Slice analysis"), wxDefaultPosition, wxSize(270,45), 3 , lstOptions,  3, wxRA_SPECIFY_COLS);
1960
1961                 wxString lstOptContOperation[5];
1962                 lstOptContOperation[0]=_T("AND");
1963                 lstOptContOperation[1]=_T("OR");
1964                 lstOptContOperation[2]=_T("XOR");
1965                 lstOptContOperation[3]=_T("ALL");
1966                 _radiolstboxContourGroup                                                = new wxRadioBox(panel, -1, _T("Contour group"), wxDefaultPosition, wxSize(270,45), 4 , lstOptContOperation,  4, wxRA_SPECIFY_COLS);
1967
1968                 wxButton *informationContourLabelsBtn                   = new wxButton(panel,-1,_T("Contour labels"),wxDefaultPosition, wxSize(140,35) );
1969                 informationContourLabelsBtn->SetEventHandler( this );
1970                 Connect( informationContourLabelsBtn->GetId(),          wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onInformationContourLabels );
1971
1972                 wxButton *statisticsContourBtn                                  = new wxButton(panel,-1,_T("Contour statistics"),wxDefaultPosition, wxSize(140,35) );
1973                 statisticsContourBtn->SetEventHandler( this );
1974                 Connect( statisticsContourBtn->GetId(),         wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onExtractInformation );
1975
1976                 wxButton *saveResultsBtn                                                = new wxButton(panel,-1,_T("Save statistics results"),wxDefaultPosition, wxSize(140,35) );
1977                 saveResultsBtn->SetEventHandler( this );
1978                 Connect( saveResultsBtn->GetId(),               wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSaveResults );
1979
1980
1981                 int sizeZ = this->_sceneManager->GetImageDataSizeZ();
1982                 _mbarrangeSliceInformation                                      =  new mBarRange(panel,65,65);
1983                 _mbarrangeSliceInformation->SetMin(0);
1984                 _mbarrangeSliceInformation->SetStart(0);
1985                 _mbarrangeSliceInformation-> SetOrientation( true );
1986                 _mbarrangeSliceInformation-> setActiveStateTo(true);
1987                 _mbarrangeSliceInformation-> setVisibleLabels( true );
1988                 _mbarrangeSliceInformation-> setDeviceEndMargin(10);
1989                 _mbarrangeSliceInformation-> setRepresentedValues( 0 , sizeZ-1 );
1990                 _mbarrangeSliceInformation-> setDeviceBlitStart(10,10);
1991                 _mbarrangeSliceInformation-> setIfWithActualDrawed( false );
1992                 _mbarrangeSliceInformation-> SetStart( 0 );
1993                 _mbarrangeSliceInformation-> SetEnd( sizeZ-1 );
1994
1995
1996                 double range[2];
1997                 this->_sceneManager->GetImageDataRange(range);
1998                 _mbarrangeRangeInformation                                      =  new mBarRange(panel,65,65);
1999                 _mbarrangeRangeInformation->SetMin(0);
2000                 _mbarrangeRangeInformation->SetStart(0);
2001                 _mbarrangeRangeInformation-> SetOrientation( true );
2002                 _mbarrangeRangeInformation-> setActiveStateTo(true);
2003                 _mbarrangeRangeInformation-> setVisibleLabels( true );
2004                 _mbarrangeRangeInformation-> setDeviceEndMargin(10);
2005                 _mbarrangeRangeInformation-> setRepresentedValues( range[0] , range[1] );
2006                 _mbarrangeRangeInformation-> setDeviceBlitStart(10,10);
2007                 _mbarrangeRangeInformation-> setIfWithActualDrawed( false );
2008                 _mbarrangeRangeInformation-> SetStart( range[0] );
2009                 _mbarrangeRangeInformation-> SetEnd( range[1] );
2010
2011
2012                 _staticTextInformation                                                  = new wxStaticText(panel,-1,_T("    "));
2013
2014
2015 //                      wxButton *XXXXXXXBtn                    = new wxButton(panel,-1,_T("Statistics"),wxDefaultPosition, wxSize(180,35) );
2016 //                      XXXXXXXBtn->SetEventHandler( this );
2017 //                      Connect( XXXXXXXBtn->GetId(),           wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onXXXXX );
2018
2019
2020                 _grid = new wxGrid( panel,
2021                     wxID_ANY,
2022                     wxPoint( 0, 0 ),
2023                     wxSize( 100, 100 ) );
2024
2025                 int i,gridCol=10,gridRow=sizeZ;
2026                 _grid->CreateGrid( 0, 0 );
2027                 _grid->AppendRows(gridRow);
2028                 _grid->AppendCols(gridCol);
2029
2030                 for (i=0;i<gridRow;i++)
2031                 {
2032                         _grid->SetRowLabelValue(i, _T(" ") );
2033                 }
2034 //                      _grid->SetColLabelSize(0);
2035
2036
2037                 FillGridWithContoursInformation();
2038
2039                 wxFlexGridSizer * sizerA                = new wxFlexGridSizer(10);
2040                 sizerA->Add( _informationRadiobox                       , 1, wxALL ,2 );
2041                 sizerA->Add( _radiolstboxContourGroup           , 1, wxALL ,2 );
2042
2043                 wxFlexGridSizer * sizerB                = new wxFlexGridSizer(10);
2044                 sizerB->Add( informationContourLabelsBtn        , 1, wxALL ,2 );
2045                 sizerB->Add( statisticsContourBtn                       , 1, wxALL ,2 );
2046                 sizerB->Add( saveResultsBtn                                     , 1, wxALL ,2 );
2047
2048                 wxFlexGridSizer * sizer         = new wxFlexGridSizer(1);
2049                 sizer->AddGrowableCol(0);
2050                 sizer->AddGrowableRow(7);
2051                 sizer->Add( sizerA                                              , 1, wxALL              , 0 );
2052                 sizer->Add( new wxStaticText(panel              ,-1,_T("Slice Range"))  , 1, wxALL              , 0 );
2053                 sizer->Add( _mbarrangeSliceInformation  , 1, wxALL|wxGROW               , 2 );
2054                 sizer->Add( new wxStaticText(panel              ,-1,_T("Gray Range"))   , 1, wxALL              , 0 );
2055                 sizer->Add( _mbarrangeRangeInformation  , 1, wxALL|wxGROW               , 2 );
2056                 sizer->Add( sizerB                                              , 1, wxALL              , 0 );
2057                 sizer->Add( _staticTextInformation              , 1, wxALL              , 0 );
2058                 sizer->Add( _grid                                               , 1, wxEXPAND   , 0 );
2059
2060
2061
2062                 panel->SetSizer( sizer );
2063                 panel->SetSize( wxSize(1500,1500) );
2064                 //panel->SetBackgroundColour( wxColour(100,100,100) );
2065                 panel->SetAutoLayout( true );
2066                 panel->Layout();
2067                 return panel;
2068         }
2069         //------------------------------------------------------------------------------------------------------------
2070         void wxContourEventHandler :: onSpreadInDepth( std::vector<std::string> & keyNamesVector )
2071         {
2072
2073         }
2074         //------------------------------------------------------------------------------------------------------------
2075         void wxContourEventHandler :: onOutline_Union_Of( std::vector<std::string> & keyNamesVector )
2076         {
2077
2078         }
2079         //------------------------------------------------------------------------------------------------------------
2080         void wxContourEventHandler :: onOutline_Intersection_Of( std::vector<std::string> & keyNamesVector )
2081         {
2082
2083         }
2084         //------------------------------------------------------------------------------------------------------------
2085         void wxContourEventHandler :: onOutline_Combination_Of( std::vector<std::string> & keyNamesVector )
2086         {
2087
2088         }
2089         //------------------------------------------------------------------------------------------------------------
2090         void wxContourEventHandler :: onOutline_Fragmentation_Of( std::vector<std::string> & keyNamesVector )
2091         {
2092
2093         }
2094         //------------------------------------------------------------------------------------------------------------
2095         void wxContourEventHandler :: onOutline_Agrupation_Of( std::vector<std::string> & keyNamesVector )
2096         {
2097
2098         }
2099         //------------------------------------------------------------------------------------------------------------
2100         void wxContourEventHandler :: onCopyOutlines( std::vector<std::string> & keyNamesVector )
2101         {
2102                 std::vector<int> tempVector;
2103                 _instantPanel->getInstant( tempVector );
2104         _performingOperation->reset();
2105                 _performingOperation->setStartCommand( (char)wxContour_ActionCommandsID::COPY_TOOL );
2106                 _performingOperation->setStartOperationInstantVector( tempVector );
2107                 _performingOperation->setKeyNamesOperationElems( keyNamesVector );
2108
2109         }
2110         //------------------------------------------------------------------------------------------------------------
2111         void wxContourEventHandler :: onPasteOutlines( )
2112         {
2113                 char theStartCommand = _performingOperation->getStartCommand();
2114                 if (  theStartCommand == wxContour_ActionCommandsID::COPY_TOOL )
2115                 {
2116                         //JCP 20-10-08 Undo redo implementation
2117                         saveState();
2118                         //JCP 20-10-08 Undo redo implementation
2119
2120
2121                         std::vector<int> tempVector;
2122                         _instantPanel->getInstant( tempVector );
2123                         _performingOperation->setEndOperationInstantVector ( tempVector );
2124                         std::vector<std::string> elems = _performingOperation->getKeyNamesOperationElems();
2125                         int i,size = elems.size();
2126                         for( i=0; i<size; i++ )
2127                         {
2128                                 createCopyContourOf( elems[i], tempVector, i>0 );
2129                         }
2130
2131
2132                 }
2133                 int fin = 0;
2134         }
2135         //------------------------------------------------------------------------------------------------------------
2136         void wxContourEventHandler :: onShowOutlines( std::vector<std::string> & keyNamesVector )
2137         {
2138
2139         }
2140         //------------------------------------------------------------------------------------------------------------
2141         void wxContourEventHandler :: onHideOutlines( std::vector<std::string> & keyNamesVector )
2142         {
2143
2144         }
2145         //------------------------------------------------------------------------------------------------------------
2146         void wxContourEventHandler :: onSelectOutlines( std::vector<std::string> & keyNamesVector )
2147         {
2148                 //if( keyNamesVector.empty() )
2149                 {
2150                         _sceneManager->drawSelectionROI( );
2151                 }
2152                 /*else
2153                 {
2154                         int ok = keyNamesVector.size();
2155                         _sceneManager->selectObjects( keyNamesVector );
2156                         std::string name = keyNamesVector[0];
2157                 }*/
2158                 /*
2159                 _sceneManager->drawSelectionROI( );
2160                 std::vector<std::string> currentSelection = _sceneManager->getSelectedObjects();
2161                 int ok = currentSelection.size();
2162                 _sceneManager->selectObjects( currentSelection );*/
2163         }
2164         //------------------------------------------------------------------------------------------------------------
2165         void wxContourEventHandler :: onEditOutlines( std::vector<std::string> & keyNamesVector )
2166         {
2167
2168         }
2169         //------------------------------------------------------------------------------------------------------------
2170
2171         //------------------------------------------------------------------------------------------------------------
2172         void wxContourEventHandler :: deleteContour( std::string theKeyName )
2173         {
2174                 manualContourModel                      * cModel;
2175                 manualViewBaseContour           * cViewer;
2176                 manualContourBaseControler      * cControler;
2177
2178                 ContourWrap_ViewControl *conwrapviewControl =  _sceneManager->getContourWrap_ViewControlOf( theKeyName );
2179                 cControler      = conwrapviewControl->getControler();
2180                 int ispartofstaticlst= _modelManager->IsPartOfStaticList(theKeyName);
2181                 if ((cControler!=NULL) && (cControler->IsEditable()==false)  && (ispartofstaticlst==-1) )
2182                 {
2183                         _sceneManager->removeFromScene( theKeyName );
2184                         cModel          = _modelManager->getOutlineByKeyName(theKeyName)->getModel();
2185                         _modelManager->removeOutline( theKeyName );
2186                         cViewer         = conwrapviewControl->getViewer();
2187                         _sceneManager->removeWrap( theKeyName );
2188 //EED Borrame
2189 //FILE *ff = fopen("c:/temp/wxVtkBaseView_SceneManagerStadistics.txt","a+");
2190 //fprintf(ff,"EED wxContourEventHandler::deleteContours() \n" );
2191 //fprintf(ff,"    %s %p\n",keyNamesVector[i].c_str(),  cControler );
2192 //fclose(ff);
2193                         delete cModel;
2194                         delete cViewer;
2195                         delete cControler;
2196                 } // if editable
2197         }
2198
2199         //------------------------------------------------------------------------------------------------------------
2200         void wxContourEventHandler :: deleteContours( std::vector<std::string>  keyNamesVector )
2201         {
2202                 int i,size=keyNamesVector.size();
2203                 for (i=0;i<size;i++)
2204                 {
2205                         deleteContour( keyNamesVector[i] );
2206                 }
2207         }
2208
2209         //------------------------------------------------------------------------------------------------------------
2210         void wxContourEventHandler :: deleteAllContours(  )
2211         {
2212                 wxBusyCursor wait;
2213                 std::vector<int> tempVector;
2214                 _instantPanel->getInstant( tempVector );
2215
2216 //JCP --08-09-2008 When using a diferent interface the _mbarrangeDeleteAll might not be initialize
2217 //              the values in GetStart and GetEnd will then not be initialize also.
2218 //              We use instead the values given when initializing the _deletepanel.
2219
2220                 //int minZ = _mbarrangeDeleteAll->GetStart();
2221                 //int maxZ = _mbarrangeDeleteAll->GetEnd();
2222                 int minZ, maxZ;
2223
2224                 minZ = 0;
2225                 maxZ = _sceneManager->GetImageDataSizeZ();
2226
2227 //JCP --08-09-2008
2228
2229                 _sceneManager->removeSceneContours( );
2230                         _modelManager->removeAllOutlines();
2231                         _sceneManager->removeAllOutlines();
2232 //JCP --08-09-2008
2233                 /*
2234                 if ( (minZ==0) && (maxZ==_mbarrangeDeleteAll->GetMax() ))
2235                 {
2236                         _sceneManager->removeSceneContours( );
2237                         _modelManager->removeAllOutlines();
2238                         _sceneManager->removeAllOutlines();
2239
2240                 } else {
2241                         for ( z=minZ ; z<=maxZ ; z++)
2242                         {
2243                                 tempVector[1]=z;
2244                                 Instant instant(&tempVector);
2245                                 std::vector<ContourThing**> lstContourThings = this->_modelManager->getOutlinesAtInstant( &instant );
2246
2247                                 sizeLstContourThings = lstContourThings.size();
2248                                 for (ii=0 ; ii<sizeLstContourThings ; ii++)
2249                                 {
2250                                         ContourThing **contourthing = lstContourThings[ii];
2251                                         deleteContour( (*contourthing)->getName() );
2252                                 } //for ii
2253                         }// for z
2254                 } // if
2255         JCP --08-09-2008 */
2256         }
2257
2258         //------------------------------------------------------------------------------------------------------------
2259         void wxContourEventHandler::openContours( FILE *pFile, bool staticContour )
2260         {
2261                 char tmp[255];
2262                 fscanf(pFile,"%s",tmp); // NumberOfContours
2263                 fscanf(pFile,"%s",tmp); // ##
2264                 int numberOfContours = atoi(tmp);
2265
2266                 std::vector<int> instantVector;
2267                 int typeContourModel;
2268                 manualContourModel *manModelContour;
2269                 int typeView;
2270
2271                 int i;
2272                 for (i=0;i<numberOfContours;i++)
2273                 {
2274                         instantVector.clear();
2275                         fscanf(pFile,"%s",tmp); // Instant
2276
2277                         fscanf(pFile,"%s",tmp); // 1
2278                         instantVector.push_back( atoi(tmp) );
2279                         fscanf(pFile,"%s",tmp); // 2
2280                         instantVector.push_back( atoi(tmp) );
2281                         fscanf(pFile,"%s",tmp); // 3
2282                         instantVector.push_back( atoi(tmp) );
2283                         fscanf(pFile,"%s",tmp); // 4
2284                         instantVector.push_back( atoi(tmp) );
2285                         fscanf(pFile,"%s",tmp); // 5
2286                         instantVector.push_back( atoi(tmp) );
2287                         fscanf(pFile,"%s",tmp); // 6
2288                         instantVector.push_back( atoi(tmp) );
2289
2290
2291                         fscanf(pFile,"%s",tmp); // TypeContourModel
2292                         fscanf(pFile,"%s",tmp); // ##
2293                         typeContourModel = atoi(tmp);
2294
2295                         manModelContour =  factoryManualContourModel(typeContourModel);
2296                         manModelContour->Open(pFile);
2297
2298                         fscanf(pFile,"%s",tmp); // TypeView
2299                         fscanf(pFile,"%s",tmp); // ##
2300                         typeView = atoi(tmp);
2301
2302
2303 //                      if (typeView==1)
2304 //                      {
2305 //                      }
2306
2307
2308                         std::string theName;
2309                         theName = _modelManager->createOutline( manModelContour, instantVector );
2310                         bool addedModel = theName.compare("") != 0;
2311                         if( addedModel )
2312                         {
2313                                 double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
2314                                 this->_theViewPanel->getSpacing(spc);
2315                                 //Adding the manualContourControler to interface objects structure
2316                                 //Adding the manualViewContour to interface objects structure
2317                                 //_sceneManager->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
2318                                 _sceneManager->configureViewControlTo( theName, manModelContour,spc , typeView) ;
2319                         }
2320
2321                         if (staticContour==true)
2322                         {
2323                                 Instant instant(&instantVector);
2324                                 changeContourOfManager( theName , &instant );
2325                         }
2326
2327                 }// for  numberOfContours
2328
2329
2330
2331         }
2332
2333         //------------------------------------------------------------------------------------------------------------
2334         void wxContourEventHandler::openFileWithContours()
2335         {
2336                 char tmp[255];
2337                 wxFileDialog dialog(NULL, _T("Choose a file"), _T(""), _T(""), _T("*.roi"), wxOPEN );
2338                 if (dialog.ShowModal() == wxID_OK)
2339                 {
2340                         fileNameContourROI = (const char *)(dialog.GetPath().mb_str());
2341                         FILE *pFile=fopen(fileNameContourROI.c_str(),"r+");
2342
2343                         fscanf(pFile,"%s",tmp); // --CreaContour--
2344
2345                         fscanf(pFile,"%s",tmp); // Version
2346                         fscanf(pFile,"%s",tmp); // 1.0.1
2347                         std::string version(tmp);
2348
2349                         openContours(pFile,false);
2350                         if (version!="1.0.0"){
2351                                 openContours(pFile,true);
2352                         }
2353 //                        _sceneManager->openFileWithContours(ff);
2354
2355                         fclose(pFile);
2356                 }
2357                 _sceneManager->removeSceneContours();
2358                 changeInstant();
2359                 //updateInstantOutlines();
2360         }
2361
2362
2363         //------------------------------------------------------------------------------------------------------------
2364         void wxContourEventHandler::saveFileWithContours( std::string filename )
2365         {
2366                 FILE *pFile=fopen(filename.c_str(),"w+");
2367                 std::vector< std::string > lstNameThings;
2368                 int i,sizeLstNameThings;
2369
2370                 fprintf(pFile,"--CreaContour--\n");
2371                 fprintf(pFile,"Version %s\n", "1.0.1" );
2372
2373                 // Normal Contours
2374                 lstNameThings           = _modelManager->GetLstNameThings();
2375                 sizeLstNameThings       = lstNameThings.size();
2376                 fprintf(pFile,"NumberOfContours %d\n", sizeLstNameThings );
2377                 for (i=0 ; i<sizeLstNameThings ; i++)
2378                 {
2379                         _modelManager->SaveThingName( pFile, lstNameThings[i] );
2380                         _sceneManager->SaveThingName( pFile, lstNameThings[i] );
2381                 }// for i
2382
2383                 //-- Contours Statics
2384                 lstNameThings           = _modelManager->GetLstNameThingsStatic();
2385                 sizeLstNameThings       = lstNameThings.size();
2386                 fprintf(pFile,"NumberOfContoursStatic %d\n", sizeLstNameThings );
2387                 for (i=0 ; i<sizeLstNameThings ; i++)
2388                 {
2389                         _modelManager->SaveThingName( pFile, lstNameThings[i] );
2390                         _sceneManager->SaveThingName( pFile, lstNameThings[i] );
2391                 }// for i
2392                 fclose(pFile);
2393         }
2394
2395
2396         //----------------------------------------------------------
2397
2398         void wxContourEventHandler::saveFileWithContours()
2399         {
2400                 wxFileDialog dialog(NULL, _T("Choose a file"), _T(""), _T(""), _T("*.roi"), wxSAVE );
2401                 if (dialog.ShowModal() == wxID_OK)
2402                 {
2403                         fileNameContourROI = (const char *)(dialog.GetPath().mb_str());
2404                         saveFileWithContours( fileNameContourROI );
2405                 } // if  ShowModal
2406         }
2407
2408         //------------------------------------------------------------------------------------------------------------
2409         void wxContourEventHandler :: saveFileWithContoursAutomatique()
2410         {
2411                 if (fileNameContourROI=="")
2412                 {
2413                         saveFileWithContours();
2414                 } else {
2415                         saveFileWithContours(fileNameContourROI);
2416                 }
2417         }
2418
2419
2420         //------------------------------------------------------------------------------------------------------------
2421         void wxContourEventHandler :: createCopyContourOf ( std::string anExistingKName, std::vector<int> &instantNoTouchData, bool append )
2422         {
2423                 std::string cloneName = _modelManager->createCopyContourOf( anExistingKName, instantNoTouchData );
2424                 manualContourModel * manualModel = _modelManager->getOutlineByKeyName( cloneName )->getModel();
2425                 _sceneManager->createCopyContourOf( anExistingKName, cloneName, manualModel , append );
2426         }
2427
2428
2429         //------------------------------------------------------------------------------------------------------------
2430         manualContourModel * wxContourEventHandler::factoryManualContourModel(int typeContour)
2431         {
2432                 manualContourModel *manModelContour=NULL;
2433
2434                 // spline
2435                 if (typeContour==0)
2436                 {
2437                         manModelContour = new manualContourModel();
2438                 }
2439
2440                 // spline
2441                 if (typeContour==1)
2442                 {
2443                         manModelContour = new manualContourModel();
2444                 }
2445
2446                 // rectangle
2447                 if (typeContour==2)
2448                 {
2449                         manModelContour = new manualContourModelRoi();
2450                 }
2451
2452                 // circle
2453                 if (typeContour==3)
2454                 {
2455                         manModelContour = new manualContourModelCircle();
2456                 }
2457
2458                 // BullEye / star
2459                 if (typeContour==4)
2460                 {
2461                         manualContourModelBullEye *manModelContourBullEye = new manualContourModelBullEye();
2462                         manModelContour = manModelContourBullEye;
2463                         if (_panelBullEyeOptions!=NULL){
2464                                 int iCrown,sizeCrowns,iSector,sizeSectors;
2465                                 double radioA,radioB,ang,angDelta ;
2466                                 sizeCrowns = _panelBullEyeOptions->GetNumberOfCrowns();
2467                                 for ( iCrown=0 ; iCrown<sizeCrowns ; iCrown++ )
2468                                 {
2469                                         sizeSectors = _panelBullEyeOptions->GetNumberOfSections(iCrown);
2470                                         radioB  = _panelBullEyeOptions->GetRadioOfCrown(iCrown);
2471                                         if (iCrown==sizeCrowns-1)
2472                                         {
2473                                                 radioA  = 0;
2474                                         } else {
2475                                                 radioA  = _panelBullEyeOptions->GetRadioOfCrown(iCrown+1);
2476                                         }
2477                                         radioA=radioA/100.0;
2478                                         radioB=radioB/100.0;
2479                                         for ( iSector=0 ; iSector<sizeSectors  ; iSector++ )
2480                                         {
2481                                                 ang             = _panelBullEyeOptions->GetAngOfCrownSection(iCrown,iSector);
2482                                                 angDelta= _panelBullEyeOptions->GetAngDeltaOfCrownSection(iCrown);
2483                                                 manModelContourBullEye->AddSector(radioA,radioB,ang,angDelta);
2484                                         } // for iSector
2485                                 } // for iCrown
2486                         } // if _panelBullEyeOptions
2487                 }// if typeContour==4
2488
2489                 return manModelContour;
2490         }
2491
2492         //------------------------------------------------------------------------------------------------------------
2493         void wxContourEventHandler :: createContour( int typeContour )
2494         {
2495                 //Creating the manualContourModel and including in the model
2496                 manualContourModel * manModelContour = factoryManualContourModel(typeContour);
2497                 std::vector<int> instantVector;
2498                 _instantPanel->getInstant( instantVector );
2499                 std::string theName;
2500                 theName= _modelManager->createOutline( manModelContour, instantVector );
2501                 bool addedModel = theName.compare("") != 0;
2502                 if( addedModel )
2503                 {
2504                         double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
2505                         this->_theViewPanel->getSpacing(spc);
2506                         //Adding the manualContourControler to interface objects structure
2507                         //Adding the manualViewContour to interface objects structure
2508                         //_sceneManager->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
2509                         _sceneManager->configureViewControlTo( theName, manModelContour,spc , typeContour) ;
2510                 }
2511
2512 //EED Borrame
2513 //FILE *ff = fopen("c:/temp/wxVtkBaseView_SceneManagerStadistics.txt","a+");
2514 //fprintf(ff,"EED wxContourEventHandler::createContour() \n" );
2515 //fprintf(ff,"    %s\n %p ",theName.c_str() ,  );
2516 //fclose(ff);
2517
2518
2519         }
2520         manualContourModel * wxContourEventHandler::factoryManualContourModel(PanelBullEyeOptions* panel){
2521
2522                 manualContourModelBullEye *manModelContourBullEye = new manualContourModelBullEye();
2523                 manualContourModel *manModelContour=NULL;
2524                 manModelContour = manModelContourBullEye;
2525                 if (panel!=NULL){
2526                         int iCrown,sizeCrowns,iSector,sizeSectors;
2527                         double radioA,radioB,ang,angDelta ;
2528                         sizeCrowns = panel->GetNumberOfCrowns();
2529                         for ( iCrown=0 ; iCrown<sizeCrowns ; iCrown++ )
2530                         {
2531                                 sizeSectors = panel->GetNumberOfSections(iCrown);
2532                                 radioB  = panel->GetRadioOfCrown(iCrown);
2533                                 if (iCrown==sizeCrowns-1)
2534                                 {
2535                                         radioA  = 0;
2536                                 } else {
2537                                         radioA  = panel->GetRadioOfCrown(iCrown+1);
2538                                 }
2539                                 radioA=radioA/100.0;
2540                                 radioB=radioB/100.0;
2541                                 for ( iSector=0 ; iSector<sizeSectors  ; iSector++ )
2542                                 {
2543                                         ang             = panel->GetAngOfCrownSection(iCrown,iSector);
2544                                         angDelta= panel->GetAngDeltaOfCrownSection(iCrown);
2545                                         manModelContourBullEye->AddSector(radioA,radioB,ang,angDelta);
2546                                 } // for iSector
2547                         } // for iCrown
2548                 } // if _panelBullEyeOptions
2549
2550                 return manModelContour;
2551         }
2552
2553         void wxContourEventHandler :: createContourBullsEye(PanelBullEyeOptions* panel )
2554         {
2555                 //Creating the manualContourModel and including in the model
2556                 manualContourModel * manModelContour = factoryManualContourModel(panel );
2557                 std::vector<int> instantVector;
2558                 _instantPanel->getInstant( instantVector );
2559                 std::string theName;
2560                 theName= _modelManager->createOutline( manModelContour, instantVector );
2561                 bool addedModel = theName.compare("") != 0;
2562                 if( addedModel )
2563                 {
2564                         double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
2565                         this->_theViewPanel->getSpacing(spc);
2566                         //Adding the manualContourControler to interface objects structure
2567                         //Adding the manualViewContour to interface objects structure
2568                         //_sceneManager->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
2569                         _sceneManager->configureViewControlTo( theName, manModelContour,spc , 4) ;
2570                 }
2571
2572 //EED Borrame
2573 //FILE *ff = fopen("c:/temp/wxVtkBaseView_SceneManagerStadistics.txt","a+");
2574 //fprintf(ff,"EED wxContourEventHandler::createContour() \n" );
2575 //fprintf(ff,"    %s\n %p ",theName.c_str() ,  );
2576 //fclose(ff);
2577
2578
2579         }
2580
2581         //------------------------------------------------------------------------------------------------------------
2582         //  Attributes getters and setters
2583         //------------------------------------------------------------------------------------------------------------
2584
2585         void wxContourEventHandler :: setModelManager( OutlineModelManager * theModelManager )
2586         {
2587                 _modelManager = theModelManager;
2588                 _workSpace = _modelManager->getContourWorkspace();
2589         }
2590         //------------------------------------------------------------------------------------------------------------
2591         void wxContourEventHandler :: setViewPanel(  wxContourViewPanel * theViewPanel )
2592         {
2593                 _theViewPanel = theViewPanel;
2594                 _theViewPanel->setWxEventHandler( this );
2595
2596                 double spc[3];
2597                 this->_theViewPanel->getSpacing(spc);
2598                 _sceneManager           = new wxVtkBaseView_SceneManager ( this->_theViewPanel->getWxVtkBaseView(), this, spc  );
2599
2600                 Connect( _theViewPanel->GetId(), wxINSTANT_CHANGE, (wxObjectEventFunction) (wxCommandEventFunction)  &wxContourEventHandler::onChangeInstant );
2601         Connect( wxID_ANY, wxEVT_START_CREATE_MULT_ROI, (wxObjectEventFunction) (wxCommandEventFunction)  &wxContourEventHandler::onCreateMultipleROI );
2602                 Connect( wxID_ANY, wxEVT_START_CREATE_ROI, (wxObjectEventFunction) (wxCommandEventFunction)  &wxContourEventHandler::onCreateROI );
2603                 Connect( wxID_ANY, wxEVT_STOP_CREATE_ROI, (wxObjectEventFunction) (wxCommandEventFunction)  &wxContourEventHandler::onStopCreateROI );
2604                 Connect( wxID_ANY, wxEVT_CHANGED_DEEP, (wxObjectEventFunction) (wxCommandEventFunction)  &wxContourEventHandler::onChangedDeep );
2605                 Connect( wxID_ANY,  wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler :: onActionButtonPressed );
2606
2607
2608         }
2609
2610         //------------------------------------------------------------------------------------------------------------
2611         void wxContourEventHandler :: setInstantChooserPanel(  wxInstantChooserPanel * theInstantChooserPanel )
2612         {
2613                 _instantPanel = theInstantChooserPanel;
2614                 _instantPanel->setWxEventHandler( this );
2615
2616                 Connect( _instantPanel->GetId(), wxINSTANT_CHOOSER_CHANGE, (wxObjectEventFunction) (wxCommandEventFunction)  &wxContourEventHandler::onChangeInstant );
2617
2618                 std::vector<int> vect;
2619                 _instantPanel->getInstant( vect );
2620                 _actualInstant = new Instant( &vect );
2621
2622                 if( _modelManager!=NULL )
2623                 {
2624                         std::vector<std::string> conceptNameVect;
2625                         std::vector<int> conceptSizeVect;
2626                         _modelManager-> getConceptsInformation(conceptNameVect, conceptSizeVect);
2627                         int i=0;
2628                         int max = conceptNameVect.size();
2629                         for( ; i<max; i++)
2630                         {
2631                                 if( conceptNameVect[i].compare("Axe Depth") == 0 )
2632                                 {
2633                                         _instantPanel->addConcept( conceptNameVect[i], 0, conceptSizeVect[i], 1);
2634                                 } else {
2635                                         _instantPanel->addConcept( conceptNameVect[i], 1, conceptSizeVect[i], 1);
2636                                 } // if
2637                         } // for
2638                 } else {
2639                         //Should be configured later, or abort program, because Model -NEEDS- to be added before chooserPanel
2640                 }
2641                 if( _theViewPanel!=NULL )
2642                 {
2643                         double val = _theViewPanel->getCurrentDeep();
2644                         _instantPanel->setConceptValue( "Axe Depth", (int)val );
2645                         ConceptDataWrap * data = _instantPanel->getConceptDataOf( "Axe Depth" );
2646                         changeInstant();
2647                         _theViewPanel->setVerticalConcept( "Axe Depth", data->getMinValue(), data->getMaxValue(), data->getMinShowedValue(),  data->getMaxShowedValue(), data->getActualValue() );
2648                 } else {
2649                         //Should be configured later, or abort program, because ViewPanel -NEEDS- to be added before chooserPanel
2650                 }// if
2651         }
2652
2653
2654         //------------------------------------------------------------------------------------------------------------
2655         void wxContourEventHandler :: setButtonsBar(  wxContour_ButtonsBar * theButtonsBar )
2656         {
2657                 _buttonsBar = theButtonsBar;
2658                 _buttonsBar->setWxEventHandler( this );
2659                 Connect( _buttonsBar->GetId(),   wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler:: onActionButtonPressed );
2660         }
2661         //------------------------------------------------------------------------------------------------------------
2662         void wxContourEventHandler :: setGrid(  wxContour_Grid * theGridPanel )
2663         {
2664                 _gridPanel = theGridPanel;
2665         }
2666         //------------------------------------------------------------------------------------------------------------
2667         void wxContourEventHandler :: setDrawToolsPanel(  wxContour_DrawToolsPanel * theDrawToolsPanel )
2668         {
2669                 _drawToolsPanel = theDrawToolsPanel;
2670         }
2671         //------------------------------------------------------------------------------------------------------------
2672         void wxContourEventHandler :: setOperationsToolsPanel(  wxContour_OperationsToolsPanel * theOperationsToolsPanel )
2673         {
2674                 _operationsToolsPanel = theOperationsToolsPanel;
2675         }
2676         //------------------------------------------------------------------------------------------------------------
2677         void wxContourEventHandler :: setAutomaticFormsPanel(  wxContour_AutomaticFormsToolsPanel * theAutoFormsPanel )
2678         {
2679                 _autoFormsPanel = theAutoFormsPanel;
2680         }
2681
2682         void wxContourEventHandler :: setStandardToolsPanel(  wxContour_StandardToolsPanel * theStandardToolsPanel )
2683         {
2684                 _standardToolsPanel= theStandardToolsPanel;
2685         }
2686         //------------------------------------------------------------------------------------------------------------
2687         void wxContourEventHandler :: setEditionToolsPanel(  wxContour_EdtionToolsPanel * theEditionToolsPanel )
2688         {
2689                 _editionToolsPanel =  theEditionToolsPanel;
2690         }
2691
2692         //------------------------------------------------------------------------------------------------------------
2693         void wxContourEventHandler :: setListViewPanel(  wxContour_ListViewPanel * theListViewPanel )
2694         {
2695                 _listViewPanel = theListViewPanel;
2696         }
2697         //------------------------------------------------------------------------------------------------------------
2698         //  Other functional methods
2699         //------------------------------------------------------------------------------------------------------------
2700
2701
2702         //------------------------------------------------------------------------------------------------------------
2703         void wxContourEventHandler::onDeleteContour( wxCommandEvent& event )
2704         {
2705
2706                 //JCP 20-10-08 Undo redo implementation
2707                 saveState();
2708                 //JCP 20-10-08 Undo redo implementation
2709
2710
2711                 int i,size=_sceneManager->getSelectedObjects().size();
2712                 for(i=0;i<size;i++)
2713                 {
2714                         std::string keyName             = _sceneManager->getSelectedObjects()[i];
2715                         int ispartofstaticlist  = this->_modelManager->IsPartOfStaticList( keyName );
2716                         if ( ispartofstaticlist>=0 )
2717                         {
2718                                 std::vector<int> tempVector;
2719                                 _instantPanel->getInstant( tempVector );
2720                                 Instant instant(&tempVector);
2721                                 this->_modelManager->ChangeContourOfList(keyName, &instant);
2722                         }
2723                 }
2724
2725                 std::vector<std::string> lstKeyName;
2726                 std::vector<std::string> lstKeyNameActualSlice;
2727                 std::vector<std::string> lstKeyNameToBeErase;
2728
2729                 lstKeyNameToBeErase             = _sceneManager->getSelectedObjects();
2730                 lstKeyNameActualSlice   = _sceneManager->GetlstContoursNameActualSlice();
2731                 int k,kSize=lstKeyNameToBeErase.size();
2732                 int j,jSize=lstKeyNameActualSlice.size();
2733                 bool ok;
2734                 for (k=0;k<kSize; k++)
2735                 {
2736                         ok=false;
2737                         for (j=0;j<jSize; j++)
2738                         {
2739                                 if (lstKeyNameToBeErase[k]==lstKeyNameActualSlice[j])
2740                                 {
2741                                         ok=true;
2742                                 }
2743                         } // for j
2744                         if (ok==true)
2745                         {
2746                                 lstKeyName.push_back( lstKeyNameToBeErase[k] );
2747                         } // if ok
2748                 } // for k
2749
2750                 deleteContours( lstKeyName );
2751
2752
2753         }
2754
2755         //------------------------------------------------------------------------------------------------------------
2756         void wxContourEventHandler::onDeleteContoursActSlice( wxCommandEvent& event )
2757         {
2758                 //JCP 20-10-08 Undo redo implementation
2759                 saveState();
2760                 //JCP 20-10-08 Undo redo implementation
2761                 deleteContours( (std::vector<std::string>)_sceneManager->GetlstContoursNameActualSlice() );
2762
2763
2764         }
2765
2766         //------------------------------------------------------------------------------------------------------------
2767         void wxContourEventHandler::onDeleteAllContours( wxCommandEvent& event )
2768         {
2769                 //JCP 20-10-08 Undo redo implementation
2770                 saveState();
2771                 //JCP 20-10-08 Undo redo implementation
2772                 deleteAllContours(  );
2773
2774
2775         }
2776
2777                 //------------------------------------------------------------------------------------------------------------
2778         void wxContourEventHandler :: onDeleteFrame( )
2779         {
2780                 if (_deleteFrame==NULL)
2781                 {
2782                         _deleteFrame                                            = new wxFrame (_theViewPanel, -1,_T("  Delete Contour "), wxDefaultPosition, wxDefaultSize, wxFRAME_TOOL_WINDOW|wxSYSTEM_MENU | wxCAPTION |  wxCLIP_CHILDREN |wxFRAME_FLOAT_ON_PARENT );
2783                         int width=300;
2784                         wxSize sizepanel(width,230);
2785                         _deleteFrame->SetSize( sizepanel );
2786                         wxPanel *panel                                          = new wxPanel(_deleteFrame,-1);
2787                         wxButton *deleteContourBtn                      = new wxButton(panel,-1,_T("Delete contour selected"),wxDefaultPosition, wxSize(width-10,35) );
2788                         wxButton *deleteContoursActSliceBtn     = new wxButton(panel,-1,_T("Delete contours of actual slice"),wxDefaultPosition, wxSize(width-10,35));
2789                         wxButton *deleteAllContoursBtn          = new wxButton(panel,-1,_T("Delete all contours"),wxDefaultPosition, wxSize(width-10,35));
2790
2791                         int sizeZ = _sceneManager->GetImageDataSizeZ();
2792                         _mbarrangeDeleteAll                                     =  new mBarRange(panel,70, 65);
2793                         _mbarrangeDeleteAll->SetMin(0);
2794                         _mbarrangeDeleteAll->SetStart(0);
2795
2796                         _mbarrangeDeleteAll-> SetOrientation( true );
2797                         _mbarrangeDeleteAll-> setActiveStateTo(true);
2798                         _mbarrangeDeleteAll-> setVisibleLabels( true );
2799                         _mbarrangeDeleteAll-> setDeviceEndMargin(10);
2800                         _mbarrangeDeleteAll-> setRepresentedValues( 0 , sizeZ );
2801                         _mbarrangeDeleteAll-> setDeviceBlitStart(10,10);
2802                         _mbarrangeDeleteAll-> setIfWithActualDrawed( false );
2803                         _mbarrangeDeleteAll-> SetStart( 0 );
2804                         _mbarrangeDeleteAll-> SetEnd( sizeZ );
2805
2806
2807                         _deleteFrame->SetEventHandler( this );
2808                         Connect( deleteContourBtn->GetId()                      ,       wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onDeleteContour );
2809                         Connect( deleteContoursActSliceBtn->GetId()     ,       wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onDeleteContoursActSlice );
2810                         Connect( deleteAllContoursBtn->GetId()          ,       wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onDeleteAllContours );
2811
2812                         wxFlexGridSizer * sizer                         = new wxFlexGridSizer(1);
2813                         sizer -> Add( deleteContourBtn                          , 1, wxGROW );
2814                         sizer -> Add( deleteContoursActSliceBtn         , 1, wxGROW );
2815                         sizer -> Add( deleteAllContoursBtn                      , 1, wxGROW );
2816                         sizer -> Add( _mbarrangeDeleteAll                       , 1, wxGROW );
2817
2818                         panel->SetSizer( sizer );
2819                         panel->SetSize( sizepanel );
2820                         panel->SetAutoLayout( true );
2821                         panel->Layout();
2822                         _deleteFrame->Show(true);
2823                 } else {
2824                         if (_deleteFrame->IsShown()==true)
2825                         {
2826                                 _deleteFrame->Show(false);
2827                         } else  {
2828                                 _deleteFrame->Show(true);
2829                         }
2830                 }
2831         }
2832
2833
2834 //------------------------------------------------------------------------------------------------------------
2835 void wxContourEventHandler::onCreateContourSpline( wxCommandEvent& event )
2836 {
2837
2838         //JCP 20-10-08 Undo redo implementation
2839         saveState();
2840         //JCP 20-10-08 Undo redo implementation
2841         createContour( 1 );
2842
2843
2844
2845 }
2846
2847 //------------------------------------------------------------------------------------------------------------
2848 void wxContourEventHandler::onCreateContourRectangle( wxCommandEvent& event )
2849 {
2850
2851         //JCP 20-10-08 Undo redo implementation
2852         saveState();
2853         //JCP 20-10-08 Undo redo implementation
2854         createContour( 2 );
2855
2856
2857 }
2858
2859 //------------------------------------------------------------------------------------------------------------
2860 void wxContourEventHandler::onCreateContourCircle( wxCommandEvent& event )
2861 {
2862         //JCP 20-10-08 Undo redo implementation
2863         saveState();
2864         //JCP 20-10-08 Undo redo implementation
2865         createContour( 3 );
2866
2867
2868 }
2869 //------------------------------------------------------------------------------------------------------------
2870 void wxContourEventHandler::onCreateContourBullEye( wxCommandEvent& event )
2871 {
2872         //JCP 20-10-08 Undo redo implementation
2873         saveState();
2874         //JCP 20-10-08 Undo redo implementation
2875         createContour( 4 );
2876
2877
2878
2879 }
2880
2881
2882
2883 //------------------------------------------------------------------------------------------------------------
2884         void wxContourEventHandler :: onCreateContourFrame( )
2885         {
2886                 if (_createContourFrame==NULL)
2887                 {
2888                         _createContourFrame                                             = new wxFrame (_theViewPanel, -1,_T("  New Contour  "), wxDefaultPosition, wxDefaultSize, wxFRAME_TOOL_WINDOW|wxSYSTEM_MENU | wxCAPTION |  wxCLIP_CHILDREN |wxFRAME_FLOAT_ON_PARENT | wxRESIZE_BORDER );
2889                         wxSize sizepanel(490,600);
2890                         _createContourFrame->SetSize( sizepanel );
2891                         wxPanel *panel                                          = new wxPanel(_createContourFrame,-1);
2892                         wxButton *newContourSplineBtn           = new wxButton(panel,-1,_T("Interpolation B-spline (close)"),wxDefaultPosition, wxSize(180,35) );
2893                         newContourSplineBtn->SetToolTip(_T("CTRL-N"));
2894                         wxButton *newContourRectangleBtn        = new wxButton(panel,-1,_T("Rectangle"),wxDefaultPosition, wxSize(180,35));
2895                         wxButton *newContourCircleBtn           = new wxButton(panel,-1,_T("Circle"),wxDefaultPosition, wxSize(180,35));
2896                         wxButton *newContourStarBtn                     = new wxButton(panel,-1,_T("Bull eye"),wxDefaultPosition, wxSize(180,35));
2897
2898                         _panelBullEyeOptions = new PanelBullEyeOptions(panel, wxSize(100,200));
2899
2900                         _createContourFrame->SetEventHandler( this );
2901                         Connect( newContourSplineBtn->GetId()           ,       wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onCreateContourSpline    );
2902                         Connect( newContourRectangleBtn->GetId()        ,       wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onCreateContourRectangle );
2903                         Connect( newContourCircleBtn->GetId()           ,       wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onCreateContourCircle    );
2904                         Connect( newContourStarBtn->GetId()                     ,       wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onCreateContourBullEye   );
2905
2906                         wxFlexGridSizer * sizer                         = new wxFlexGridSizer(1);
2907                         sizer -> Add( newContourSplineBtn                       , 1, wxGROW );
2908                         sizer -> Add( newContourRectangleBtn            , 1, wxGROW );
2909                         sizer -> Add( newContourCircleBtn                       , 1, wxGROW );
2910                         sizer -> Add( newContourStarBtn                         , 1, wxGROW );
2911                         sizer -> Add( _panelBullEyeOptions                      , 1, wxGROW );
2912
2913                         panel->SetSizer( sizer );
2914                         panel->SetSize( sizepanel );
2915                         panel->SetAutoLayout( true );
2916                         panel->Layout();
2917                         _createContourFrame->Show(true);
2918                 } else {
2919                         if (_createContourFrame->IsShown()==true)
2920                         {
2921                                 _createContourFrame->Show(false);
2922                         } else  {
2923                                 _createContourFrame->Show(true);
2924                         }
2925                 }
2926         }
2927
2928
2929 //------------------------------------------------------------------------
2930 void wxContourEventHandler::RefreshInterface()
2931 {
2932         changeInstant();
2933         wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)this->_theViewPanel->getWxVtkBaseView();
2934         wxvtk2dbaseview->Refresh();
2935 }
2936
2937 //------------------------------------------------------------------------
2938 void wxContourEventHandler::onWidthOfContour(wxScrollEvent& event){
2939         _sceneManager->removeSceneContours();
2940         double width = (double)_withOfContourLine->GetValue() / 2.0;
2941         _sceneManager->SetWidthContour( width );
2942
2943         RefreshInterface();
2944 }
2945
2946 //------------------------------------------------------------------------
2947
2948 void wxContourEventHandler::onBrigthnessColorWindowLevel(wxScrollEvent& event){
2949         int colorwindow                         = _brithtnessColorLevel->GetValue();
2950         int windowlevel                         = _brithtnessWindowLevel->GetValue();
2951         wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)this->_theViewPanel->getWxVtkBaseView();
2952         vtkImageViewer2 *imageviewer = wxvtk2dbaseview->_imageViewer2XYZ->GetVtkImageViewer2();
2953         imageviewer->SetColorWindow(colorwindow);
2954         imageviewer->SetColorLevel(windowlevel);
2955 //      wxvtk2dbaseview->Refresh();
2956         RefreshInterface();
2957 }
2958
2959 void wxContourEventHandler::OnInterpolation(wxCommandEvent& event)
2960 {
2961         wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)this->_theViewPanel->getWxVtkBaseView();
2962         vtkImageViewer2 *imageviewer = wxvtk2dbaseview->_imageViewer2XYZ->GetVtkImageViewer2();
2963         if (_interpolationCheckBox->GetValue()==true)
2964         {
2965                 imageviewer->GetImageActor()->InterpolateOn();
2966         } else {
2967                 imageviewer->GetImageActor()->InterpolateOff();
2968         }
2969         RefreshInterface();
2970 }
2971
2972
2973 //------------------------------------------------------------------------------------------------------------
2974         void wxContourEventHandler :: onInterfaceConfigurationFrame( )
2975         {
2976                 if (_interfaceConfigurationFrame==NULL)
2977                 {
2978                         _interfaceConfigurationFrame                    = new wxFrame (_theViewPanel, -1,_T(" Interface Configuration "), wxDefaultPosition, wxDefaultSize, wxFRAME_TOOL_WINDOW|wxSYSTEM_MENU | wxCAPTION |  wxCLIP_CHILDREN |wxFRAME_FLOAT_ON_PARENT );
2979                         wxSize sizepanel(190,400);
2980                         _interfaceConfigurationFrame->SetSize( sizepanel );
2981                         _interfaceConfigurationFrame->SetEventHandler( this );
2982                         wxPanel* panel = getConfigurationPanel(_interfaceConfigurationFrame);
2983                         panel->SetSize(sizepanel);
2984                         _interfaceConfigurationFrame->Show(true);
2985                 } else {
2986                         if (_interfaceConfigurationFrame->IsShown()==true)
2987                         {
2988                                 _interfaceConfigurationFrame->Show(false);
2989                         } else  {
2990                                 _interfaceConfigurationFrame->Show(true);
2991                         }
2992                 }
2993         }
2994
2995
2996         //**JCP 13-10-08
2997
2998         wxPanel* wxContourEventHandler :: getConfigurationPanel(wxWindow* parent){
2999
3000                 /*wxPanel *panel                                                        = new wxPanel(parent,-1);
3001                 _withOfContourLine                                              = new wxSlider(panel, -1, 1 , 1, 10, wxDefaultPosition, wxSize(180,40), wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
3002
3003                 double range[2];
3004                 this->_sceneManager->GetImageDataRange(range);
3005
3006                 wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)this->_theViewPanel->getWxVtkBaseView();
3007                 vtkImageViewer2 *imageviewer = wxvtk2dbaseview->_imageViewer2XYZ->GetVtkImageViewer2();
3008                 int colorwindow = (int)imageviewer->GetWindowLevel()->GetLevel();
3009                 int windowlevel = (int)imageviewer->GetWindowLevel()->GetWindow();
3010
3011                 _brithtnessWindowLevel                                  = new wxSlider(panel, -1, windowlevel , 1, range[1], wxDefaultPosition, wxSize(180,40), wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
3012                 _brithtnessColorLevel                                   = new wxSlider(panel, -1, colorwindow , 1, range[1], wxDefaultPosition, wxSize(180,40), wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
3013
3014                 _interpolationCheckBox = new wxCheckBox(panel, -1, _T("Image interpolation") );
3015                 _interpolationCheckBox->SetValue(true);
3016
3017                 _interfaceConfigurationFrame->SetEventHandler( this );
3018
3019                 Connect( _withOfContourLine->GetId()            ,       wxEVT_SCROLL_CHANGED    , (wxObjectEventFunction) &wxContourEventHandler::onWidthOfContour      );
3020                 Connect( _withOfContourLine->GetId()            ,       wxEVT_SCROLL_THUMBTRACK , (wxObjectEventFunction) &wxContourEventHandler::onWidthOfContour      );
3021
3022                 Connect( _brithtnessWindowLevel->GetId()        ,       wxEVT_SCROLL_CHANGED    , (wxObjectEventFunction) &wxContourEventHandler::onBrigthnessColorWindowLevel  );
3023                 Connect( _brithtnessWindowLevel->GetId()        ,       wxEVT_SCROLL_THUMBTRACK , (wxObjectEventFunction) &wxContourEventHandler::onBrigthnessColorWindowLevel  );
3024                 Connect( _brithtnessColorLevel->GetId()         ,       wxEVT_SCROLL_CHANGED    , (wxObjectEventFunction) &wxContourEventHandler::onBrigthnessColorWindowLevel  );
3025                 Connect( _brithtnessColorLevel->GetId()         ,       wxEVT_SCROLL_THUMBTRACK , (wxObjectEventFunction) &wxContourEventHandler::onBrigthnessColorWindowLevel  );
3026                 Connect( _interpolationCheckBox->GetId()        ,       wxEVT_COMMAND_CHECKBOX_CLICKED    , (wxObjectEventFunction) &wxContourEventHandler::OnInterpolation             );
3027
3028                 wxFlexGridSizer * sizer                                 = new wxFlexGridSizer(1);
3029                 sizer -> Add( new wxStaticText(panel,-1,_T("Contour width"))  , 1, wxGROW );
3030                 sizer -> Add( _withOfContourLine                , 1, wxGROW );
3031                 sizer -> Add( new wxStaticText(panel,-1,_T(" "))  , 1, wxGROW );
3032                 sizer -> Add( new wxStaticText(panel,-1,_T(" "))  , 1, wxGROW );
3033                 sizer -> Add( new wxStaticText(panel,-1,_T("Brightness of the image"))  , 1, wxGROW );
3034                 sizer -> Add( new wxStaticText(panel,-1,_T("--Window level--"))  , 1, wxGROW );
3035                 sizer -> Add( _brithtnessWindowLevel            , 1, wxGROW );
3036                 sizer -> Add( new wxStaticText(panel,-1,_T("--Color level--"))  , 1, wxGROW );
3037                 sizer -> Add( _brithtnessColorLevel, 1, wxGROW );
3038                 sizer -> Add( new wxStaticText(panel,-1,_T(" "))  , 1, wxGROW );
3039                 sizer -> Add( new wxStaticText(panel,-1,_T(" "))  , 1, wxGROW );
3040                 sizer -> Add( _interpolationCheckBox            , 1, wxGROW );
3041
3042                 panel->SetSizer( sizer );
3043                 //JCP 13-10-08
3044                 //panel->SetSize( sizepanel );
3045                 //13-10-08
3046                 panel->SetAutoLayout( true );
3047                 panel->Layout();
3048
3049                 return panel;*/
3050
3051                 wxPanel *panel                                                  = new wxPanel(parent,-1,wxDefaultPosition, wxDefaultSize,wxNO_BORDER, wxString(_T("")));
3052                 _withOfContourLine                                              = new wxSlider(panel, -1, 1 , 1, 10, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
3053
3054                 double range[2];
3055                 this->_sceneManager->GetImageDataRange(range);
3056
3057                 wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)this->_theViewPanel->getWxVtkBaseView();
3058                 vtkImageViewer2 *imageviewer = wxvtk2dbaseview->_imageViewer2XYZ->GetVtkImageViewer2();
3059                 int colorwindow = (int)imageviewer->GetWindowLevel()->GetLevel();
3060                 int windowlevel = (int)imageviewer->GetWindowLevel()->GetWindow();
3061
3062                 _brithtnessWindowLevel                                  = new wxSlider(panel, -1, windowlevel , 1, range[1], wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
3063                 _brithtnessColorLevel                                   = new wxSlider(panel, -1, colorwindow , 1, range[1], wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
3064
3065                 _interpolationCheckBox = new wxCheckBox(panel, -1, _T("Image interpolation") );
3066                 _interpolationCheckBox->SetValue(true);
3067
3068                 Connect( _withOfContourLine->GetId()            ,       wxEVT_SCROLL_CHANGED    , (wxObjectEventFunction) &wxContourEventHandler::onWidthOfContour      );
3069                 Connect( _withOfContourLine->GetId()            ,       wxEVT_SCROLL_THUMBTRACK , (wxObjectEventFunction) &wxContourEventHandler::onWidthOfContour      );
3070
3071                 Connect( _brithtnessWindowLevel->GetId()        ,       wxEVT_SCROLL_CHANGED    , (wxObjectEventFunction) &wxContourEventHandler::onBrigthnessColorWindowLevel  );
3072                 Connect( _brithtnessWindowLevel->GetId()        ,       wxEVT_SCROLL_THUMBTRACK , (wxObjectEventFunction) &wxContourEventHandler::onBrigthnessColorWindowLevel  );
3073                 Connect( _brithtnessColorLevel->GetId()         ,       wxEVT_SCROLL_CHANGED    , (wxObjectEventFunction) &wxContourEventHandler::onBrigthnessColorWindowLevel  );
3074                 Connect( _brithtnessColorLevel->GetId()         ,       wxEVT_SCROLL_THUMBTRACK , (wxObjectEventFunction) &wxContourEventHandler::onBrigthnessColorWindowLevel  );
3075                 Connect( _interpolationCheckBox->GetId()        ,       wxEVT_COMMAND_CHECKBOX_CLICKED    , (wxObjectEventFunction) &wxContourEventHandler::OnInterpolation             );
3076
3077                 wxFlexGridSizer * sizer                                 = new wxFlexGridSizer(1);
3078                 sizer -> Add( new wxStaticText(panel,-1,_T("Contour width"))  , 1, wxGROW );
3079                 sizer -> Add( _withOfContourLine                , 1, wxGROW );
3080                 sizer -> Add( new wxStaticText(panel,-1,_T(" "))  , 1, wxGROW );
3081                 sizer -> Add( new wxStaticText(panel,-1,_T(" "))  , 1, wxGROW );
3082                 sizer -> Add( new wxStaticText(panel,-1,_T("Brightness of the image"))  , 1, wxGROW );
3083                 sizer -> Add( new wxStaticText(panel,-1,_T("--Window level--"))  , 1, wxGROW );
3084                 sizer -> Add( _brithtnessWindowLevel            , 1, wxGROW );
3085                 sizer -> Add( new wxStaticText(panel,-1,_T("--Color level--"))  , 1, wxGROW );
3086                 sizer -> Add( _brithtnessColorLevel, 1, wxGROW );
3087                 sizer -> Add( new wxStaticText(panel,-1,_T(" "))  , 1, wxGROW );
3088                 sizer -> Add( new wxStaticText(panel,-1,_T(" "))  , 1, wxGROW );
3089                 sizer -> Add( _interpolationCheckBox            , 1, wxGROW );
3090
3091                 panel->SetSizer( sizer );
3092                 //JCP 13-10-08
3093                 //panel->SetSize( sizepanel );
3094                 //13-10-08
3095                 panel->SetAutoLayout( true );
3096                 panel->Layout();
3097
3098                 return panel;
3099         }
3100
3101 //**JCP 13-10-08
3102
3103
3104
3105 //------------------------------------------------------------------
3106         void wxContourEventHandler :: changeContourOfManager(std::string keyName, Instant *instant)
3107         {
3108                 this->_modelManager->ChangeContourOfList(keyName, instant);
3109         }
3110
3111 //------------------------------------------------------------------
3112         void wxContourEventHandler :: changeContoursOfManager(  std::vector<std::string> & keyNamesVector  )
3113         {
3114
3115                 //JCP 20-10-08 Undo redo implementation
3116                 saveState();
3117                 //JCP 20-10-08 Undo redo implementation
3118
3119                 std::vector<int> tempVector;
3120                 _instantPanel->getInstant( tempVector );
3121                 Instant instant(&tempVector);
3122
3123                 int i , size=keyNamesVector.size();
3124                 for ( i=0 ; i<size ; i++ )
3125                 {
3126                         changeContourOfManager(keyNamesVector[i], &instant);
3127                 } // i
3128
3129
3130         }
3131
3132
3133 //------------------------------------------------------------------
3134         void wxContourEventHandler :: executeActionCommand( const char  toolCommand )
3135         {
3136                 std::vector<std::string> currentSelection = _sceneManager->getSelectedObjects();
3137                 int elementsSelected = currentSelection.size();
3138                 if( toolCommand == (wxContour_ActionCommandsID::CREATE_TOOL) )
3139                 {
3140                         onCreateContourFrame();
3141                 }
3142                 if( toolCommand == (wxContour_ActionCommandsID::CREATE_CONTOUR_KEY) )
3143                 {
3144                         createContour();
3145                 }
3146                 else if( toolCommand == wxContour_ActionCommandsID::DELETE_TOOL )
3147                 {
3148                         onDeleteFrame( );
3149                 }
3150                 else if( toolCommand == wxContour_ActionCommandsID::DELETE_KEY )
3151                 {
3152                         deleteContours( currentSelection );
3153                 }
3154                 else if( toolCommand == wxContour_ActionCommandsID::SAVE_TOOL )
3155                 {
3156                         saveFileWithContours(  );
3157                 }
3158                 else if( toolCommand == wxContour_ActionCommandsID::SAVE_KEY )
3159                 {
3160                         saveFileWithContoursAutomatique(  );
3161                 }
3162                 else if( toolCommand == wxContour_ActionCommandsID::OPEN_TOOL )
3163                 {
3164                         openFileWithContours(  );
3165                 }
3166                 else if( toolCommand == wxContour_ActionCommandsID::CHANGE_TOOL )
3167                 {
3168                         if ( elementsSelected >= 1 )
3169                         {
3170                                 changeContoursOfManager( currentSelection );
3171                         }
3172
3173                 }
3174                 else if( toolCommand == wxContour_ActionCommandsID::HIDE_TOOL )
3175                 {
3176                         if ( elementsSelected >= 1 )
3177                         {
3178                                 onHideOutlines( currentSelection );
3179                         }
3180                 }
3181                 else if( toolCommand == wxContour_ActionCommandsID::SHOW_TOOL )
3182                 {
3183                         if ( elementsSelected >= 1 )
3184                         {
3185                                 onShowOutlines( currentSelection );
3186                         }
3187                 }
3188                 else if( toolCommand == wxContour_ActionCommandsID::COPY_TOOL )
3189                 {
3190                         if ( elementsSelected >= 1 )
3191                         {
3192                                 onCopyOutlines( currentSelection );
3193                         }
3194                 }
3195                 else if( toolCommand == wxContour_ActionCommandsID::PASTE_TOOL )
3196                 {
3197                         onPasteOutlines(  );
3198                 }
3199                 else if( toolCommand == wxContour_ActionCommandsID::SPREAD_TOOL )
3200                 {
3201                                 onSpread();
3202                 }
3203                 else if( toolCommand == wxContour_ActionCommandsID::AUTOMATIQUESEGMENTATION_TOOL )
3204                 {
3205                         onAutomatiqueSegmentation(  );
3206                 }
3207
3208                 else if( toolCommand == wxContour_ActionCommandsID::SELECT_TOOL )
3209                 {
3210                         onSelectOutlines( currentSelection );
3211
3212                 }
3213                 else if( toolCommand == wxContour_ActionCommandsID::EDIT_TOOL )
3214                 {
3215                         if ( elementsSelected >= 1 )
3216                         {
3217                                 onEditOutlines( currentSelection );
3218                         }
3219                 }
3220                 else if( toolCommand == wxContour_ActionCommandsID::UNDO_TOOL )
3221                 {
3222                         onUNDO();
3223                 }
3224                 else if( toolCommand == wxContour_ActionCommandsID::REDO_TOOL )
3225                 {
3226                         onREDO();
3227                 }
3228                 else if( toolCommand == wxContour_ActionCommandsID::INFORMATIONCONTOUR_TOOL )
3229                 {
3230                         onInformationContourFrame();
3231                 }
3232                 else if( toolCommand == wxContour_ActionCommandsID::INTERFACECONFIGURATION_TOOL )
3233                 {
3234                         onInterfaceConfigurationFrame();
3235                 }
3236                 else if( toolCommand == wxContour_ActionCommandsID::TEST_TOOL )
3237                 {
3238                         onInterfaceTestFrame();
3239                 }
3240
3241
3242         }
3243
3244
3245         //------------------------------------------------------------------------------------------------------------
3246         //  Getting information methods
3247         //------------------------------------------------------------------------------------------------------------
3248
3249
3250
3251         //------------------------------------------------------------------------------------------------------------
3252         //  Private methods
3253         //------------------------------------------------------------------------------------------------------------
3254
3255         void wxContourEventHandler :: updateInstantOutlines()
3256         {
3257                 std::vector<NameWrapper *> namesWrapping = _modelManager->getActualInstantOutlines();
3258                 int size = namesWrapping.size();
3259                 _sceneManager->removeSceneContours();
3260                 for( int i=0; i<size; i++)
3261                 {
3262                         _sceneManager->addToScene(namesWrapping[i]->getKeyName(), true, true, true, false, false );
3263                 }
3264         }
3265         //------------------------------------------------------------------------------------------------------------
3266         void wxContourEventHandler :: updateInstantImageData()
3267         {
3268
3269         }
3270         //------------------------------------------------------------------------------------------------------------
3271
3272         void wxContourEventHandler :: updateInstantAxes()
3273         {
3274
3275         }
3276         //------------------------------------------------------------------------------------------------------------
3277         void wxContourEventHandler :: changeInstant()
3278         {
3279                 std::vector<int> instantVect;
3280                 _instantPanel->getInstant( instantVect );
3281                 Instant * theInstant = new Instant ( &instantVect );
3282                 //if( !theInstant->isEquals( _actualInstant ))
3283                 {
3284                         //Setting the actual instant
3285                         _actualInstant = theInstant;
3286                         _modelManager->setInstant( _actualInstant );
3287
3288                         updateInstantOutlines();
3289                         updateInstantImageData();
3290                         updateInstantAxes();
3291
3292                         //Searching the elements at the specified instant
3293
3294                         /*
3295                         std::map<std::string, ContourWrap_ViewControl *> :: iterator iter;
3296                         iter = contours_ViewControl->find("Outline 0");
3297                         (iter->second)->getViewer()->RemoveCompleteContourActor();*/
3298                 }
3299         }
3300
3301         void wxContourEventHandler :: saveState(){
3302
3303
3304                 inredo = 0;
3305
3306                 //char str[9000];
3307                 //itoa(inundo, str, 10);
3308                 std::string str = intToString(inundo);
3309
3310
3311                 std::string temp = stundoredo + str + ".roi";
3312                 saveFileWithContours(temp);
3313
3314                 inundo++;
3315         }
3316
3317         void wxContourEventHandler ::loadState(std::string filename){
3318
3319                 char tmp[255];
3320                 FILE *pFile=fopen(filename.c_str(),"r+");
3321
3322                 fscanf(pFile,"%s",tmp); // --CreaContour--
3323
3324                 fscanf(pFile,"%s",tmp); // Version
3325                 fscanf(pFile,"%s",tmp); // 1.0.1
3326                 std::string version(tmp);
3327
3328                 deleteAllContours();
3329
3330                 openContours(pFile,false);
3331                 if (version!="1.0.0"){
3332                         openContours(pFile,true);
3333                 }
3334
3335                 fclose(pFile);
3336
3337                 //_sceneManager->removeSceneContours();
3338                 //changeInstant();
3339
3340         }
3341 void wxContourEventHandler :: onREDO()
3342         {
3343                 if(inredo > 0){
3344                         inredo--;
3345                         inundo++;
3346
3347                         //char str[9000];
3348                         //itoa(inundo, str, 10);
3349                         std::string str = intToString(inundo);
3350
3351
3352                         std::string temp = stundoredo + str + ".roi";
3353
3354                         loadState(temp);
3355
3356
3357                 }
3358
3359         }
3360         //------------------------------------------------------------------------------------------------------------
3361         void wxContourEventHandler :: onUNDO()
3362         {
3363                 if(inundo>0){
3364                         if(inredo==0){
3365
3366                                 //char str[9000];
3367                                 //itoa(inundo, str, 10);
3368                                 std::string str = intToString(inundo);
3369
3370                                 std::string temp = stundoredo + str + ".roi";
3371                                 saveFileWithContours(temp);
3372
3373                         }
3374                         inredo++;
3375                         inundo--;
3376
3377                         //char str[9000];
3378                         //itoa(inundo, str, 10);
3379                         std::string str = intToString(inundo);
3380
3381
3382                         std::string temp = stundoredo + str + ".roi";
3383
3384                         loadState(temp);
3385                 }
3386         }
3387 //JCP 21 - 10 - 09
3388         void  wxContourEventHandler :: getValuesXYZ(double **vectx, double **vecty, double **vectz, std::vector<int>* size){
3389
3390
3391                 wxBusyCursor wait;
3392                 ContourExtractData      *contourextractdata = new ContourExtractData();
3393                 int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
3394                 contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
3395
3396                 std::vector<manualContourModel*> lstManConMod;
3397                 std::vector<manualContourModel*> lstManConModTmp;
3398                 std::vector<manualContourModel*> lstManConModExp;
3399                 std::vector<double> pLstValue;
3400                 std::vector<double> pLstValuePosX;
3401                 std::vector<double> pLstValuePosY;
3402                 std::vector<double> pLstValuePosZ;
3403
3404                 std::vector<int> tempVector;
3405                 _instantPanel->getInstant( tempVector );
3406
3407                 vtkImageData *imagedata = _sceneManager->GetImageData();
3408                 int sizeZ = _sceneManager->GetImageDataSizeZ();
3409                 int z;
3410                 int ii,sizeLstContourThings;
3411
3412
3413                 int minZ,maxZ;
3414                 double totalZ;
3415                 double porcent;
3416                 wxString tmpString;
3417                 minZ    = 0;// _mbarrange->GetStart();
3418                 maxZ    = sizeZ;//_mbarrange->GetEnd();
3419                 totalZ  = maxZ-minZ+1;
3420
3421                 contourextractdata->SetImage( imagedata);
3422
3423         // For each slice..
3424                 vectx = new double *[sizeZ];
3425                 vecty = new double *[sizeZ];
3426                 vectz = new double *[sizeZ];
3427                 for ( z=0 ; z<sizeZ ; z++)
3428                 {
3429
3430                         porcent = 100.0* (z-minZ)/totalZ;
3431
3432                         //Extraction data from contours of each slice
3433                         contourextractdata->SetZtoBeAnalys( z);
3434
3435                         tempVector[1]=z;
3436                         Instant instant(&tempVector);
3437                         std::vector<ContourThing**> lstContourThings = this->_modelManager->getOutlinesAtInstant( &instant );
3438                         sizeLstContourThings = lstContourThings.size();
3439
3440                         lstManConMod.clear();
3441                         for (ii=0 ; ii<sizeLstContourThings ; ii++)
3442                         {
3443                                 ContourThing **contourthing = lstContourThings[ii];
3444                                 lstManConMod.push_back( (*contourthing)->getModel() );
3445                         }
3446                         lstManConModExp =  ExploseEachModel( lstManConMod );
3447
3448
3449 //EED004
3450
3451                         int iContourGroup,sizeContourGroup;
3452                         if (typeContourGroup==3) // contour separete
3453                         {
3454                                 sizeContourGroup=lstManConModExp.size();
3455                         } else {  // contour AND OR XOR
3456                                 sizeContourGroup=1;
3457                         }
3458
3459                         for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
3460                                 lstManConModTmp.clear();
3461                                 if (typeContourGroup==3) // contour separete
3462                                 {
3463                                         lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
3464                                 } else {  // contour AND OR XOR
3465                                         lstManConModTmp = lstManConModExp;
3466                                 }
3467
3468                                 contourextractdata->SetLstManualContourModel( lstManConModTmp );
3469
3470                                 pLstValue.clear();
3471                                 pLstValuePosX.clear();
3472                                 pLstValuePosY.clear();
3473                                 pLstValuePosZ.clear();
3474                                 contourextractdata->GetValuesInsideCrown(       &pLstValue,
3475                                                                                                                         &pLstValuePosX,
3476                                                                                                                         &pLstValuePosY,
3477                                                                                                                         &pLstValuePosZ);
3478
3479
3480                                 int iLstValue,sizeLstValue=pLstValue.size();
3481
3482                                 //We initialize the pointers
3483                                 size->push_back(sizeLstValue);
3484                                 vectx[sizeZ] = new double[sizeLstValue];
3485                                 vecty[sizeZ] = new double[sizeLstValue];
3486                                 vectz[sizeZ] = new double[sizeLstValue];
3487
3488                                 for (iLstValue=0 ; iLstValue<sizeLstValue ; iLstValue++ )
3489                                 {
3490
3491                                         vectx[sizeZ][iLstValue] = pLstValuePosX[iLstValue];
3492                                         vecty[sizeZ][iLstValue] = pLstValuePosY[iLstValue];
3493                                         vectz[sizeZ][iLstValue] = pLstValuePosZ[iLstValue];
3494
3495                                 }
3496                                 //The size of the contour is saved
3497
3498
3499
3500                                 //fclose(pFile);
3501                         } // for  iContourGroup
3502                 } // for z
3503                 //_staticTextInformation->SetLabel( _T("") );
3504                 delete contourextractdata;
3505
3506         }
3507
3508
3509         void  wxContourEventHandler :: getMaskValue(vtkImageData* mask, vtkImageData* value){
3510
3511
3512                 wxBusyCursor wait;
3513                 ContourExtractData      *contourextractdata = new ContourExtractData( true );
3514                 int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
3515                 if (typeContourGroup==3)
3516                 {
3517                         typeContourGroup=1;
3518                 }
3519                 contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
3520
3521                 std::vector<manualContourModel*> lstManConMod;
3522                 std::vector<manualContourModel*> lstManConModTmp;
3523                 std::vector<manualContourModel*> lstManConModExp;
3524
3525                 std::vector<int> tempVector;
3526                 _instantPanel->getInstant( tempVector );
3527
3528                 vtkImageData *imagedata = _sceneManager->GetImageData();
3529                 int sizeZ = _sceneManager->GetImageDataSizeZ();
3530                 int z;
3531                 int ii,sizeLstContourThings;
3532
3533
3534                 int minZ,maxZ;
3535                 double totalZ;
3536                 double porcent;
3537
3538                 wxString tmpString;
3539
3540                 minZ    = 0;// _mbarrange->GetStart();
3541                 maxZ    = sizeZ;//_mbarrange->GetEnd();
3542                 totalZ  = maxZ-minZ+1;
3543
3544                 contourextractdata->SetImage( imagedata);
3545
3546         // For each slice..
3547                 for ( z=0 ; z<sizeZ ; z++)
3548                 {
3549
3550                         porcent = 100.0* (z-minZ)/totalZ;
3551                         tmpString.Printf(_T("Saving Values"));
3552                         tmpString.Printf(_T("  %d %c            %d/%d             %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
3553                         _staticTextInformation->SetLabel(tmpString);
3554
3555                         //Extraction data from contours of each slice
3556                         contourextractdata->SetZtoBeAnalys( z);
3557
3558                         tempVector[1]=z;
3559                         Instant instant(&tempVector);
3560                         std::vector<ContourThing**> lstContourThings = this->_modelManager->getOutlinesAtInstant( &instant );
3561                         sizeLstContourThings = lstContourThings.size();
3562
3563                         lstManConMod.clear();
3564                         for (ii=0 ; ii<sizeLstContourThings ; ii++)
3565                         {
3566                                 ContourThing **contourthing = lstContourThings[ii];
3567                                 lstManConMod.push_back( (*contourthing)->getModel() );
3568                         }
3569                         lstManConModExp =  ExploseEachModel( lstManConMod );
3570
3571
3572                         int iContourGroup,sizeContourGroup;
3573                         if (typeContourGroup==3) // contour separete
3574                         {
3575                                 sizeContourGroup=lstManConModExp.size();
3576                         } else {  // contour AND OR XOR
3577                                 sizeContourGroup=1;
3578                         }
3579
3580                         for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
3581                                 lstManConModTmp.clear();
3582                                 if (typeContourGroup==3) // contour separete
3583                                 {
3584                                         lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
3585                                 } else {  // contour AND OR XOR
3586                                         lstManConModTmp = lstManConModExp;
3587                                 }
3588
3589                                 contourextractdata->SetLstManualContourModel( lstManConModTmp );
3590
3591
3592                                 contourextractdata->CalculateImageResult(); // with actual Z
3593
3594                         } // for  iContourGroup
3595                 } // for z
3596
3597
3598
3599 // Image Value
3600                 value = contourextractdata->GetVtkImageValueResult();
3601
3602 // Image Mask
3603                 mask = contourextractdata->GetVtkImageMaskResult();
3604
3605                 delete contourextractdata;
3606
3607
3608         }
3609         wxPanel* wxContourEventHandler::getSegmentationPanelITK(wxWindow* parent){
3610
3611                 int sizeZ = _sceneManager->GetImageDataSizeZ();
3612                 double range[2];
3613                 _sceneManager->GetImageDataRange(range);
3614
3615                 wxPanel *panel                                          = new wxPanel(parent,-1);
3616                 wxButton *segmentationOneSliceBtn       = new wxButton(panel,-1,_T("Actual slice"), wxDefaultPosition, wxSize(200,35) );
3617                 wxButton *segmentationAllSliceBtn       = new wxButton(panel,-1,_T("All slices") ,wxDefaultPosition, wxSize(200,35) );
3618                 _isovalue                                                       = new wxSlider(panel, -1, 40 , (int)(range[0]), (int)(range[1]), wxDefaultPosition, wxSize(200,35), wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
3619                 _sampling                                                       = new wxSlider(panel, -1, 20 , 4, 50, wxDefaultPosition, wxSize(200,35), wxSL_HORIZONTAL|wxSL_LABELS, wxDefaultValidator);
3620                 wxString lstOptions[3];
3621                 lstOptions[0]=_T("A");
3622                 lstOptions[1]=_T("B");
3623                 lstOptions[2]=_T("C");
3624                 methodRadiobox                                          = new wxRadioBox(panel, -1, _T("Method (find ctrl. Points)"), wxDefaultPosition, wxSize(200,45), 3 , lstOptions,  3, wxRA_SPECIFY_COLS);
3625                 methodRadiobox->SetSelection(2);
3626                 _staticTextSegmentation                         = new wxStaticText(panel,-1,_T("    "));
3627
3628
3629                 _mbarrange                                      =  new mBarRange(panel,70, 65);
3630                 _mbarrange->SetMin(0);
3631                 _mbarrange->SetStart(0);
3632
3633                 _mbarrange-> SetOrientation( true );
3634                 _mbarrange-> setActiveStateTo(true);
3635                 _mbarrange-> setVisibleLabels( true );
3636                 _mbarrange-> setDeviceEndMargin(10);
3637                 _mbarrange-> setRepresentedValues( 0 , sizeZ );
3638                 _mbarrange-> setDeviceBlitStart(10,10);
3639                 _mbarrange-> setIfWithActualDrawed( false );
3640                 _mbarrange-> SetStart( 0 );
3641                 _mbarrange-> SetEnd( sizeZ );
3642
3643
3644 //                      _segmentationFrame->SetEventHandler( this );
3645                 segmentationOneSliceBtn->SetEventHandler( this );
3646                 segmentationAllSliceBtn->SetEventHandler( this );
3647                 Connect( segmentationOneSliceBtn->GetId(),   wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSegmentationOneSliceITK );
3648                 Connect( segmentationAllSliceBtn->GetId(),   wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxContourEventHandler::onSegmentationAllSliceITK );
3649
3650                 wxFlexGridSizer * sizer                         = new wxFlexGridSizer(1);
3651                 sizer -> Add( new wxStaticText(panel,-1,_T("Isovalue (Gray level)"))  , 1, wxGROW );
3652                 sizer -> Add( _isovalue , 1, wxGROW );
3653                 sizer -> Add( methodRadiobox , 1, wxGROW );
3654                 sizer -> Add( new wxStaticText(panel,-1,_T("Sampling (%)"))  , 1, wxGROW );
3655                 sizer -> Add( _sampling , 1, wxGROW );
3656                 sizer -> Add( segmentationOneSliceBtn , 1, wxGROW );
3657                 sizer -> Add( new wxStaticText(panel,-1,_T(" "))  , 1, wxGROW );
3658                 sizer -> Add( _staticTextSegmentation  , 1, wxGROW );
3659                 sizer -> Add( segmentationAllSliceBtn , 1, wxGROW );
3660                 sizer -> Add( _mbarrange  , 1, wxGROW );
3661
3662                 panel->SetSizer( sizer );
3663 //              panel->SetSize( sizePanel );
3664                 panel->SetSize( wxDefaultSize );
3665                 panel->SetAutoLayout( true );
3666                 panel->Layout();
3667
3668                 return panel;
3669
3670         }
3671
3672         void wxContourEventHandler::onSegmentationAllSliceITK( wxCommandEvent& event ){
3673                 //TODO implementar el método para todos los slices ver ayuda en onSegmentationAllSlice
3674         }
3675         void wxContourEventHandler::onSegmentationOneSliceITK( wxCommandEvent& event ){
3676                 //TODO implementar el método de segmentación en ITK ver ayuda en onSegmentationOneSlice y el método
3677                 // SegmentationOneSlice(x, y, z) que es la implementación del método en VTK
3678
3679                 //JCP 20-10-08 Undo redo implementation
3680                 saveState();
3681                 //JCP 20-10-08 Undo redo implementation
3682
3683                 wxBusyCursor wait;
3684                 int                                     x                                       = this->_theViewPanel->GetX();
3685                 int                                     y                                       = this->_theViewPanel->GetY();
3686                 int                                     z                                       = this->_theViewPanel->GetZ();
3687                 //SegmentationOneSlice( x,y,z );
3688                 RefreshInterface();
3689         }
3690         void wxContourEventHandler::onSnakePressed(wxWindow* parent){
3691
3692                 std::vector<double> vecX;
3693                 std::vector<double> vecY;
3694                 std::vector<double> vecZ;
3695                 _sceneManager->GetPointsOfActualContour( &vecX , &vecY , &vecZ );
3696
3697                 if (vecX.size()!=0){
3698                         std::vector<int> tempVector;
3699                         _instantPanel->getInstant( tempVector );
3700                         int i,size=vecZ.size();
3701                         int actualSlice = tempVector[1];
3702                         for ( i=0 ; i<size ; i++ )
3703                         {
3704                                 vecZ[i] = actualSlice;
3705                         } // for
3706
3707                         wxDialog* dialog = new wxDialog(parent, -1, wxString(_T("Snake")));
3708                         wxPanel* panel = new wxPanel(dialog,-1);
3709                         wxStaticText* sttext = new wxStaticText(panel, -1, wxString(_T("Panel para snake")));
3710                         dialog->ShowModal();
3711                 } // if
3712
3713         }
3714
3715         void wxContourEventHandler::checkInformationPanel(){
3716                 if (_InformationContourFrame==NULL){
3717                         onInformationContourFrame();
3718                         _InformationContourFrame->Show(false);
3719                 }
3720         }
3721
3722         std::string wxContourEventHandler::intToString(int num){
3723                 std::string result;
3724                 for(int k = num; k == 0; k++){
3725                         char temp = k % 10 + 48;
3726                         k = k / 10;
3727                         result = temp + result;
3728                 }
3729                 return result;
3730         }
3731 //JCP 21 - 10 - 09