lib/maracasVisuLib/src/interface/wxWindows/manualContourContainer.cxx

   1
   2 /*=========================================================================
   3
   4  Program:   wxMaracas
   5  Module:    $RCSfile: manualContourContainer.cxx,v $
   6  Language:  C++
   7  Date:      $Date: 2008/10/31 16:32:09 $
   8  Version:   $Revision: 1.1 $
   9
  10   Copyright: (c) 2002, 2003
  11   License:
  12
  13    This software is distributed WITHOUT ANY WARRANTY; without even
  14    the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15    PURPOSE.  See the above copyright notice for more information.
  16
  17 =========================================================================*/
  18
  19 #include "manualContourContainer.h"
  20
  21 //////////////////////////////////////////////////////////////////////
  22 // Constructor
  23 //////////////////////////////////////////////////////////////////////
  24
  25 //--------------------------------------------------------
  26 manualContourContainer::manualContourContainer()
  27 {
  28
  29         _manContourControlWall = NULL;
  30         _mContourModelWall = NULL;
  31         _mViewContourWall = NULL;
  32
  33
  34         _manContourControlLumen = NULL;
  35         _mContourModelLumen = NULL;
  36         _mViewContourLumen = NULL;
  37 }
  38
  39
  40
  41
  42 //--------------------------------------------------------
  43 manualContourContainer::~manualContourContainer()
  44 {
  45
  46 }
  47
  48 //--------------------------------------------------------
  49 manualContourControler* manualContourContainer::getWallController()
  50 {
  51         return _manContourControlWall;
  52 }
  53
  54 //--------------------------------------------------------
  55 manualContourControler* manualContourContainer::getLumenController()
  56 {
  57         return _manContourControlLumen;
  58 }
  59
  60 //--------------------------------------------------------
  61 manualContourControler* manualContourContainer::getCalcController(int i)
  62 {
  63         return _manContourControlCalc[i];
  64 }
  65
  66 //--------------------------------------------------------
  67 manualContourControler* manualContourContainer::getHypoController(int i)
  68 {
  69         return _manContourControlHypo[i];
  70 }
  71
  72 //--------------------------------------------------------
  73 int manualContourContainer::addCalcificationContour(wxVtk2DBaseView     *_imageviewer2D_1)
  74 {
  75         int tam = 0;
  76         manualContourControler *tempC   = new manualContourControler();
  77         manualContourModel *tempM               = new manualContourModel();
  78         manualViewContour *tempV                = new manualViewContour();
  79 //EED 28Dic2006
  80         tempV->SetRange((int)(0.6) );
  81
  82         _manContourControlCalc.push_back(tempC);
  83         _mContourModelCalc.push_back(tempM);
  84         _mViewContourCalc.push_back(tempV);
  85
  86         tam = _mViewContourCalc.size() - 1;
  87
  88         _mViewContourCalc[tam]->SetModel( _mContourModelCalc[tam] );
  89         _mViewContourCalc[tam]->SetWxVtkBaseView( _imageviewer2D_1 );
  90 //      _mViewContourCalc[tam]->SetRange( 2 );
  91         _mViewContourCalc[tam]->SetZ( 1000 );
  92         _mViewContourCalc[tam]->SetColorNormalContour(0, 0.5, 0);
  93         _mViewContourCalc[tam]->SetColorEditContour(1, 1, 0.33);
  94         _manContourControlCalc[tam]->SetModelView( _mContourModelCalc[tam] , _mViewContourCalc[tam] );
  95         _manContourControlCalc[tam]->CreateNewManualContour();
  96         _manContourControlCalc[tam]->SetActive(false);
  97         _mViewContourCalc[tam]->RefreshContour();
  98
  99         return tam;
 100 }
 101 //--------------------------------------------------------
 102 int manualContourContainer::addHypodenseContour(wxVtk2DBaseView *_imageviewer2D_1)
 103 {
 104         int tam = 0;
 105         manualContourControler *tempC = new manualContourControler();
 106         manualContourModel *tempM = new manualContourModel();
 107         manualViewContour *tempV = new manualViewContour();
 108 //EED 28Dic2006
 109         tempV->SetRange( (int)(0.6) );
 110
 111         _manContourControlHypo.push_back(tempC);
 112         _mContourModelHypo.push_back(tempM);
 113         _mViewContourHypo.push_back(tempV);
 114
 115         tam = _mViewContourHypo.size() - 1;
 116         _mViewContourHypo[tam]->SetModel( _mContourModelHypo[tam] );
 117         _mViewContourHypo[tam]->SetWxVtkBaseView( _imageviewer2D_1 );
 118 //      _mViewContourHypo[tam]->SetRange( 2 );
 119         _mViewContourHypo[tam]->SetZ( 1000 );
 120         _mViewContourHypo[tam]->SetColorNormalContour(0, 0.5, 0.5);
 121         _mViewContourHypo[tam]->SetColorEditContour(1, 1, 0.33);
 122         _manContourControlHypo[tam]->SetModelView( _mContourModelHypo[tam] , _mViewContourHypo[tam] );
 123         _manContourControlHypo[tam]->CreateNewManualContour();
 124         _manContourControlHypo[tam]->SetActive(false);
 125         _mViewContourHypo[tam]->RefreshContour();
 126
 127         return tam;
 128 }
 129
 130 //--------------------------------------------------------
 131 void manualContourContainer::setWallVisibility(bool visible)
 132 {
 133         if (_mViewContourWall != NULL)
 134         {
 135                 _mViewContourWall->SetVisible( visible );
 136                 _mViewContourWall->Refresh();
 137         }
 138
 139 }
 140
 141 //--------------------------------------------------------
 142 void manualContourContainer::setLumenVisibility(bool visible)
 143 {
 144         if (_mViewContourLumen != NULL)
 145         {
 146                 _mViewContourLumen->SetVisible( visible );
 147                 _mViewContourLumen->Refresh();
 148         }
 149
 150 }
 151
 152 //--------------------------------------------------------
 153 void manualContourContainer::setCalcVisibility(bool visible)
 154 {
 155         int i;
 156         for (i = 0; i < (int)_mViewContourCalc.size(); i++)
 157         {
 158                 _mViewContourCalc[i]->SetVisible( visible );
 159                 _mViewContourCalc[i]->Refresh();
 160         }
 161
 162 }
 163
 164 //--------------------------------------------------------
 165 void manualContourContainer::setHypoVisibility(bool visible)
 166 {
 167         int i;
 168         for (i = 0; i < (int)_mViewContourHypo.size(); i++)
 169         {
 170                 _mViewContourHypo[i]->SetVisible( visible );
 171                 _mViewContourHypo[i]->Refresh();
 172         }
 173 }
 174
 175 //--------------------------------------------------------
 176 void manualContourContainer::setWallActive()
 177 {
 178         _manContourControlWall -> SetActive(true);
 179
 180         if (_manContourControlLumen != NULL)
 181         {
 182                 _manContourControlLumen -> SetActive(false);
 183         }
 184
 185         int i;
 186         for (i = 0; i < (int)_manContourControlCalc.size(); i++)
 187         {
 188                 _manContourControlCalc[i] -> SetActive(false);
 189         }
 190         int j;
 191         for (j = 0; j < (int)_manContourControlHypo.size(); j++)
 192         {
 193                 _manContourControlHypo[j] -> SetActive(false);
 194         }
 195 }
 196
 197 //--------------------------------------------------------
 198 void manualContourContainer::setLumenActive()
 199 {
 200         if (_manContourControlWall != NULL)
 201         {
 202                 _manContourControlWall -> SetActive(false);
 203         }
 204         _manContourControlLumen -> SetActive(true);
 205
 206         int i;
 207         for (i = 0; i < (int)_manContourControlCalc.size(); i++)
 208         {
 209                 _manContourControlCalc[i] -> SetActive(false);
 210         }
 211
 212         int j;
 213         for (j = 0; j < (int)_manContourControlHypo.size(); j++)
 214         {
 215                 _manContourControlHypo[j] -> SetActive(false);
 216         }
 217
 218
 219 }
 220
 221 //--------------------------------------------------------
 222 void manualContourContainer::setCalcActive()
 223 {
 224         if (_manContourControlWall != NULL)
 225         {
 226                 _manContourControlWall -> SetActive(false);
 227         }
 228         if (_manContourControlLumen != NULL)
 229         {
 230                 _manContourControlLumen -> SetActive(false);
 231         }
 232         int i;
 233         for (i = 0; i < (int)_manContourControlHypo.size(); i++)
 234         {
 235                 _manContourControlHypo[i] -> SetActive(false);
 236         }
 237         int j;
 238         for (j = 0; j < (int)_manContourControlCalc.size(); j++)
 239         {
 240                 _manContourControlCalc[j] -> SetActive(true);
 241         }
 242 }
 243
 244 //--------------------------------------------------------
 245 void manualContourContainer::setHypoActive()
 246 {
 247         if (_manContourControlWall != NULL)
 248         {
 249                 _manContourControlWall -> SetActive(false);
 250         }
 251
 252         if (_manContourControlLumen != NULL)
 253         {
 254                 _manContourControlLumen -> SetActive(false);
 255         }
 256
 257         int i;
 258         for (i = 0; i < (int)_manContourControlCalc.size(); i++)
 259         {
 260                 _manContourControlCalc[i] -> SetActive(false);
 261         }
 262
 263         int j;
 264         for (j = 0; j < (int)_manContourControlHypo.size(); j++)
 265         {
 266                 _manContourControlHypo[j] -> SetActive(true);
 267         }
 268 }
 269
 270 //--------------------------------------------------------
 271 void manualContourContainer::setCalcContourActive(int i)
 272 {
 273         if (_manContourControlWall != NULL)
 274         {
 275                 _manContourControlWall -> SetActive(false);
 276         }
 277         if (_manContourControlLumen != NULL)
 278         {
 279                 _manContourControlLumen -> SetActive(false);
 280         }
 281
 282         int j;
 283         for (j = 0; j < (int)_manContourControlHypo.size(); j++)
 284         {
 285                 _manContourControlHypo[j] -> SetActive(false);
 286         }
 287
 288         _manContourControlCalc[i] -> SetActive(true);
 289 }
 290
 291 //--------------------------------------------------------
 292 void manualContourContainer::setHypoContourActive(int i)
 293 {
 294         if (_manContourControlWall != NULL)
 295         {
 296                 _manContourControlWall -> SetActive(false);
 297         }
 298         if (_manContourControlLumen != NULL)
 299         {
 300                 _manContourControlLumen -> SetActive(false);
 301         }
 302
 303         int j;
 304         for (j = 0; j < (int)_manContourControlCalc.size(); j++)
 305         {
 306                 _manContourControlCalc[j] -> SetActive(true);
 307         }
 308
 309         _manContourControlHypo[i] -> SetActive(true);
 310 }
 311
 312 //--------------------------------------------------------
 313 int  manualContourContainer::getNumberOfCalcContours()
 314 {
 315         return _manContourControlCalc.size();
 316 }
 317
 318 //--------------------------------------------------------
 319 int  manualContourContainer::getNumberOfHypoContours()
 320 {
 321         return _manContourControlHypo.size();
 322 }
 323
 324 //--------------------------------------------------------
 325 void manualContourContainer::inactivate()
 326 {
 327         if (_manContourControlWall != NULL)
 328         {
 329                 _manContourControlWall -> SetActive(false);
 330         }
 331         if (_manContourControlLumen != NULL)
 332         {
 333                 _manContourControlLumen -> SetActive(false);
 334         }
 335
 336         int i;
 337         for (i = 0; i < (int)_manContourControlCalc.size(); i++)
 338         {
 339                 _manContourControlCalc[i] -> SetActive(false);
 340         }
 341         int j;
 342         for (j = 0; j < (int)_manContourControlHypo.size(); j++)
 343         {
 344                 _manContourControlHypo[j] -> SetActive(false);
 345         }
 346 }
 347
 348 //--------------------------------------------------------
 349 int manualContourContainer::getNumberOfWallContourPoints()
 350 {
 351         return _manContourControlWall->GetNumberOfPointsSplineManualContour();
 352 }
 353
 354 //--------------------------------------------------------
 355 int manualContourContainer::getNumberOfLumenContourPoints()
 356 {
 357         return _manContourControlLumen->GetNumberOfPointsSplineManualContour();
 358 }
 359
 360 //--------------------------------------------------------
 361 int manualContourContainer::getNumberOfCalcContourPoints(int i)
 362 {
 363         return _manContourControlCalc[i]->GetNumberOfPointsSplineManualContour();
 364 }
 365
 366 //--------------------------------------------------------
 367 int manualContourContainer::getNumberOfHypoContourPoints(int i)
 368 {
 369         return _manContourControlHypo[i]->GetNumberOfPointsSplineManualContour();
 370 }
 371
 372 //--------------------------------------------------------
 373 double* manualContourContainer::getXVectorWallPoints()
 374 {
 375         return _manContourControlWall->GetVectorPointsXManualContour();
 376 }
 377
 378 //--------------------------------------------------------
 379 double* manualContourContainer::getXVectorLumenPoints()
 380 {
 381         return _manContourControlLumen->GetVectorPointsXManualContour();
 382 }
 383
 384 //--------------------------------------------------------
 385 double* manualContourContainer::getXVectorCalcPoints(int i)
 386 {
 387         return _manContourControlCalc[i]->GetVectorPointsXManualContour();
 388 }
 389
 390 //--------------------------------------------------------
 391 double* manualContourContainer::getXVectorHypoPoints(int i)
 392 {
 393         return _manContourControlHypo[i]->GetVectorPointsXManualContour();
 394 }
 395
 396 //--------------------------------------------------------
 397 double* manualContourContainer::getYVectorWallPoints()
 398 {
 399         return _manContourControlWall->GetVectorPointsYManualContour();
 400 }
 401
 402 //--------------------------------------------------------
 403 double* manualContourContainer::getYVectorLumenPoints()
 404 {
 405         return _manContourControlLumen->GetVectorPointsYManualContour();
 406 }
 407
 408 //--------------------------------------------------------
 409 double* manualContourContainer::getYVectorCalcPoints(int i)
 410 {
 411         return _manContourControlCalc[i]->GetVectorPointsYManualContour();
 412 }
 413
 414 //--------------------------------------------------------
 415 double* manualContourContainer::getYVectorHypoPoints(int i)
 416 {
 417         return _manContourControlHypo[i]->GetVectorPointsYManualContour();
 418 }
 419
 420 //--------------------------------------------------------
 421 void manualContourContainer::clear()
 422 {
 423         clearWall();
 424         clearLumen();
 425         clearCalc();
 426         clearHypo();
 427 }
 428
 429 //--------------------------------------------------------
 430 void manualContourContainer::clearWall()
 431 {
 432         if (_mViewContourWall != NULL)
 433         {
 434                 _mViewContourWall->ClearContour();
 435         }
 436
 437 }
 438
 439 //--------------------------------------------------------
 440 void manualContourContainer::clearLumen()
 441 {
 442         if (_mViewContourLumen != NULL)
 443         {
 444                 _mViewContourLumen->ClearContour();
 445         }
 446
 447 }
 448
 449 //--------------------------------------------------------
 450 void manualContourContainer::clearCalc()
 451 {
 452         int i;
 453         for (i = 0; i < (int)_mViewContourCalc.size(); i++)
 454         {
 455                 _mViewContourCalc[i] -> ClearContour();
 456         }
 457 }
 458
 459 //--------------------------------------------------------
 460 void manualContourContainer::clearHypo()
 461 {
 462         int j;
 463         for (j = 0; j < (int)_mViewContourHypo.size(); j++)
 464         {
 465                 _mViewContourHypo[j] -> ClearContour();
 466         }
 467 }
 468
 469
 470 //--------------------------------------------------------
 471 void manualContourContainer::refreshWall(wxVtk2DBaseView        *_imageviewer2D_1)
 472 {
 473
 474         if (_mContourModelWall == NULL)
 475         {
 476                 return;
 477         }
 478
 479         int size = _mContourModelWall->GetSizeLstPoints();
 480         std::vector<manualPoint *> points;
 481
 482         int i;
 483         for (i = 0; i < size; i++)
 484         {
 485                 points.push_back(_mContourModelWall->GetManualPoint(i));
 486         }
 487
 488         _mContourModelWall->DeleteAllPoints();
 489         _manContourControlWall->CreateNewManualContour();
 490         _manContourControlWall->SetActive(false);
 491         _mViewContourWall->RefreshContour();
 492         _imageviewer2D_1->GetInteractorStyleBaseView()->AddInteractorStyleMaracas(
 493                                         _manContourControlWall );
 494         for (i = 0; i < size; i++)
 495         {
 496                 manualPoint* mp = points[i];
 497                 int     id              = _manContourControlWall->GetManualContourModel()->AddPoint(mp->GetX(),mp->GetY(),mp->GetZ());
 498                 _manContourControlWall->GetManualViewBaseContour()->AddPoint();
 499                 _manContourControlWall->GetManualViewBaseContour()->Refresh();
 500         }
 501
 502
 503 }
 504
 505 //--------------------------------------------------------
 506 void manualContourContainer::refreshLumen(wxVtk2DBaseView       *_imageviewer2D_1)
 507 {
 508         if (_mContourModelLumen == NULL)
 509         {
 510                 return;
 511         }
 512         int size = _mContourModelLumen->GetSizeLstPoints();
 513         std::vector<manualPoint *> points;
 514
 515         int i;
 516         for (i = 0; i < size; i++)
 517         {
 518                 points.push_back(_mContourModelLumen->GetManualPoint(i));
 519         }
 520
 521         _mContourModelLumen->DeleteAllPoints();
 522         _manContourControlLumen->CreateNewManualContour();
 523         _manContourControlLumen->SetActive(false);
 524         _mViewContourLumen->RefreshContour();
 525         _imageviewer2D_1->GetInteractorStyleBaseView()->AddInteractorStyleMaracas(
 526                                         _manContourControlLumen );
 527         for (i = 0; i < size; i++)
 528         {
 529                 manualPoint* mp = points[i];
 530                 int     id              = _manContourControlLumen->GetManualContourModel()->AddPoint(mp->GetX(),mp->GetY(),mp->GetZ());
 531                 _manContourControlLumen->GetManualViewBaseContour()->AddPoint();
 532                 _manContourControlLumen->GetManualViewBaseContour()->Refresh();
 533         }
 534 }
 535
 536 //--------------------------------------------------------
 537 void manualContourContainer::refreshCalc(int j,wxVtk2DBaseView  *_imageviewer2D_1)
 538 {
 539
 540         int size = _mContourModelCalc[j]->GetSizeLstPoints();
 541         std::vector<manualPoint *> points;
 542
 543         int i;
 544         for (i = 0; i < size; i++)
 545         {
 546                 points.push_back(_mContourModelCalc[j]->GetManualPoint(i));
 547         }
 548
 549         _mContourModelCalc[j]->DeleteAllPoints();
 550         _manContourControlCalc[j]->CreateNewManualContour();
 551         _manContourControlCalc[j]->SetActive(false);
 552         _mViewContourCalc[j]->RefreshContour();
 553         _imageviewer2D_1->GetInteractorStyleBaseView()->AddInteractorStyleMaracas(
 554                                         _manContourControlCalc[j] );
 555         for (i = 0; i < size; i++)
 556         {
 557                 manualPoint* mp = points[i];
 558                 int     id              = _manContourControlCalc[j]->GetManualContourModel()->AddPoint(mp->GetX(),mp->GetY(),mp->GetZ());
 559                 _manContourControlCalc[j]->GetManualViewBaseContour()->AddPoint();
 560                 _manContourControlCalc[j]->GetManualViewBaseContour()->Refresh();
 561         }
 562
 563
 564
 565 }
 566
 567 //--------------------------------------------------------
 568 void manualContourContainer::refreshHypo(int j,wxVtk2DBaseView  *_imageviewer2D_1)
 569 {
 570
 571         int size = _mContourModelHypo[j]->GetSizeLstPoints();
 572         std::vector<manualPoint *> points;
 573
 574         int i;
 575         for (i = 0; i < size; i++)
 576         {
 577                 points.push_back(_mContourModelHypo[j]->GetManualPoint(i));
 578         }
 579
 580         _mContourModelHypo[j]->DeleteAllPoints();
 581         _manContourControlHypo[j]->CreateNewManualContour();
 582         _manContourControlHypo[j]->SetActive(false);
 583         _mViewContourHypo[j]->RefreshContour();
 584         _imageviewer2D_1->GetInteractorStyleBaseView()->AddInteractorStyleMaracas(
 585                                         _manContourControlHypo[j] );
 586         for (i = 0; i < size; i++)
 587         {
 588                 manualPoint* mp = points[i];
 589                 int     id              = _manContourControlHypo[j]->GetManualContourModel()->AddPoint(mp->GetX(),mp->GetY(),mp->GetZ());
 590                 _manContourControlHypo[j]->GetManualViewBaseContour()->AddPoint();
 591                 _manContourControlHypo[j]->GetManualViewBaseContour()->Refresh();
 592         }
 593 }
 594
 595 //--------------------------------------------------------
 596 void manualContourContainer::restartWallContour(wxVtk2DBaseView *_imageviewer2D_1)
 597 {
 598         if (_manContourControlWall == NULL)
 599         {
 600                 return;
 601         }
 602         delete _manContourControlWall;
 603         delete _mContourModelWall;
 604         delete _mViewContourWall;
 605
 606         _manContourControlWall  = new manualContourControler();
 607         _mContourModelWall              = new manualContourModel();
 608         _mViewContourWall                       = new manualViewContour();
 609 //EED 28Dic2006
 610         _mViewContourWall->SetRange( (int)(0.6) );
 611
 612         _mViewContourWall->SetModel( _mContourModelWall );
 613         _mViewContourWall->SetWxVtkBaseView( _imageviewer2D_1 );
 614 //      _mViewContourWall->SetRange( 2 );
 615         _mViewContourWall->SetZ( 1000 );
 616         _mViewContourWall->SetColorNormalContour(0.2, 0.6, 1);
 617         _mViewContourWall->SetColorEditContour(1, 1, 0.33);
 618
 619         _manContourControlWall->SetModelView( _mContourModelWall , _mViewContourWall );
 620         _manContourControlWall->CreateNewManualContour();
 621         _manContourControlWall->SetActive(false);
 622         _mViewContourWall->RefreshContour();
 623 }
 624 //--------------------------------------------------------
 625 void manualContourContainer::restartLumenContour(wxVtk2DBaseView        *_imageviewer2D_1)
 626 {
 627
 628         if (_manContourControlLumen == NULL)
 629         {
 630                 return;
 631         }
 632         delete _manContourControlLumen;
 633         delete _mContourModelLumen;
 634         delete _mViewContourLumen;
 635
 636         _manContourControlLumen = new manualContourControler();
 637         _mContourModelLumen             = new manualContourModel();
 638         _mViewContourLumen                      = new manualViewContour();
 639         _mViewContourLumen->SetModel( _mContourModelLumen );
 640         _mViewContourLumen->SetWxVtkBaseView( _imageviewer2D_1 );
 641 //EED 28Dic2006
 642         _mViewContourLumen->SetRange( (int)(0.6) );
 643         _mViewContourLumen->SetZ( 1000 );
 644         _mViewContourLumen->SetColorNormalContour(1, 0, 0);
 645         _mViewContourLumen->SetColorEditContour(1, 1, 0.33);
 646
 647         _manContourControlLumen->SetModelView( _mContourModelLumen , _mViewContourLumen );
 648         _manContourControlLumen->CreateNewManualContour();
 649         _manContourControlLumen->SetActive(false);
 650         _mViewContourLumen->RefreshContour();
 651 }
 652
 653 //--------------------------------------------------------
 654 void manualContourContainer::restartCalcContours()
 655 {
 656         int i;
 657         for (i = 0; i < (int)_mContourModelCalc.size(); i++)
 658         {
 659
 660                 _manContourControlCalc[i] = NULL;
 661                 _mContourModelCalc[i] = NULL;
 662                 _mViewContourCalc[i] = NULL;
 663
 664                 delete _manContourControlCalc[i];
 665                 delete _mContourModelCalc[i];
 666                 delete _mViewContourCalc[i];
 667         }
 668
 669         _manContourControlCalc.clear();
 670         _mContourModelCalc.clear();
 671         _mViewContourCalc.clear();
 672 }
 673
 674 //--------------------------------------------------------
 675 void manualContourContainer::restartHypoContours()
 676 {
 677         int i;
 678         for (i = 0; i < (int)_mContourModelHypo.size(); i++)
 679         {
 680
 681                 _manContourControlHypo[i] = NULL;
 682                 _mContourModelHypo[i] = NULL;
 683                 _mViewContourHypo[i] = NULL;
 684
 685                 delete _manContourControlHypo[i];
 686                 delete _mContourModelHypo[i];
 687                 delete _mViewContourHypo[i];
 688         }
 689
 690         _manContourControlHypo.clear();
 691         _mContourModelHypo.clear();
 692         _mViewContourHypo.clear();
 693 }
 694
 695 //--------------------------------------------------------
 696 void manualContourContainer::createWallContour(wxVtk2DBaseView  *_imageviewer2D_1)
 697 {
 698         //Contorno 1
 699         _manContourControlWall  = new manualContourControler();
 700         _mContourModelWall      = new manualContourModel();
 701         _mViewContourWall       = new manualViewContour();
 702         _mViewContourWall->SetModel( _mContourModelWall );
 703         _mViewContourWall->SetWxVtkBaseView( _imageviewer2D_1 );
 704 //EED 28Dic2006
 705         _mViewContourWall->SetRange( (int)(0.6) );
 706
 707         _mViewContourWall->SetZ( 1000 );
 708         _mViewContourWall->SetColorNormalContour(0.2, 0.6, 1);
 709         _mViewContourWall->SetColorEditContour(1, 1, 0.33);
 710
 711         _manContourControlWall->SetModelView( _mContourModelWall , _mViewContourWall );
 712         _manContourControlWall->CreateNewManualContour();
 713         _manContourControlWall->SetActive(false);
 714         _mViewContourWall->RefreshContour();
 715 }
 716
 717 //--------------------------------------------------------
 718 void manualContourContainer::createLumenContour(wxVtk2DBaseView *_imageviewer2D_1)
 719 {
 720
 721                 //Contorno Lumen
 722         _manContourControlLumen = new manualContourControler();
 723         _mContourModelLumen             = new manualContourModel();
 724         _mViewContourLumen                      = new manualViewContour();
 725         _mViewContourLumen->SetModel( _mContourModelLumen );
 726         _mViewContourLumen->SetWxVtkBaseView( _imageviewer2D_1 );
 727 //EED 28Dic2006
 728         _mViewContourLumen->SetRange( (int)(0.6) );
 729
 730         _mViewContourLumen->SetZ( 1000 );
 731         _mViewContourLumen->SetColorNormalContour(1, 0, 0);
 732         _mViewContourLumen->SetColorEditContour(1, 1, 0.33);
 733
 734         _manContourControlLumen->SetModelView( _mContourModelLumen , _mViewContourLumen );
 735         _manContourControlLumen->CreateNewManualContour();
 736         _manContourControlLumen->SetActive(false);
 737         _mViewContourLumen->RefreshContour();
 738 }