lib/Interface_ManagerContour_NDimensions/wxVtkBaseView_SceneManager.cxx

   1 /*# ---------------------------------------------------------------------
   2 #
   3 # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
   4 #                        pour la Sant�)
   5 # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
   6 # Previous Authors : Laurent Guigues, Jean-Pierre Roux
   7 # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
   8 #
   9 #  This software is governed by the CeCILL-B license under French law and
  10 #  abiding by the rules of distribution of free software. You can  use,
  11 #  modify and/ or redistribute the software under the terms of the CeCILL-B
  12 #  license as circulated by CEA, CNRS and INRIA at the following URL
  13 #  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  14 #  or in the file LICENSE.txt.
  15 #
  16 #  As a counterpart to the access to the source code and  rights to copy,
  17 #  modify and redistribute granted by the license, users are provided only
  18 #  with a limited warranty  and the software's author,  the holder of the
  19 #  economic rights,  and the successive licensors  have only  limited
  20 #  liability.
  21 #
  22 #  The fact that you are presently reading this means that you have had
  23 #  knowledge of the CeCILL-B license and that you accept its terms.
  24 # ------------------------------------------------------------------------ */
  25
  26
  27 //----------------------------------------------------------------------------------------------------------------
  28 // Class definition include
  29 //----------------------------------------------------------------------------------------------------------------
  30 #include "wxVtkBaseView_SceneManager.h"
  31 #include "wxVtk2DBaseView.h"
  32
  33 //----------------------------------------------------------------------------------------------------------------
  34 // Class implementation
  35 //----------------------------------------------------------------------------------------------------------------
  36 /** @file wxVtkBaseView_SceneManager.cxx */
  37
  38
  39 //------------------------------------------------------------------------------------------------------------
  40 // Includes
  41 //------------------------------------------------------------------------------------------------------------
  42 #include "wxContour_ActionCommandsID.h"
  43
  44 //------------------------------------------------------------------------------------------------------------
  45 // Generated events declaration and definition
  46 //------------------------------------------------------------------------------------------------------------
  47
  48 DEFINE_EVENT_TYPE( wxEVT_START_CREATE_MULT_ROI )
  49 DEFINE_EVENT_TYPE( wxEVT_STOP_CREATE_MULT_ROI )
  50 DEFINE_EVENT_TYPE( wxEVT_START_CREATE_ROI )
  51 DEFINE_EVENT_TYPE( wxEVT_STOP_CREATE_ROI )
  52 DEFINE_EVENT_TYPE( wxEVT_DELETE_ROI )
  53 DEFINE_EVENT_TYPE( wxEVT_SELECTED_MULT_ROI )
  54 DEFINE_EVENT_TYPE( wxEVT_SELECTED_ROI )
  55 DEFINE_EVENT_TYPE( wxEVT_UNSLECTED_ROI )
  56 DEFINE_EVENT_TYPE( wxEVT_MANUAL_HIDED_ROI )
  57 DEFINE_EVENT_TYPE( wxEVT_MANUAL_SHOWED_ROI )
  58 DEFINE_EVENT_TYPE( wxEVT_EDITING_ROI )
  59 DEFINE_EVENT_TYPE( wxEVT_MOVING_ROI )
  60 DEFINE_EVENT_TYPE( wxEVT_MOVING_ROI_POINT )
  61 DEFINE_EVENT_TYPE( wxEVT_SELECTED_ROI_POINT )
  62 DEFINE_EVENT_TYPE( wxEVT_UNSELECTED_ROI_POINT )
  63 DEFINE_EVENT_TYPE( wxEVT_CHANGED_DEEP )
  64
  65
  66         wxVtkBaseView_SceneManager :: wxVtkBaseView_SceneManager( wxVtkBaseView * theWxBaseViewToManage, wxEvtHandler * theEventHandler, double * spc )
  67         {
  68
  69                 _lastInteraction                                = NULL;
  70                 _lastInteractionName                            = "";
  71                 _eventHandler                                   = theEventHandler;
  72                 _leftClickCount                                 = 0;
  73                 _rigthClickCount                                = 0;
  74
  75                 _contours_ViewControl                           = new std::map< std::string, ContourWrap_ViewControl * >();
  76                 _sceneContours_ViewControl                      = new std::map< std::string, ContourWrap_ViewControl * >();
  77                 _workingGroup                                   = new std::map< std::string, ContourWrap_ViewControl * >();
  78
  79                 _creatingMULT_ROI                               = false;
  80                 _editingROI                                     = false;
  81                 _toIncludeAtInteractionGroup                    = false;
  82                 _waiting                                        = false;
  83                 _creatingROI                                    = false;
  84                 _drawingSelectionROI                            = false;
  85                 SetWidthContour(1.0);
  86
  87                 _wxVtk_BaseView = theWxBaseViewToManage;
  88                 if( _wxVtk_BaseView!=NULL )
  89                 {
  90                         vtkInteractorStyleBaseView* theInteractorStyleBaseView = (vtkInteractorStyleBaseView*)_wxVtk_BaseView->GetInteractorStyleBaseView();
  91                         theInteractorStyleBaseView->AddInteractorStyleMaracas( this );
  92                         SetVtkInteractorStyleBaseView( theInteractorStyleBaseView );
  93                 }
  94                 configureSelectionROI( spc );
  95         }
  96         //------------------------------------------------------------------------------------------------------------
  97         wxVtkBaseView_SceneManager :: ~wxVtkBaseView_SceneManager()
  98         {
  99                 std::map <std::string, ContourWrap_ViewControl *>::iterator iter = _contours_ViewControl->begin();
 100                 int size = _contours_ViewControl->size();
 101                 for ( int i = 0; i<size; iter++ )
 102                 {
 103                         _contours_ViewControl->erase( iter );
 104                         i++;
 105                 }
 106                 _contours_ViewControl->clear();
 107                 delete _contours_ViewControl;
 108                 _workingGroup->clear();
 109                 delete _lastInteraction;
 110                 delete _workingGroup;
 111                 //delete _contours_ViewControl;
 112         }
 113
 114         //------------------------------------------------------------------------------------------------------------
 115         // Methods for capturing events
 116         //------------------------------------------------------------------------------------------------------------
 117
 118
 119         //------------------------------------------------------------------------------------------------------------
 120         //  Methods for sending events
 121         //------------------------------------------------------------------------------------------------------------
 122         void wxVtkBaseView_SceneManager :: sendEnvent( WXTYPE theEventType, std::string text )
 123         {
 124                 if ( _eventHandler != NULL )
 125                 {
 126                         wxCommandEvent cevent( theEventType );
 127                         cevent.SetString( wxString( text.c_str(), wxConvUTF8) );
 128                         _eventHandler->ProcessEvent( cevent );
 129                 }
 130         }
 131
 132
 133         //------------------------------------------------------------------------------------------------------------
 134         //  Attributes getters and setters
 135         //------------------------------------------------------------------------------------------------------------
 136         void wxVtkBaseView_SceneManager :: setWxEventHandler( wxEvtHandler * theEventHandler )
 137         {
 138                 _eventHandler = theEventHandler;
 139         }
 140         //------------------------------------------------------------------------------------------------------------
 141         void wxVtkBaseView_SceneManager :: setWxVtkViewBase( wxVtkBaseView * theBaseView )
 142         {
 143                 _wxVtk_BaseView = theBaseView;
 144         }
 145
 146         //------------------------------------------------------------------------------------------------------------
 147         wxVtkBaseView * wxVtkBaseView_SceneManager :: getWxVtkViewBase()
 148         {
 149                 return _wxVtk_BaseView;
 150         }
 151         //------------------------------------------------------------------------------------------------------------
 152         void wxVtkBaseView_SceneManager :: configureViewControlTo( std::string theKeyName, manualBaseModel * manModelContour, double * spc,int typeContour)
 153         {
 154                 //setControlActiveStateOfALL( false );
 155                 _creatingROI = true;
 156                 _waiting = false;
 157                 if( _lastInteraction!=NULL )
 158                 {
 159                         _lastInteraction->getControler()->SetEditable( false );
 160                         _lastInteraction->getViewer()->Refresh();
 161                         _lastInteraction->getControler()->SetActive( false );
 162                         this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
 163                 }
 164
 165
 166                 manualContourBaseControler *manContourControl;
 167                 manualViewBaseContour           *manViewerContour;
 168
 169                 // Creating the view manualViewContour and the manualContourControler
 170                 // NOTE: The model is created in the KernelManagerContour class, factoryManualContourModel method
 171                 if (typeContour==1)
 172                 {
 173                         manContourControl       = new manualContourControler();
 174                         manViewerContour        = new manualViewContour();
 175                 }
 176
 177                 if (typeContour==2)
 178                 {
 179                         manContourControl       = new manualRoiControler();
 180                         manViewerContour        = new manualViewRoi();
 181                 }
 182
 183                 if (typeContour==3)
 184                 {
 185                         manContourControl       = new manualCircleControler();
 186                         manViewerContour        = new manualViewCircle();
 187                 }
 188
 189                 if (typeContour==4)
 190                 {
 191                         manContourControl       = new manualRoiControler();
 192                         manViewerContour        = new manualViewBullEye();
 193                 }
 194
 195                 if (typeContour==6)
 196                 {
 197                         manContourControl       = new manualLineControler();
 198                         manViewerContour        = new manualViewLine();
 199                 }
 200
 201                 //Points
 202                 if (typeContour==7)
 203                 {
 204                         manContourControl       = new manualContourControler();
 205                         manViewerContour        = new manualViewPoints();
 206                 }
 207
 208                 //Polygon
 209                 if (typeContour==10)
 210                 {
 211                         manContourControl       = new manualContourControler();
 212                         manViewerContour        = new manualViewContour();
 213                 }
 214
 215
 216
 217         _lastInteraction = insertWrap( theKeyName, manContourControl, manViewerContour );
 218                 _lastInteractionName = theKeyName;
 219
 220                 //Configuring the relations between the contour members representation
 221                 manViewerContour->SetModel( manModelContour );
 222                 manViewerContour->SetWxVtkBaseView( _wxVtk_BaseView );
 223                 manViewerContour->SetRange( _widthOfControlPoint );
 224                 manViewerContour->SetZ( -900 );
 225
 226                 manViewerContour->SetSpacing(spc);
 227
 228                 manViewerContour->SetColorNormalContour(0, 0, 1);
 229                 manViewerContour->SetColorEditContour(0.5, 0.5, 0.5);
 230                 manViewerContour->SetColorSelectContour(1, 0.8, 0);
 231                 manViewerContour->SetWidthLine(_widthOfContour);
 232
 233                 manContourControl->SetModelView( manModelContour , manViewerContour );
 234                 manContourControl->Configure();
 235                 int i,sizeLstPoints = manModelContour->GetSizeLstPoints();
 236                 for ( i=0; i<sizeLstPoints; i++ )
 237                 {
 238                         manViewerContour->AddPoint();
 239                 }
 240
 241                 manContourControl->CreateNewManualContour();
 242                 manViewerContour->RefreshContour();
 243                 addToScene( theKeyName );
 244         }
 245         //------------------------------------------------------------------------------------------------------------
 246         void wxVtkBaseView_SceneManager :: configureSelectionROI( double * spc )
 247         {
 248                 _controlerSelectionROI = new manualRoiControler();
 249                 _viewerSelectionROI = new manualViewRoi();
 250                 _modelSelectionROI = new manualContourModel();
 251
 252                 _viewerSelectionROI->SetModel( _modelSelectionROI );
 253                 _viewerSelectionROI->SetWxVtkBaseView( _wxVtk_BaseView );
 254                 _viewerSelectionROI->SetRange( 2 );
 255                 _viewerSelectionROI->SetZ( -900 );
 256                 _viewerSelectionROI->SetColorNormalContour(0.6, 0.8, 0);
 257
 258                 _viewerSelectionROI->SetSpacing( spc );
 259
 260                 _controlerSelectionROI->SetModelView( _modelSelectionROI , _viewerSelectionROI );
 261                 ((vtkInteractorStyleBaseView*)_wxVtk_BaseView->GetInteractorStyleBaseView())->AddInteractorStyleMaracas( _controlerSelectionROI );
 262                 _controlerSelectionROI->SetActive(false);
 263         }
 264
 265         //------------------------------------------------------------------------------------------------------------
 266         ContourWrap_ViewControl * wxVtkBaseView_SceneManager :: insertWrap( std::string theKeyName, manualContourBaseControler * manContourControl, manualViewBaseContour  * manViewerContour )
 267         {
 268                 ContourWrap_ViewControl * newContourWrap = new ContourWrap_ViewControl(manContourControl, manViewerContour);
 269                 if(_contours_ViewControl == NULL)
 270                 {
 271                         _contours_ViewControl = new std::map< std::string, ContourWrap_ViewControl * >();
 272                 }
 273                 _contours_ViewControl->insert(std::pair <std::string, ContourWrap_ViewControl *> ( theKeyName, newContourWrap ));
 274                 return newContourWrap;
 275         }
 276         //------------------------------------------------------------------------------------------------------------
 277         void wxVtkBaseView_SceneManager :: desconfigureViewControlOf( std::string theKeyName )
 278         {
 279
 280         }
 281         //------------------------------------------------------------------------------------------------------------
 282         void wxVtkBaseView_SceneManager :: removeWrap( std::string theKeyName )
 283         {
 284                 std::map<std::string, ContourWrap_ViewControl *> :: iterator iter;
 285                 iter = _contours_ViewControl->find( theKeyName );
 286                 _contours_ViewControl->erase( iter );
 287                 _lastInteraction=NULL;
 288                 _lastInteractionName = "";
 289                 _workingGroup->clear();
 290                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
 291                 this->_vtkInteractorStyleBaseView->EvaluateToRefresh();
 292         }
 293         //------------------------------------------------------------------------------------------------------------
 294         ContourWrap_ViewControl * wxVtkBaseView_SceneManager :: getContourWrap_ViewControlOf ( std::string theName )
 295         {
 296                 std::map<std::string, ContourWrap_ViewControl *> :: iterator iter;
 297                 iter = _contours_ViewControl->find( theName );
 298                 return iter->second;
 299                 //return iter->first;
 300         }
 301         //------------------------------------------------------------------------------------------------------------
 302         ContourWrap_ViewControl * wxVtkBaseView_SceneManager :: getContourWrap_ViewControlOf ( std::string theName, std::map<std::string, ContourWrap_ViewControl *> * theMap )
 303         {
 304                 std::map<std::string, ContourWrap_ViewControl *> :: iterator iter;
 305                 iter = theMap->find( theName );
 306                 return iter->second;
 307         }
 308         //------------------------------------------------------------------------------------------------------------
 309         manualContourBaseControler * wxVtkBaseView_SceneManager :: getControlerOf( std::string theName )
 310         {
 311                 return getContourWrap_ViewControlOf ( theName )->getControler();
 312         }
 313         //------------------------------------------------------------------------------------------------------------
 314         manualViewBaseContour * wxVtkBaseView_SceneManager :: getViewerOf( std::string theName )
 315         {
 316                 return getContourWrap_ViewControlOf ( theName )->getViewer();
 317         }
 318         //------------------------------------------------------------------------------------------------------------
 319         void wxVtkBaseView_SceneManager :: set_creatingMULT_ROI( bool condition )
 320         {
 321                 _creatingMULT_ROI = condition;
 322         }
 323         //------------------------------------------------------------------------------------------------------------
 324         void wxVtkBaseView_SceneManager :: set_editingROI( bool condition )
 325         {
 326                 _editingROI = condition;
 327         }
 328         //------------------------------------------------------------------------------------------------------------
 329         void wxVtkBaseView_SceneManager :: set_toIncludeAtInteractionGroup( bool condition )
 330         {
 331                 _toIncludeAtInteractionGroup = condition;
 332         }
 333         //------------------------------------------------------------------------------------------------------------
 334         void wxVtkBaseView_SceneManager :: set_waiting( bool condition )
 335         {
 336                 _waiting = condition;
 337         }
 338         //------------------------------------------------------------------------------------------------------------
 339         bool wxVtkBaseView_SceneManager :: get_creatingMULT_ROI(  )
 340         {
 341                 return _creatingMULT_ROI;
 342         }
 343         //------------------------------------------------------------------------------------------------------------
 344         bool wxVtkBaseView_SceneManager :: get_editingROI(  )
 345         {
 346                 return _editingROI;
 347         }
 348         //------------------------------------------------------------------------------------------------------------
 349         bool wxVtkBaseView_SceneManager :: get_toIncludeAtInteractionGroup(  )
 350         {
 351                 return _toIncludeAtInteractionGroup;
 352         }
 353
 354         //------------------------------------------------------------------------------------------------------------
 355         bool wxVtkBaseView_SceneManager :: get_waiting(  )
 356         {
 357                 return _waiting;
 358         }
 359
 360         //------------------------------------------------------------------------------------------------------------
 361         bool wxVtkBaseView_SceneManager :: get_creatingROI()
 362         {
 363                 return _creatingROI;
 364         }
 365         //------------------------------------------------------------------------------------------------------------
 366         void wxVtkBaseView_SceneManager :: set_creatingROI( bool condition )
 367         {
 368                 _creatingROI = condition;
 369         }
 370
 371         //------------------------------------------------------------------------------------------------------------
 372         //  Other functional methods
 373         //------------------------------------------------------------------------------------------------------------
 374
 375         void wxVtkBaseView_SceneManager :: createCopyContourOf( std::string anExistingKName, std::string cloneName, manualBaseModel * manualModel, bool append )
 376         {
 377                 if ( !append )
 378                 {
 379                         setControlActiveStateOf( _workingGroup, false );
 380                         _workingGroup->clear();
 381                 }
 382         std::map <std::string, ContourWrap_ViewControl *>::iterator iter;
 383
 384
 385                 iter = _contours_ViewControl->find( anExistingKName );
 386
 387                 manualBaseModel                 *cModule        = manualModel;
 388                 manualViewBaseContour           *cViewer        = iter->second->getViewer()->Clone();
 389                 manualContourBaseControler      *cControl       = iter->second->getControler()->Clone(  );
 390
 391                 cViewer->SetModel(cModule);
 392                 cControl->SetModelView( cModule , cViewer );
 393                 cControl->CreateNewManualContour();
 394                 cControl->SetActive( true );
 395                 cControl->SetEditable( false );
 396
 397         cViewer->RefreshContour();
 398                 cViewer->Refresh();
 399                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
 400                 this->_vtkInteractorStyleBaseView->EvaluateToRefresh();
 401
 402                 _lastInteraction = insertWrap( cloneName, cControl, cViewer );
 403                 _workingGroup->insert(std::pair <std::string, ContourWrap_ViewControl *> ( cloneName, _lastInteraction ));
 404         addToScene( cloneName );
 405         }
 406
 407         //------------------------------------------------------------------------------------------------------------
 408
 409         void wxVtkBaseView_SceneManager :: removeFromScene( ContourWrap_ViewControl * contourWRP, bool visualization, bool control )
 410         {
 411                 if( contourWRP == _lastInteraction )
 412                 {
 413                         _lastInteraction = NULL;
 414                         _lastInteractionName = "";
 415                 }
 416
 417
 418                 ((vtkInteractorStyleBaseView*)_wxVtk_BaseView->GetInteractorStyleBaseView())->RemoveInteractorStyleMaracas( contourWRP->getControler() );
 419
 420                 contourWRP->getControler()->SetActive( control );
 421                 contourWRP->getControler()->SetEditable( false );
 422
 423                 if ( !visualization && control )
 424                 {
 425                         contourWRP->getViewer()->RemoveControlPoints( );
 426                         contourWRP->getViewer()->RemoveTextActor( );
 427                 }
 428                 if ( visualization )
 429                 {
 430                         contourWRP->getViewer()->RemoveCompleteContourActor();
 431                 }
 432
 433         }
 434         //------------------------------------------------------------------------------------------------------------
 435         void wxVtkBaseView_SceneManager :: removeFromScene( std::string theKeyName, bool visualization , bool control )
 436         {
 437
 438                 std::map<std::string, ContourWrap_ViewControl *> :: iterator iter;
 439                 iter = _sceneContours_ViewControl->find( theKeyName );
 440                 if (iter != _sceneContours_ViewControl->end())
 441                 {
 442                         ContourWrap_ViewControl * contourWRP =   iter->second;
 443                         removeFromScene( contourWRP );
 444                         _sceneContours_ViewControl->erase(iter);
 445                 }
 446         }
 447
 448
 449         //------------------------------------------------------------------------------------------------------------
 450         std::vector<std::string> wxVtkBaseView_SceneManager::GetlstContoursNameActualSlice()
 451         {
 452                 std::vector<std::string> lstContoursNameActualSlice;
 453                 std::map <std::string, ContourWrap_ViewControl *>::iterator iter = _sceneContours_ViewControl->begin();
 454                 int i,size = _sceneContours_ViewControl->size();
 455                 for ( i = 0; i<size; i++ )
 456                 {
 457                         lstContoursNameActualSlice.push_back( iter->first );
 458                         iter++;
 459                 }
 460                 return lstContoursNameActualSlice;
 461         }
 462
 463         //------------------------------------------------------------------------------------------------------------
 464         void wxVtkBaseView_SceneManager :: removeSceneContours( )
 465         {
 466                 std::map <std::string, ContourWrap_ViewControl *>::iterator iter = _sceneContours_ViewControl->begin();
 467                 int size = _sceneContours_ViewControl->size();
 468                 for ( int i = 0; i<size; i++ )
 469                 {
 470                         removeFromScene( iter->second );
 471                         iter++;
 472                 }
 473                 _sceneContours_ViewControl->clear();
 474
 475
 476                 //Removing the selection rectangle to avoid showing when it's innecesary
 477                 _controlerSelectionROI->SetActive( false );
 478                 _viewerSelectionROI->RemoveCompleteContourActor();
 479         }
 480
 481         void wxVtkBaseView_SceneManager::removeAllOutlines()
 482         {
 483                 manualViewBaseContour           * cViewer;
 484                 manualContourBaseControler      * cControler;
 485
 486                 std::map <std::string, ContourWrap_ViewControl *>::iterator iter;
 487                 int i,size=_contours_ViewControl->size();
 488                 for (i=0;i<size;i++)
 489                 {
 490                         iter = _contours_ViewControl->begin();
 491                         cControler      = iter->second->getControler();
 492                         cViewer         = iter->second->getViewer();
 493                         removeWrap( iter->first );
 494                         delete cViewer;
 495                         delete cControler;
 496                 }// for
 497
 498         }
 499
 500
 501         //------------------------------------------------------------------------------------------------------------
 502         void wxVtkBaseView_SceneManager :: addToScene( std::string theKeyName, bool append, bool visualization, bool control, bool ifActive, bool ifShowCtrlPoints )
 503         {
 504                 if( !append )
 505                 {
 506                         removeSceneContours();
 507                 }
 508                 ContourWrap_ViewControl * contourWRP =  getContourWrap_ViewControlOf( theKeyName );
 509                 _sceneContours_ViewControl->insert(std::pair <std::string, ContourWrap_ViewControl *> ( theKeyName, contourWRP ) );
 510
 511                 addToScene( theKeyName, contourWRP, true, visualization, control, ifActive, ifShowCtrlPoints);
 512         }
 513
 514         //------------------------------------------------------------------------------------------------------------
 515         void wxVtkBaseView_SceneManager :: addToScene( std::string theKeyName, ContourWrap_ViewControl * contourWRP, bool append, bool visualization, bool control, bool ifActive, bool ifShowCtrlPoints )
 516         {
 517                 if( !append )
 518                 {
 519                         removeSceneContours();
 520                 }
 521                 _sceneContours_ViewControl->insert(std::pair <std::string, ContourWrap_ViewControl *> ( theKeyName, contourWRP ) );
 522                 if ( visualization )
 523                 {
 524                         contourWRP->getViewer()->AddCompleteContourActor( ifShowCtrlPoints );
 525                 }
 526
 527                 if( control )
 528                 {
 529                         ((vtkInteractorStyleBaseView*)_wxVtk_BaseView->GetInteractorStyleBaseView())->AddInteractorStyleMaracas( contourWRP->getControler() );
 530                 }
 531                 if( ifActive )
 532                 {
 533                         contourWRP->getControler()->SetActive( true );
 534                         contourWRP->getViewer()->RemoveTextActor();
 535                 }
 536         }
 537
 538         //------------------------------------------------------------------------------------------------------------
 539         void wxVtkBaseView_SceneManager :: removeFromScene( std::vector< std::string> theKeyNameVector, bool visualization, bool control  )
 540         {
 541                 int i, size = theKeyNameVector.size();
 542                 for( i=0; i< size; i++ )
 543                 {
 544                         removeFromScene( theKeyNameVector[i], visualization, control );
 545                 }
 546         }
 547
 548         //------------------------------------------------------------------------------------------------------------
 549         void wxVtkBaseView_SceneManager :: addToScene( std::vector< std::string> theKeyNameVector, bool append, bool visualization, bool control, bool ifActive, bool ifShowCtrlPoints )
 550         {
 551                 int i, size = theKeyNameVector.size();
 552                 for( i=0; i< size; i++ )
 553                 {
 554                         addToScene( theKeyNameVector[i], append, visualization, control, ifActive, ifShowCtrlPoints );
 555                 }
 556         }
 557
 558         //------------------------------------------------------------------------------------------------------------
 559         void wxVtkBaseView_SceneManager :: setControlActiveStateOfALL( bool stateCondition )
 560         {
 561                 setControlActiveStateOf( _contours_ViewControl, stateCondition );
 562         }
 563
 564         //------------------------------------------------------------------------------------------------------------
 565         void wxVtkBaseView_SceneManager :: setControlActiveStateOf( std::string theKeyName, bool stateCondition )
 566         {
 567                 ContourWrap_ViewControl * contourWRP =  getContourWrap_ViewControlOf( theKeyName );
 568                 setControlActiveStateOf( contourWRP, stateCondition );
 569         }
 570
 571         //------------------------------------------------------------------------------------------------------------
 572         void wxVtkBaseView_SceneManager :: setControlActiveStateOf( ContourWrap_ViewControl * contourWRP, bool stateCondition )
 573         {
 574                 contourWRP->getControler()->SetActive( stateCondition );
 575                 contourWRP->getControler()->SetEditable( false );
 576         }
 577
 578         //------------------------------------------------------------------------------------------------------------
 579         void wxVtkBaseView_SceneManager :: setVisibleStateOf( std::string theKeyName, bool stateCondition )
 580         {
 581                 ContourWrap_ViewControl * contourWRP =  getContourWrap_ViewControlOf( theKeyName );
 582 //              contourWRP->getViewer()->SetVisible( stateCondition );
 583                 if ( contourWRP!=NULL )
 584                         removeFromScene( contourWRP, false, stateCondition );
 585         }
 586
 587         //------------------------------------------------------------------------------------------------------------
 588         std::vector< std::string > wxVtkBaseView_SceneManager :: getSelectedObjects()
 589         {
 590                 std::vector< std::string > selectedObjects;
 591                 std::map <std::string, ContourWrap_ViewControl *>::iterator iter = _workingGroup->begin();
 592                 int size = _workingGroup->size();
 593                 for ( int i = 0; i<size; i++ )
 594                 {
 595 //EED???                        manualViewBaseContour * viewer = iter->second->getViewer();
 596                         selectedObjects.push_back( iter->first);
 597
 598                         iter++;
 599                 }
 600                 return selectedObjects;
 601         }
 602         //------------------------------------------------------------------------------------------------------------
 603         void wxVtkBaseView_SceneManager :: selectObjects( std::vector< std::string > theExistingObjectsToSelect )
 604         {
 605                 std::map <std::string, ContourWrap_ViewControl *>::iterator iter = _contours_ViewControl->begin();
 606 //EED???                int size = _contours_ViewControl->size();
 607 //EED???                bool selected;
 608                 /*for ( int i = 0; i<size; i++ )
 609                 {
 610                         selected = false;
 611                         manualViewBaseContour * viewer = iter->second->getViewer();
 612                         std::vector <std::string >::iterator iterIN;
 613                         int a = 0;
 614                         for( a = 0, iterIN = theExistingObjectsToSelect.begin() ; !selected && a < theExistingObjectsToSelect.size() ; a++ )
 615                         {
 616                                 if( iter->first.compare( theExistingObjectsToSelect[i] ) )
 617                                 {
 618                                         viewer->SelectAllPoints( true );
 619                                         viewer->SelectPosibleContour( true );
 620                                         selected = true;
 621                                         theExistingObjectsToSelect.erase( iterIN );
 622                                 }
 623                                 if( !selected )
 624                                         iterIN++;
 625                         }
 626                 }       */
 627         }
 628
 629         //------------------------------------------------------------------------------------------------------------
 630         void wxVtkBaseView_SceneManager :: selectObjects( std::map<std::string, ContourWrap_ViewControl *> * theMap )
 631         {
 632                 std::map <std::string, ContourWrap_ViewControl *>::iterator iter = theMap->begin();
 633                 int size = _contours_ViewControl->size();
 634                 for ( int i = 0; i<size; i++ )
 635                 {
 636                         manualViewBaseContour * viewer = iter->second->getViewer();
 637
 638                         viewer->SetSelected( true );
 639                         /*viewer->SelectAllPoints( true );
 640                         viewer->SelectPosibleContour( true );*/
 641
 642                         iter++;
 643                 }
 644         }
 645
 646         //------------------------------------------------------------------------------------------------------------
 647         void wxVtkBaseView_SceneManager :: setControlActiveStateOf( std::vector< std::string> &theKeyNameVector, bool controlCondition )
 648         {
 649                 int i, size = theKeyNameVector.size();
 650                 for( i=0; i< size; i++ )
 651                 {
 652                         setControlActiveStateOf( theKeyNameVector[i], controlCondition );
 653                 }
 654         }
 655
 656         //------------------------------------------------------------------------------------------------------------
 657         void wxVtkBaseView_SceneManager :: setControlActiveStateOf( std::map<std::string, ContourWrap_ViewControl *> * theMap, bool controlCondition )
 658         {
 659                 std::map<std::string, ContourWrap_ViewControl *>::iterator iter = theMap->begin();
 660                 int i, size = theMap->size();
 661                 for( i=0; i< size; i++ )
 662                 {
 663                         removeFromScene( iter->second, false, controlCondition );
 664                         iter++;
 665                 }
 666         }
 667
 668         //------------------------------------------------------------------------------------------------------------
 669         //  Private methods
 670         //------------------------------------------------------------------------------------------------------------
 671
 672         //------------------------------------------------------------------------------------------------------------
 673         // Creational and initialization methods
 674         //------------------------------------------------------------------------------------------------------------
 675
 676         //------------------------------------------------------------------------------------------------------------
 677         // Inherited Methods
 678         //------------------------------------------------------------------------------------------------------------
 679
 680         bool  wxVtkBaseView_SceneManager :: isCtrlPressed()
 681         {
 682                 return _ctrlKey;
 683         }
 684         bool  wxVtkBaseView_SceneManager :: isShiftPressed()
 685         {
 686                 return _shiftKey;
 687         }
 688         char  wxVtkBaseView_SceneManager :: getLastKeyCode()
 689         {
 690                 return _lastKeyCode;
 691         }
 692         bool  wxVtkBaseView_SceneManager :: OnChar()
 693         {
 694
 695                 _ctrlKey = _vtkInteractorStyleBaseView->GetInteractor()->GetControlKey() == 1;
 696                 _shiftKey = _vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey() == 1;
 697
 698                 _lastKeyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
 699
 700                 wxCommandEvent cevent( wxEVT_COMMAND_BUTTON_CLICKED );
 701                 _eventHandler->ProcessEvent( cevent );
 702
 703
 704                 /*if( _eventHandler!=NULL )
 705                 {
 706                         char * toolCommand = NULL;
 707
 708                         if ( _lastKeyCode == 3 && ctrlKey ) //'C' || 'c'
 709                         {
 710                                 toolCommand = &(COPY_TOOL);
 711                         }
 712                         else if(  _lastKeyCode == 22 && ctrlKey ) //'V' || 'v'
 713                         {
 714                                 toolCommand = &(PASTE_TOOL);
 715                         }
 716                         else if(  _lastKeyCode == 8 || (_lastKeyCode==127) ) // Delete
 717                         {
 718                                 toolCommand = &(DELETE_KEY);
 719                         }
 720                         else if(  _lastKeyCode == 14 && ctrlKey ) //'N' || 'n'
 721                         {
 722                                 toolCommand = &(CREATE_CONTOUR_KEY);
 723                         }
 724                         else if(  _lastKeyCode == 15 && ctrlKey ) //'O' || 'o'
 725                         {
 726                                 toolCommand = &(OPEN_TOOL);
 727                         }
 728                         else if(  _lastKeyCode == 19 && ctrlKey ) //'S' || 's'
 729                         {
 730                                 toolCommand = &(SAVE_KEY);
 731                         }
 732
 733                         if ( toolCommand!=NULL )
 734                         {
 735                                 currentkey = toolCommand;
 736                                 wxCommandEvent cevent( wxEVT_COMMAND_BUTTON_CLICKED );
 737                                 cevent.SetClientData( (void *) toolCommand);
 738                                 _eventHandler->ProcessEvent( cevent );
 739                         }
 740                 }*/
 741
 742
 743         //      long int endtime = clock();
 744
 745                 return true;
 746         }
 747         //------------------------------------------------------------------------------------------------------------
 748
 749         bool  wxVtkBaseView_SceneManager :: OnMouseMove()
 750         {
 751
 752                 bool condition = true;
 753                 int X,Y;
 754                 wxVTKRenderWindowInteractor *_wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
 755                 _wxVTKiren->GetEventPosition( X , Y );
 756
 757                 bool ctrlKey = _vtkInteractorStyleBaseView->GetInteractor()->GetControlKey() == 1;
 758 //???           bool shiftKey = _vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey() == 1;
 759
 760                 if( _waiting && !ctrlKey )
 761                 {
 762                         sendEnvent( wxEVT_CHANGED_DEEP, "Update");
 763                         //toca ver como decirle al viewer que no se mueva mientras no se este esperando que se pueda mover
 764                 }
 765
 766                 if ( !_creatingROI && !_creatingMULT_ROI )
 767                 {
 768
 769                         /*if( ctrlKey || shiftKey )
 770                         {
 771
 772                         }
 773                         else
 774                         {
 775                                 _toIncludeAtInteractionGroup = false;
 776                         }*/
 777
 778                         bool preserveState = _lastInteraction!=NULL? _lastInteraction->getViewer()->GetSelected() : false;
 779                         std::string preservingName = preserveState ? _lastInteractionName : "";
 780
 781                         std::map<std::string, ContourWrap_ViewControl *>::iterator iter = _sceneContours_ViewControl->begin();
 782                         int i, size = _sceneContours_ViewControl->size();
 783                         bool foundOne = false;
 784
 785                         manualContourBaseControler      * control       = _lastInteraction != NULL ? _lastInteraction->getControler() : NULL;
 786                         manualViewBaseContour           * viewer        = NULL;
 787
 788
 789                         bool singleMoving = true;
 790                         int selectionSize = _workingGroup->size();
 791                         if( selectionSize > 1 )
 792                         {
 793                                 //Multiple moving
 794
 795 //EED???                                bool ckecking = false;
 796                                 for( i =0; i<size ; i++ )
 797                                 {
 798                                         control = iter->second->getControler();
 799                                         viewer = iter->second->getViewer();
 800                                         /*ckecking = */control->SetActive( true );
 801                                 }
 802                                 if (_lastInteraction != NULL)
 803                                 {
 804                                         singleMoving = !_lastInteraction->getViewer()->GetSelected();
 805
 806                                 }
 807                                 if( !singleMoving )
 808                                 {
 809                                         size = selectionSize;
 810                                         iter = _workingGroup->begin();
 811                                 }
 812                         }
 813                         else
 814                         {
 815
 816                                 _toIncludeAtInteractionGroup = false;
 817                         }
 818
 819                         if( ((_lastInteraction != NULL && !control->IsEditable() && !control->IsMoving() ) || _lastInteraction==NULL ))
 820                         {
 821
 822                                 _lastInteraction=NULL;
 823                                 for( i =0; i<size ; i++ )
 824                                 {
 825                                         control = iter->second->getControler();
 826                                         viewer = iter->second->getViewer();
 827 //                                      _wxVtk_BaseView->GetInteractorStyleBaseView()->AddInteractorStyleMaracas( control );
 828                                         control->SetActive( true );
 829
 830                                         foundOne = control->OnMouseMove();
 831                                         foundOne &= viewer->GetPosibleSelected();
 832
 833                                         if ( !foundOne && singleMoving )
 834                                         {
 835                                                 control->SetActive( false );
 836 //                                              _wxVtk_BaseView->GetInteractorStyleBaseView()->RemoveInteractorStyleMaracas( control );
 837                                                 control->SetPosibleToMove( false );
 838                                         }
 839                                         else
 840                                         {
 841                                                 if( _toIncludeAtInteractionGroup && preserveState && _lastInteractionName.compare( preservingName)==0 )
 842                                                 {
 843                                                         _lastInteraction->getControler()->SetActive( true );
 844                                                 }
 845
 846                                                 _lastInteraction                = iter->second;
 847                                                 _lastInteractionName    = iter->first;
 848
 849                                                 viewer->UpdateColorActor();
 850                                                 control->SetPosibleToMove( true );
 851                                                 // viewer->AddCompleteContourActor();
 852                                         }
 853                                         iter++;
 854                                 }
 855                                 control = NULL;
 856                                 viewer = NULL;
 857                         }
 858                 }
 859                 return condition;
 860         }
 861
 862
 863
 864
 865
 866         //------------------------------------------------------------------------------------------------------------
 867         bool  wxVtkBaseView_SceneManager :: OnLeftButtonDown()
 868         {
 869
 870
 871
 872 //EED???                char aa = _vtkInteractorStyleBaseView->GetInteractor()->GetKeyCode();
 873                 bool condition = false;
 874                 //vtkCommand * theComand = _wxVtk_BaseView ->GetInteractorStyleBaseView()->GetCommand(
 875 //EED???                vtkRenderWindowInteractor               * vtkRWInteractor1      = _wxVtk_BaseView ->GetWxVTKRenderWindowInteractor();
 876 //EED???                wxVTKRenderWindowInteractor             * vtkRWInteractor2      = _wxVtk_BaseView ->GetWxVTKRenderWindowInteractor();//GetInteractorStyleBaseView()->GetInteractor();
 877 //EED??         wxVTKRenderWindowInteractorPlus * vtkRWInteractor3      = (wxVTKRenderWindowInteractorPlus*)_wxVtk_BaseView ->GetWxVTKRenderWindowInteractor();//GetInteractorStyleBaseView()->GetInteractor();
 878                 vtkRenderWindowInteractor               * vtkRWInteractor       = _vtkInteractorStyleBaseView->GetInteractor();
 879
 880                 bool ctrlKey = vtkRWInteractor->GetControlKey() == 1;
 881                 bool shftKey = vtkRWInteractor->GetShiftKey() == 1;
 882                 _toIncludeAtInteractionGroup = false;
 883                 if ( ctrlKey || shftKey )
 884                 {
 885                         _toIncludeAtInteractionGroup = true;
 886                 }
 887                 else
 888                 {
 889                         if( _lastInteraction!=NULL && !_toIncludeAtInteractionGroup )
 890                         {
 891                                 if( _lastInteraction->getControler()->GetIfCompleteCreation() && !_lastInteraction->getControler()->IsEditable()&& !_lastInteraction->getViewer()->GetPosibleSelected() )
 892                                 {
 893                                         _lastInteraction->getControler()->SetEditable( false );
 894                                         _lastInteraction->getControler()->SetActive( false );
 895                                         _lastInteraction->getControler()->SetPosibleToMove( false );
 896                                         _lastInteraction->getViewer()->Refresh();
 897                                         _lastInteraction=NULL;
 898                                 }
 899                         }
 900                 }
 901
 902
 903
 904                 if( !_toIncludeAtInteractionGroup )
 905                 {
 906                         _workingGroup->clear();
 907                 }
 908
 909                 if( _lastInteraction!=NULL )
 910                 {
 911                         _toIncludeAtInteractionGroup = !_lastInteraction->getControler()->IsEditable();
 912                         _toIncludeAtInteractionGroup &= _lastInteraction->getViewer()->GetSelected();
 913                         _workingGroup->insert(std::pair <std::string, ContourWrap_ViewControl *> ( _lastInteractionName, _lastInteraction ));
 914                 }
 915                 if( _creatingMULT_ROI && !_creatingROI && !ctrlKey  && !shftKey )
 916                 {
 917                         _creatingROI = true;
 918                         //setControlActiveStateOf( _contours_ViewControl, false );
 919                         sendEnvent( wxEVT_START_CREATE_ROI, "");
 920                 }
 921                 condition = true;
 922
 923 // FILE *ff = fopen("c:/temp/wxVtkBaseView_SceneManagerStadistics.txt","a+");
 924 // fprintf(ff,"EED wxVtkBaseView_SceneManager::OnLeftButtonDown() contours=%d  sceneContour=%d  workingContours=%d\n",
 925 //                                      _contours_ViewControl->size(), _sceneContours_ViewControl->size(), _workingGroup->size() );
 926 // fclose(ff);
 927
 928
 929                 return condition;
 930         }
 931
 932         //------------------------------------------------------------------------------------------------------------
 933         bool  wxVtkBaseView_SceneManager :: OnLeftButtonUp()
 934         {
 935                 bool condition = false;
 936                 condition = true;
 937
 938                 if( _drawingSelectionROI )
 939                 {
 940                         setSelection2DROIInternalOutlines();
 941                 }
 942                 return condition;
 943         }
 944         //------------------------------------------------------------------------------------------------------------
 945         bool  wxVtkBaseView_SceneManager :: OnMiddleButtonDown()
 946         {
 947                 bool condition = false;
 948                 condition = true;
 949
 950                 return condition;
 951         }
 952         //------------------------------------------------------------------------------------------------------------
 953         bool  wxVtkBaseView_SceneManager :: OnMiddleButtonUp()
 954         {
 955                 bool condition = false;
 956                 condition = true;
 957
 958                 return condition;
 959         }
 960         //------------------------------------------------------------------------------------------------------------
 961         bool  wxVtkBaseView_SceneManager :: OnRightButtonDown()
 962         {
 963                 bool condition = false;
 964 //EED???                vtkRenderWindowInteractor * vtkRWInteractor = _vtkInteractorStyleBaseView->GetInteractor();
 965 //EED???                bool ctrlKey = vtkRWInteractor->GetControlKey() == 1;
 966                 _waiting = true;
 967
 968                 condition = true;
 969
 970                 return condition;
 971         }
 972         //------------------------------------------------------------------------------------------------------------
 973         bool  wxVtkBaseView_SceneManager :: OnRightButtonUp()
 974         {
 975                 bool condition = false;
 976                 condition = true;
 977                 //setControlActiveStateOfALL( false );//************************************************
 978                 if ( _creatingMULT_ROI )
 979                 {
 980                         //setControlActiveStateOfALL( false );
 981                 }
 982                 if( _creatingROI )
 983                 {
 984                         sendEnvent( wxEVT_STOP_CREATE_ROI, "Activate");
 985                         _creatingROI = false;
 986                 }
 987                 else
 988                 {
 989                         if(_lastInteraction!=NULL && !_toIncludeAtInteractionGroup)
 990                         {
 991                                 manualContourBaseControler * control = _lastInteraction->getControler();
 992                                 //_lastInteraction->getControler()->SetPosibleToMove( false );
 993                                 control->SetActive( false );
 994                                 control->SetEditable( false );
 995                                 control->SetPosibleToMove( false );
 996 //                              _wxVtk_BaseView->GetInteractorStyleBaseView()->RemoveInteractorStyleMaracas( control );
 997                                 _lastInteraction->getViewer()->Refresh();
 998                                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
 999                         }
1000                 }
1001                 _waiting = false;
1002                 return condition;
1003         }
1004         //------------------------------------------------------------------------------------------------------------
1005
1006         bool  wxVtkBaseView_SceneManager :: OnLeftDClick()
1007         {
1008                 bool condition = false;
1009                 condition = true;
1010
1011                 return condition;
1012         }
1013         //------------------------------------------------------------------------------------------------------------
1014         bool  wxVtkBaseView_SceneManager :: OnRightDClick()
1015         {
1016                 bool condition = false;  condition = true;
1017 //EED???                vtkRenderWindowInteractor * vtkRWInteractor = _vtkInteractorStyleBaseView->GetInteractor();
1018                 /*vtkRenderWindowInteractor * vtkRWInteractor1 =*/ _vtkInteractorStyleBaseView->OnChar();
1019 //EED???                wxVTKRenderWindowInteractor * wxVtkRWInterator = _wxVtk_BaseView ->GetWxVTKRenderWindowInteractor();
1020
1021                 /*if( _waiting )
1022                 {
1023                         sendEnvent( wxEVT_START_CREATE_MULT_ROI, "Multiple");
1024                         set_creatingMULT_ROI( !_creatingMULT_ROI );
1025                         _waiting = false;
1026                 }
1027                 else
1028                         _waiting = true;*/
1029
1030                 return condition;
1031         }
1032         //------------------------------------------------------------------------------------------------------------
1033         bool  wxVtkBaseView_SceneManager :: OnMiddleDClick()
1034         {
1035                 bool condition = false;
1036                 condition = true;
1037
1038                 return condition;
1039         }
1040         //------------------------------------------------------------------------------------------------------------
1041         bool  wxVtkBaseView_SceneManager :: OnMouseWheel()
1042         {
1043                 bool condition = false;
1044                 condition = true;
1045                 return condition;
1046         }
1047         //------------------------------------------------------------------------------------------------------------
1048
1049         void wxVtkBaseView_SceneManager :: drawSelectionROI()
1050         {
1051                 _drawingSelectionROI = true;
1052                 _workingGroup->clear();
1053                 _controlerSelectionROI->CreateNewManualContour();
1054                 if (_lastInteraction!=NULL)
1055                 {
1056                         _lastInteraction->getControler()->SetEditable( false );
1057                         _lastInteraction->getControler()->SetActive( false );
1058                         _lastInteraction->getControler()->SetPosibleToMove( false );
1059                         _lastInteraction->getViewer()->Refresh();
1060                 }
1061                 std::map<std::string, ContourWrap_ViewControl *>::iterator iter = _workingGroup->begin();
1062                 int i, workSize = _workingGroup->size();
1063                 for( i=0; i< workSize; i++ )
1064                 {
1065                         manualContourBaseControler * control = iter->second->getControler();
1066                         control->SetEditable( false );
1067                         control->SetActive( false );
1068                         control->SetPosibleToMove( false );
1069                         iter->second->getViewer()->Refresh();
1070
1071                         iter++;
1072                 }
1073                 _lastInteraction = NULL;
1074                 _lastInteractionName = "";
1075
1076                 _viewerSelectionROI->AddCompleteContourActor( true );
1077                 _controlerSelectionROI->SetActive( true );
1078
1079                 _viewerSelectionROI->RefreshContour();
1080                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
1081         }
1082         //------------------------------------------------------------------------------------------------------------
1083         void wxVtkBaseView_SceneManager :: setSelection2DROIInternalOutlines( )
1084         {
1085                 _drawingSelectionROI = false;
1086                 _workingGroup->clear();
1087                 double minX,minY,maxX,maxY, minX_ROI,minY_ROI,maxX_ROI,maxY_ROI;
1088                 double minZ = -1.0;
1089                 double maxZ = -1.0;
1090                 std::map<std::string, ContourWrap_ViewControl *>::iterator iter = _sceneContours_ViewControl->begin();
1091                 int i, size = _sceneContours_ViewControl->size();
1092                 _viewerSelectionROI->GetMinMax( minX_ROI, minY_ROI, maxX_ROI, maxY_ROI );
1093                 manualViewBaseContour * viewer;
1094                 bool insideRoi = false;
1095                 for ( i=0; i<size; i++ )
1096                 {
1097                         viewer = iter->second->getViewer();
1098                         viewer->GetMinMax( minX, minY, minZ, maxX, maxY, maxZ );
1099                         insideRoi = minX >= minX_ROI && maxX <= maxX_ROI && minY_ROI && maxY <= maxY_ROI;
1100                         if ( insideRoi )
1101                         {
1102                                 viewer->SetSelected( true );
1103                                 viewer->UpdateColorActor();
1104                                 setControlActiveStateOf( iter->second, true );
1105                                 _workingGroup->insert(std::pair <std::string, ContourWrap_ViewControl *> ( iter->first, iter->second ));
1106                         }
1107                         iter++;
1108                 }
1109                 _viewerSelectionROI->RemoveCompleteContourActor( );
1110                 _controlerSelectionROI->SetActive( false );
1111         }
1112         //------------------------------------------------------------------------------------------------------------
1113         void wxVtkBaseView_SceneManager :: writeCoords( std::string method )
1114         {
1115                 FILE *ff = fopen("c:/temp/wxVtkBaseView_SceneManagerStadistics.txt","a+");
1116                 long int start = clock();
1117 #if(WIN32)
1118                 double sg = (double)(start) / (double)CLK_TCK;
1119 #else
1120                 double sg = (double)(start) / CLOCKS_PER_SEC;
1121 #endif
1122                 int tmpPx,tmpPy;
1123                 wxVTKRenderWindowInteractor *wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
1124                 wxVTKiren->GetEventPosition( tmpPx , tmpPy );
1125                 fprintf(ff,"::%s (x,y) = (%i, %i) t(sg): %f\n  \n",method.c_str(), tmpPx, tmpPy, sg);
1126                 fclose(ff);
1127         }
1128
1129
1130         //------------------------------------------------------------------------------------------------------------
1131         void wxVtkBaseView_SceneManager::SaveThingName(FILE *ff, std::string nameThing)
1132         {
1133                 std::map <std::string, ContourWrap_ViewControl *>::iterator iter = _contours_ViewControl->find(nameThing);
1134                 manualViewBaseContour           * cViewer;
1135                 manualContourBaseControler      * cControler;
1136                 ContourWrap_ViewControl *conwraviwcont=iter->second;
1137
1138                 cViewer         = conwraviwcont->getViewer();
1139                 cViewer->Save(ff);
1140
1141                 cControler      = conwraviwcont->getControler();
1142 //              cControler->Save(ff);
1143
1144 //              cModel          = cControler->GetManualContourModel();
1145 //              cModel->Save(ff);
1146         }
1147
1148
1149         //------------------------------------------------------------------------------------------------------------
1150         void wxVtkBaseView_SceneManager::GetPointsOfActualContour( std::vector<double> *vecX, std::vector<double> *vecY, std::vector<double> *vecZ )
1151         {
1152                 std::vector<std::string> currentSelection = this->getSelectedObjects();
1153                 if (currentSelection.size()>=1){
1154
1155                         manualContourBaseControler *cControler  = this->getControlerOf( currentSelection[0] );
1156                         manualBaseModel *cModel                         = cControler->GetManualContourModel();
1157                         int i,size = cModel->GetNumberOfPointsSpline();
1158                         double x,y,z;
1159                         for (i=0; i<size; i++)
1160                         {
1161                                 cModel->GetSpline_i_Point(i, &x, &y, &z);
1162                                 vecX->push_back(x);
1163                                 vecY->push_back(y);
1164                                 vecZ->push_back(z);
1165                         }
1166                 }
1167         }
1168
1169         //------------------------------------------------------------------------------------------------------------
1170         vtkImageData *wxVtkBaseView_SceneManager::GetImageData()
1171         {
1172                 wxVtk2DBaseView *wxvtk2dbaseview =(wxVtk2DBaseView*)_wxVtk_BaseView;
1173                 return wxvtk2dbaseview->GetVtkBaseData()->GetImageData();
1174         }
1175
1176         //------------------------------------------------------------------------------------------------------------
1177         int wxVtkBaseView_SceneManager::GetImageDataSizeZ()
1178         {
1179                         int ext[6];
1180                         vtkImageData    *imagedata      = GetImageData();
1181                         imagedata->GetExtent(ext);
1182                         int sizeZ = ext[5]-ext[4]+1;
1183
1184 //EED OJO   Machete
1185 //                      sizeZ = sizeZ-1;
1186
1187                         return sizeZ;
1188         }
1189
1190         //------------------------------------------------------------------------------------------------------------
1191         void wxVtkBaseView_SceneManager::GetImageDataRange( double *range )
1192         {
1193                 int ext[6];
1194                 vtkImageData    *imagedata      = GetImageData();
1195                 imagedata->GetExtent(ext);
1196                 int sizeX       = ext[1]-ext[0]+1;
1197                 int sizeY       = ext[3]-ext[2]+1;
1198                 int sizeZ       = GetImageDataSizeZ();
1199                 int sizeXYZ = sizeX*sizeY*sizeZ;
1200                 long int i;
1201                 range[0]=9999999;
1202                 range[1]=-9999999;
1203                 unsigned short *p = (unsigned short *)imagedata->GetScalarPointer(0,0,0);
1204                 for (i=0;i<sizeXYZ;i++)
1205                 {
1206                         if ( p[i]<range[0] ) range[0]=p[i];
1207                         if ( p[i]>range[1] ) range[1]=p[i];
1208                 }
1209         }
1210
1211         //------------------------------------------------------------------------------------------------------------
1212         void wxVtkBaseView_SceneManager::SetWidthContour(double width)
1213         {
1214                 _widthOfContour         = width;
1215                 _widthOfControlPoint    = _widthOfContour*_widthOfContour/2;
1216                 manualViewBaseContour           *cViewer;
1217                 ContourWrap_ViewControl         *conwraviwcont;
1218                 std::map <std::string, ContourWrap_ViewControl *>::iterator iter;
1219
1220                 if (_contours_ViewControl!=NULL)
1221                 {
1222                         for (iter=_contours_ViewControl->begin(); iter!=_contours_ViewControl->end(); iter++ )
1223                         {
1224                                 conwraviwcont           = iter->second;
1225                                 cViewer                 = conwraviwcont->getViewer();
1226                                 cViewer->SetShowText( false );                                  // EED 28Mars2011
1227                                 cViewer->SetWidthLine( _widthOfContour );
1228                                 cViewer->SetRange( _widthOfControlPoint );
1229                         } // for
1230                 } // if
1231         }
1232
1233         bool wxVtkBaseView_SceneManager::isEditableCControler(std::string theKeyName){
1234
1235                 ContourWrap_ViewControl* ccon = getContourWrap_ViewControlOf(theKeyName);
1236                 if(ccon != NULL ){
1237                         manualContourBaseControler* cControler = ccon->getControler();
1238                         if(cControler != NULL && cControler->IsEditable() == false){
1239                                 return true;
1240                         }
1241                 }
1242                 return false;
1243         }
1244
1245         void wxVtkBaseView_SceneManager::deleteCViewerCControler(std::string theKeyName){
1246
1247
1248                 ContourWrap_ViewControl* ccon = getContourWrap_ViewControlOf(theKeyName);
1249
1250                 manualViewBaseContour       * cViewer = ccon->getViewer();
1251                 manualContourBaseControler  * cControler = ccon->getControler();
1252
1253                 removeFromScene(theKeyName);
1254                 removeWrap(theKeyName);
1255
1256                 delete cViewer;
1257                 delete cControler;
1258         }
1259
1260
1261