]> Creatis software - creaMaracasVisu.git/blob - lib/maracasVisuLib/src/interface/wxWindows/manualContourContainer.cxx
BUG interaction click right
[creaMaracasVisu.git] / 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 }