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