lib/maracasVisuLib/src/interface/wxWindows/manualContour.cpp

   1
   2 #include <vtkActor.h>
   3 #include <vtkProperty.h>
   4
   5 #include <vtkCellArray.h>
   6 #include <vtkRenderer.h>
   7 #include <vtkCoordinate.h>
   8 #include <vtkTextProperty.h>
   9 #include <vtkTextActor.h>
  10 #include <vtkProperty2D.h>
  11 #include <vtkPointPicker.h>
  12 #include "widgets/UtilVtk3DGeometriSelection.h"
  13
  14
  15 #include "manualContour.h"
  16
  17
  18 // ----------------------------------------------------------------------------
  19 // ----------------------------------------------------------------------------
  20 // ----------------------------------------------------------------------------
  21
  22 manualPoint::manualPoint(){
  23 }
  24 // ----------------------------------------------------------------------------
  25 manualPoint::~manualPoint(){
  26 }
  27 // ----------------------------------------------------------------------------
  28 void manualPoint::SetPoint(double x,double y,double z){
  29         _x=x;
  30         _y=y;
  31         _z=z;
  32 }
  33 // ----------------------------------------------------------------------------
  34 void manualPoint::SetPointX(double x){
  35         _x=x;
  36 }
  37 // ----------------------------------------------------------------------------
  38 void manualPoint::SetPointY(double y){
  39         _y=y;
  40 }
  41 // ----------------------------------------------------------------------------
  42 void manualPoint::SetPointZ(double z){
  43         _z=z;
  44 }
  45 // ----------------------------------------------------------------------------
  46 double manualPoint::GetX(){
  47         return _x;
  48 }
  49 // ----------------------------------------------------------------------------
  50 double manualPoint::GetY(){
  51         return _y;
  52 }
  53 // ----------------------------------------------------------------------------
  54 double manualPoint::GetZ(){
  55         return _z;
  56 }
  57 // ----------------------------------------------------------------------------
  58 manualPoint * manualPoint :: Clone()
  59 {
  60         manualPoint * clone = new manualPoint();
  61         clone->SetPoint( GetX(), GetY(), GetZ());
  62         return clone;
  63 }
  64
  65
  66 // ----------------------------------------------------------------------------
  67 // ----------------------------------------------------------------------------
  68 // ----------------------------------------------------------------------------
  69
  70 manualContourModelCircle::manualContourModelCircle()
  71 : manualContourModel()
  72 {
  73 }
  74
  75 manualContourModelCircle::~manualContourModelCircle()
  76 {
  77 }
  78
  79
  80 // ----------------------------------------------------------------------------
  81 manualContourModelCircle * manualContourModelCircle :: Clone()  // virtual
  82 {
  83         manualContourModelCircle * clone = new manualContourModelCircle();
  84         CopyAttributesTo(clone);
  85         return clone;
  86 }
  87
  88 // ---------------------------------------------------------------------------
  89
  90 void manualContourModelCircle::CopyAttributesTo( manualContourModelCircle * cloneObject)
  91 {
  92         // Fathers object
  93         manualContourModel::CopyAttributesTo(cloneObject);
  94 }
  95
  96 //----------------------------------------------------------------
  97 int manualContourModelCircle::GetTypeModel() //virtual
  98 {
  99         return 3;
 100 }
 101
 102 //----------------------------------------------------------------
 103 void manualContourModelCircle::GetSpline_i_Point(int i, double *x, double *y, double *z) // virtal
 104 {
 105         double angle = _deltaAngle*i;
 106         *x = _radio*cos(angle) + _centerX;
 107         *y = _radio*sin(angle) + _centerY;
 108         *z = _centerZ;
 109 }
 110
 111 //
 112 // ---------------------------------------------------------------------------
 113 void manualContourModelCircle::UpdateSpline() // virtal
 114 {
 115         manualPoint     *mpA,*mpB;
 116         double difX,difY;
 117     int np      = GetSizeLstPoints( );
 118         int nps = GetNumberOfPointsSpline();
 119         _deltaAngle=(3.14159265*2)/(nps-1);
 120
 121         if (np==2){
 122                 mpA                     = GetManualPoint(0);
 123                 mpB                     = GetManualPoint(1);
 124                 difX            = mpA->GetX() - mpB->GetX();
 125                 difY            = mpA->GetY() - mpB->GetY();
 126                 _radio          = sqrt( difX*difX + difY*difY );
 127                 _centerX        = mpA->GetX();
 128                 _centerY        = mpA->GetY();
 129                 _centerZ        = mpA->GetZ();
 130         } else {
 131                 _radio          = -1;
 132                 _centerX        = -1;
 133                 _centerY        = -1;
 134                 _centerZ        = -1;
 135         }
 136 }
 137
 138 // ----------------------------------------------------------------------------
 139 // ----------------------------------------------------------------------------
 140 // ----------------------------------------------------------------------------
 141
 142 //AD: 02-09
 143
 144 manualContourModelLine::manualContourModelLine()
 145 : manualContourModel()
 146 {
 147         SetNumberOfPointsSpline(2);
 148 }
 149
 150 manualContourModelLine::~manualContourModelLine()
 151 {
 152 }
 153
 154
 155 // ----------------------------------------------------------------------------
 156 manualContourModelLine * manualContourModelLine :: Clone()  // virtual
 157 {
 158         manualContourModelLine * clone = new manualContourModelLine();
 159         CopyAttributesTo(clone);
 160         return clone;
 161 }
 162
 163 // ---------------------------------------------------------------------------
 164
 165 void manualContourModelLine::CopyAttributesTo( manualContourModelLine * cloneObject)
 166 {
 167         manualContourModel::CopyAttributesTo(cloneObject);
 168 }
 169
 170 //----------------------------------------------------------------
 171 int manualContourModelLine::GetTypeModel() //virtual
 172 {
 173         return 6;
 174 }
 175
 176 //----------------------------------------------------------------
 177 void manualContourModelLine::GetSpline_i_Point(int i, double *x, double *y, double *z) // virtal
 178 {
 179         int np  = GetSizeLstPoints();
 180         if (np==0)
 181         {
 182                 *x      = 0;
 183                 *y      = 0;
 184                 *z      = 0;
 185         }
 186         if (np==1)
 187         {
 188                 manualPoint     *mp;
 189                 mp      = GetManualPoint(0);
 190                 *x      = mp->GetX();
 191                 *y      = mp->GetY();
 192                 *z      = mp->GetZ();
 193         }
 194         if (np==2)
 195         {
 196                 manualPoint     *mp;
 197
 198                 if (i==0)
 199                 {
 200                         mp = GetManualPoint(0);
 201                 }
 202                 else if (i==1)
 203                 {
 204                         mp = GetManualPoint(1);
 205                 }
 206
 207                 *x      = mp->GetX();
 208                 *y      = mp->GetY();
 209                 *z      = mp->GetZ();
 210         }
 211
 212 /*
 213         manualPoint     *mp;
 214         double difX,difY;
 215     int np      = GetSizeLstPoints( );
 216         int nps = GetNumberOfPointsSpline();
 217 //      _deltaAngle=(3.14159265*2)/(nps-1);
 218         _deltaAngle = 100/nps;
 219
 220         if (np==2){
 221
 222                 if (i==0){
 223                         mp                      = GetManualPoint(0);
 224                 } else {
 225                         mp                      = GetManualPoint(1);
 226                 }
 227
 228                 *x = mp->GetX();
 229                 *y = mp->GetY();
 230                 *z = mp->GetZ();
 231
 232         }else {
 233                 *x=-1;
 234                 *y=-1;
 235                 *z=-1;
 236         }
 237 */
 238 }
 239
 240
 241
 242 // ----------------------------------------------------------------------------
 243 // ----------------------------------------------------------------------------
 244 // ----------------------------------------------------------------------------
 245 manualContourModelBullEye::manualContourModelBullEye()
 246 : manualContourModel()
 247 {
 248         _numberPointsSlineBySector=101;   // impaire
 249 }
 250
 251 manualContourModelBullEye::~manualContourModelBullEye()
 252 {
 253 }
 254
 255
 256 // ----------------------------------------------------------------------------
 257 manualContourModelBullEye * manualContourModelBullEye :: Clone()  // virtual
 258 {
 259         manualContourModelBullEye * clone = new manualContourModelBullEye();
 260         CopyAttributesTo(clone);
 261         return clone;
 262 }
 263
 264 // ---------------------------------------------------------------------------
 265
 266 void manualContourModelBullEye::CopyAttributesTo( manualContourModelBullEye * cloneObject)
 267 {
 268         // Fathers object
 269         manualContourModel::CopyAttributesTo(cloneObject);
 270 }
 271
 272 //----------------------------------------------------------------
 273 int manualContourModelBullEye::GetTypeModel() //virtual
 274 {
 275         return 4;
 276 }
 277
 278 //----------------------------------------------------------------
 279 int     manualContourModelBullEye::GetNumberOfPointsSplineSectorBulleEje()
 280 {
 281         return _numberPointsSlineBySector;
 282 }
 283
 284 //----------------------------------------------------------------
 285 void manualContourModelBullEye::SetNumberOfPointsSplineSectorBulleEje(int numpoints)
 286 {
 287         this->_numberPointsSlineBySector = numpoints;
 288 }
 289
 290 //----------------------------------------------------------------
 291 void manualContourModelBullEye::AddSector(      double radioA,
 292                                                 double radioB,
 293                                                 double ang,
 294                                                 double angDelta)
 295 {
 296         manualContourModelBullEyeSector *modelSector = new manualContourModelBullEyeSector();
 297         modelSector->SetSector(radioA,radioB,ang,angDelta);
 298         modelSector->SetNumberOfPointsSpline( this->GetNumberOfPointsSplineSectorBulleEje() );
 299         _lstModelBullEyeSector.push_back(modelSector);
 300 }
 301
 302 //----------------------------------------------------------------
 303 manualContourModelBullEyeSector * manualContourModelBullEye::GetModelSector(int id)
 304 {
 305         return _lstModelBullEyeSector[id];
 306 }
 307
 308 //----------------------------------------------------------------
 309 void manualContourModelBullEye::GetSector(int id,
 310                                                 double *radioA,
 311                                                 double *radioB,
 312                                                 double *ang,
 313                                                 double *angDelta)
 314 {
 315         _lstModelBullEyeSector[id]->GetSector(radioA,radioB,ang,angDelta);
 316 }
 317
 318 void manualContourModelBullEye::UpdateSpline() // virtual
 319 {
 320         manualContourModel::UpdateSpline();
 321
 322         if (this->GetSizeLstPoints()>2){
 323                 double cx,cy;
 324                 double ww,hh;
 325                 manualPoint *mpA = GetManualPoint(0);
 326                 manualPoint *mpB = GetManualPoint(2);
 327                 cx = (mpA->GetX() + mpB->GetX()) / 2.0;
 328                 cy = (mpA->GetY() + mpB->GetY()) / 2.0;
 329                 ww = fabs( mpA->GetX() - mpB->GetX() )/2.0;
 330                 hh = fabs( mpA->GetY() - mpB->GetY() )/2.0;
 331                 int i,size = _lstModelBullEyeSector.size();
 332                 for (i=0;i<size;i++)
 333                 {
 334                         _lstModelBullEyeSector[i]->SetCenter(cx,cy);
 335                         _lstModelBullEyeSector[i]->SetSize(ww,hh);
 336                 } // for
 337         }
 338 }
 339
 340
 341 //----------------------------------------------------------------
 342 void manualContourModelBullEye::ResetSectors()
 343 {
 344         int i,size=_lstModelBullEyeSector.size();
 345         for (i=0;i<size;i++)
 346         {
 347                 delete _lstModelBullEyeSector[i];
 348         }
 349         _lstModelBullEyeSector.clear();
 350 }
 351
 352 //----------------------------------------------------------------
 353 int manualContourModelBullEye::GetSizeOfSectorLst()
 354 {
 355         return _lstModelBullEyeSector.size();
 356 }
 357
 358 //----------------------------------------------------------------
 359 void manualContourModelBullEye::Save(FILE *ff) // virtual
 360 {
 361         manualContourModel::Save(ff);
 362         int i,size = GetSizeOfSectorLst();
 363         fprintf(ff,"numberOfSections %d \n",size);
 364         for ( i=0 ; i<size ; i++ )
 365         {
 366                 _lstModelBullEyeSector[i]->Save(ff);
 367         }
 368 }
 369
 370 //----------------------------------------------------------------
 371 void manualContourModelBullEye::Open(FILE *ff) // virtual
 372 {
 373         manualContourModel::Open(ff);
 374
 375         ResetSectors();
 376
 377         char tmp[255];
 378         int i;
 379         int numberOfSections;
 380 //      double radioA,radioB,ang,deltaAng;
 381
 382         fscanf(ff,"%s",tmp); // NumberOfSections
 383         fscanf(ff,"%s",tmp); // ##
 384         numberOfSections = atoi(tmp);
 385         for (i=0;i<numberOfSections;i++)
 386         {
 387                 AddSector(0,1,90,0);
 388                 _lstModelBullEyeSector[i]->Open(ff);
 389         }
 390
 391 }
 392
 393 // ----------------------------------------------------------------------------
 394 std::vector<manualContourModel*> manualContourModelBullEye::ExploseModel(  )
 395 {
 396 //EED004
 397         std::vector<manualContourModel*> lstTmp;
 398         int i,iSize=_lstModelBullEyeSector.size();
 399         for (i=0;i<iSize;i++)
 400         {
 401                 lstTmp.push_back( _lstModelBullEyeSector[i] );
 402         }
 403         return lstTmp;
 404 }
 405
 406
 407 // ----------------------------------------------------------------------------
 408 // ----------------------------------------------------------------------------
 409 // ----------------------------------------------------------------------------
 410 manualContourModelBullEyeSector::manualContourModelBullEyeSector()
 411 : manualContourModel()
 412 {
 413 }
 414
 415 manualContourModelBullEyeSector::~manualContourModelBullEyeSector()
 416 {
 417 }
 418
 419
 420 // ----------------------------------------------------------------------------
 421 manualContourModelBullEyeSector * manualContourModelBullEyeSector :: Clone()  // virtual
 422 {
 423         manualContourModelBullEyeSector * clone = new manualContourModelBullEyeSector();
 424         CopyAttributesTo(clone);
 425         return clone;
 426 }
 427
 428 // ---------------------------------------------------------------------------
 429
 430 void manualContourModelBullEyeSector::CopyAttributesTo( manualContourModelBullEyeSector * cloneObject)
 431 {
 432         // Fathers object
 433         manualContourModel::CopyAttributesTo(cloneObject);
 434 }
 435
 436 //----------------------------------------------------------------
 437 int manualContourModelBullEyeSector::GetTypeModel() //virtual
 438 {
 439         return 5;
 440 }
 441
 442
 443 //----------------------------------------------------------------
 444 void manualContourModelBullEyeSector::SetSector(        double radioA,
 445                                                 double radioB,
 446                                                 double ang,
 447                                                 double angDelta)
 448 {
 449         _radioA         = radioA;
 450         _radioB         = radioB;
 451         _ang            = ang*3.14159265/180.0;
 452         _angDelta       = angDelta*3.14159265/180.0;
 453 }
 454
 455 //----------------------------------------------------------------
 456 void manualContourModelBullEyeSector::GetSector(
 457                                                 double *radioA,
 458                                                 double *radioB,
 459                                                 double *ang,
 460                                                 double *angDelta)
 461 {
 462         *radioA         = _radioA;
 463         *radioB         = _radioB;
 464         *ang            = _ang;
 465         *angDelta       = _angDelta;
 466 }
 467
 468 // ----------------------------------------------------------------------------
 469 void manualContourModelBullEyeSector::SetCenter(double cx,double cy)
 470 {
 471         _cx = cx;
 472         _cy = cy;
 473 }
 474
 475 //----------------------------------------------------------------
 476 void manualContourModelBullEyeSector::SetSize(double ww,double hh)
 477 {
 478         _ww = ww;
 479         _hh = hh;
 480 }
 481
 482 //----------------------------------------------------------------
 483 void manualContourModelBullEyeSector::GetSpline_i_Point(int i, double *x, double *y, double *z)
 484 {
 485 //EED004
 486
 487         int ii,nps;
 488 //      double x,y,z;
 489         double ang,angcos, angsin;
 490         double radio;
 491
 492         nps     =  GetNumberOfPointsSpline() - 3;
 493
 494         if (i==GetNumberOfPointsSpline()-1)
 495         {
 496                 i=0;
 497         }
 498
 499         if (i<=nps/2)
 500         {
 501                 ii=i;
 502                 radio=_radioA;
 503         } else {
 504                 ii=nps-i+1;
 505                 radio=_radioB;
 506         }
 507         ang = ((double)ii/(nps/2))*_angDelta + _ang;
 508         angcos =  cos(ang);
 509         angsin =  sin(ang);
 510
 511         *x = _ww*radio*angcos + _cx;
 512         *y = _hh*radio*angsin + _cy;
 513         *z= -900;
 514 }
 515
 516 //----------------------------------------------------------------
 517 void manualContourModelBullEyeSector::Save(FILE *ff) // virtual
 518 {
 519         manualContourModel::Save(ff);
 520         fprintf(ff,"rA= %f rB= %f ang= %f deltaAng= %f\n", _radioA,_radioB, _ang , _angDelta);
 521 }
 522
 523 //----------------------------------------------------------------
 524 void manualContourModelBullEyeSector::Open(FILE *ff) // virtual
 525 {
 526         char tmp[255];
 527         fscanf(ff,"%s",tmp); // TypeModel
 528         fscanf(ff,"%s",tmp); // ##
 529
 530         manualContourModel::Open(ff);
 531
 532
 533         fscanf(ff,"%s",tmp); // radioA=
 534         fscanf(ff,"%s",tmp); // radioA
 535         _radioA = atof(tmp);
 536
 537         fscanf(ff,"%s",tmp); // radioB=
 538         fscanf(ff,"%s",tmp); // radioB
 539         _radioB = atof(tmp);
 540
 541         fscanf(ff,"%s",tmp); // ang=
 542         fscanf(ff,"%s",tmp); // ang
 543         _ang = atof(tmp);
 544
 545         fscanf(ff,"%s",tmp); // deltaAng=
 546         fscanf(ff,"%s",tmp); // deltaAng
 547         _angDelta = atof(tmp);
 548 }
 549
 550
 551
 552 // ---------------------------------------------------------------------------
 553 // ---------------------------------------------------------------------------
 554 // ---------------------------------------------------------------------------
 555 // ---------------------------------------------------------------------------
 556
 557 //JSTG 25-02-08 --------------------------------------------------
 558 manualContourModelRoi::manualContourModelRoi()
 559 : manualContourModel()
 560 {
 561         SetNumberOfPointsSpline(5);
 562 }
 563
 564 manualContourModelRoi::~manualContourModelRoi()
 565 {
 566 }
 567
 568
 569 // ----------------------------------------------------------------------------
 570 manualContourModelRoi * manualContourModelRoi :: Clone()  // virtual
 571 {
 572         manualContourModelRoi * clone = new manualContourModelRoi();
 573         CopyAttributesTo(clone);
 574         return clone;
 575 }
 576
 577 // ---------------------------------------------------------------------------
 578
 579 void manualContourModelRoi::CopyAttributesTo( manualContourModelRoi * cloneObject)
 580 {
 581         // Fathers object
 582         manualContourModel::CopyAttributesTo(cloneObject);
 583 }
 584
 585 //----------------------------------------------------------------
 586 int manualContourModelRoi::GetTypeModel() //virtual
 587 {
 588         return 2;
 589 }
 590
 591 //----------------------------------------------------------------
 592
 593
 594 // ----------------------------------------------------------------------------
 595 // ----------------------------------------------------------------------------
 596 // ----------------------------------------------------------------------------
 597
 598 manualContourModel::manualContourModel()
 599 {
 600     _cntSplineX = vtkKochanekSpline::New( );
 601     _cntSplineY = vtkKochanekSpline::New( );
 602     _cntSplineZ = vtkKochanekSpline::New( );
 603
 604         this->SetCloseContour(true);
 605
 606     _cntSplineX->SetDefaultTension( 0 );
 607         _cntSplineX->SetDefaultBias( 0 );
 608         _cntSplineX->SetDefaultContinuity( 0 );
 609
 610     _cntSplineY->SetDefaultTension( 0 );
 611         _cntSplineY->SetDefaultBias( 0 );
 612         _cntSplineY->SetDefaultContinuity( 0 );
 613
 614     _cntSplineZ->SetDefaultTension( 0 );
 615         _cntSplineZ->SetDefaultBias( 0 );
 616         _cntSplineZ->SetDefaultContinuity( 0 );
 617
 618 //JSTG 25-02-08 -------------------------------------------------------------------------------------------------
 619
 620         // this parameter is reset in the  VIRTUAL manualContourBaseControler::Configure
 621         _sizePointsContour      = 100;                  //JSTG 25-02-08 The change in the inisialization of these variable is critical.
 622
 623         _delta_JSTG                     = 0.0;
 624 //---------------------------------------------------------------------------------------------------------------
 625 }
 626
 627 // ----------------------------------------------------------------------------
 628 manualContourModel::~manualContourModel()
 629 {
 630         int i,size=_lstPoints.size();
 631         for (i=0;i<size; i++){
 632                 delete _lstPoints[i];
 633         }
 634         _lstPoints.clear();
 635
 636         _cntSplineX->Delete();
 637         _cntSplineY->Delete();
 638         _cntSplineZ->Delete();
 639 }
 640 // ----------------------------------------------------------------------------
 641 int manualContourModel::AddPoint(double x,double y,double z)
 642 {
 643    manualPoint *mp = new manualPoint();
 644    mp->SetPoint(x,y,z);
 645    AddManualPoint(mp);
 646    //UpdateSpline();
 647
 648    return _lstPoints.size()-1;
 649 }
 650 // ----------------------------------------------------------------------------
 651 int manualContourModel::InsertPoint(double x,double y,double z)
 652 {
 653         double dd,ddmin=9999999;
 654         int    ibak=0;
 655         double xx,x1,x2;
 656         double yy,y1,y2;
 657         double zz,z1,z2;
 658         int i,ii,iii,size=_lstPoints.size();
 659         double j,MaxDivisions=20,porcentage;
 660         int sizeB=size;
 661
 662         if (_closeContour==false)
 663         {
 664                 size=size-1;
 665         }
 666
 667         double jbak;
 668
 669         for ( i=0 ; i<size ; i++ )
 670         {
 671                 ii=i % sizeB ;
 672                 iii=(i+1) % sizeB;
 673                 x1=_lstPoints[ii]->GetX();
 674                 y1=_lstPoints[ii]->GetY();
 675                 z1=_lstPoints[ii]->GetZ();
 676                 x2=_lstPoints[iii]->GetX();
 677                 y2=_lstPoints[iii]->GetY();
 678                 z2=_lstPoints[iii]->GetZ();
 679                 for (j=0; j<=MaxDivisions; j++)
 680                 {
 681                         porcentage=(j/MaxDivisions);
 682                         xx=(x2-x1)*porcentage+x1;
 683                         yy=(y2-y1)*porcentage+y1;
 684                         zz=(z2-z1)*porcentage+z1;
 685                         dd=sqrt( (xx-x)*(xx-x) + (yy-y)*(yy-y) + (zz-z)*(zz-z) );
 686                         if ( dd<ddmin )
 687                         {
 688                                 ddmin=dd;
 689                                 ibak=iii;
 690                                 jbak=j;
 691                         }
 692                 }
 693         }
 694
 695         if (_closeContour==false)
 696         {
 697                 if ( (ibak==1) && (jbak==0) )
 698                 {
 699                         ibak=0;
 700                 }
 701                 if ( ( ibak==size ) && ( jbak==MaxDivisions ) )
 702                 {
 703                         ibak=sizeB;
 704                 }
 705         }
 706
 707
 708 //JSTG - 25-04-08 ----------------------------------------------------------
 709         //manualPoint *mp = new manualPoint();
 710         //mp->SetPoint(x,y,z);
 711         //std::vector<manualPoint*>::iterator itNum = _lstPoints.begin() + ibak;
 712         //_lstPoints.insert(itNum,mp);
 713         InsertPoint_id(ibak,x,y,z);
 714 //----------------------------------------------------------------------------
 715
 716         return ibak;
 717 }
 718 // ----------------------------------------------------------------------------
 719 void manualContourModel::InsertPoint_id(int id, double x, double y, double z)
 720 {
 721         manualPoint *mp = new manualPoint();
 722         mp->SetPoint(x,y,z);
 723         std::vector<manualPoint*>::iterator itNum = _lstPoints.begin() + id;
 724         _lstPoints.insert(itNum,mp);
 725 }
 726 // ----------------------------------------------------------------------------
 727
 728 void manualContourModel::DeletePoint(int i)
 729 {
 730         std::vector<manualPoint*>::iterator itNum = _lstPoints.begin() + i;
 731    _lstPoints.erase(itNum);
 732 }
 733 // ----------------------------------------------------------------------------
 734 void manualContourModel::DeleteAllPoints()
 735 {
 736         int i,size=_lstPoints.size();
 737         for (i=0;i<size;i++){
 738            _lstPoints.erase( _lstPoints.begin() );
 739         }
 740         this->UpdateSpline();
 741 }
 742 // ----------------------------------------------------------------------------
 743
 744 void manualContourModel::MovePoint(int i,double dx,double dy,double dz)
 745 {
 746         manualPoint *mp=_lstPoints[i];
 747         double x=mp->GetX()+dx;
 748         double y=mp->GetY()+dy;
 749         double z=mp->GetZ()+dz;
 750         mp->SetPoint(x,y,z);
 751 }
 752 // ----------------------------------------------------------------------------
 753 void manualContourModel::MoveLstPoints(double dx,double dy,double dz)
 754 {
 755         // ToDo
 756 }
 757 // ----------------------------------------------------------------------------
 758 void manualContourModel::MoveAllPoints(double dx,double dy,double dz)
 759 {
 760         int i,size=_lstPoints.size();
 761         for (i=0;i<size;i++){
 762                 MovePoint(i,dx,dy,dz);
 763         }
 764 }
 765
 766
 767 // ----------------------------------------------------------------------------
 768
 769 // type=-1  x,y,z
 770 // type=0       x,y
 771 // type=1       y,z
 772 // type=2       x,z
 773 int      manualContourModel::GetIdPoint(double x, double y, double z, int i_range,int type)
 774 {
 775         double range = i_range+1;
 776
 777         double xx,yy,zz,dd,ddmin=9999999;
 778         int ibak=-1;
 779         int i,size=_lstPoints.size();
 780         for (i=0;i<size;i++){
 781                 manualPoint *mp=_lstPoints[i];
 782                 xx=mp->GetX();
 783                 yy=mp->GetY();
 784                 zz=mp->GetZ();
 785
 786                 if (type==-1)
 787                 {
 788                         if ((fabs(xx-x)<range) && (fabs(yy-y)<range) && (fabs(zz-z)<range)) {
 789                            dd=sqrt(   (xx-x)*(xx-x) + (yy-y)*(yy-y) + (zz-z)*(zz-z) );
 790                            if (dd<ddmin){
 791                                    ddmin=dd;
 792                                    ibak=i;
 793                            }
 794                         }
 795                 }
 796                 if (type==0)
 797                 {
 798                         if ((fabs(yy-y)<range) && (fabs(zz-z)<range)) {
 799                            dd=sqrt(   (yy-y)*(yy-y) + (zz-z)*(zz-z) );
 800                            if (dd<ddmin){
 801                                    ddmin=dd;
 802                                    ibak=i;
 803                            }
 804                         }
 805                 }
 806                 if (type==1)
 807                 {
 808                         if ((fabs(xx-x)<range) && (fabs(zz-z)<range)) {
 809                            dd=sqrt(   (xx-x)*(xx-x)  + (zz-z)*(zz-z) );
 810                            if (dd<ddmin){
 811                                    ddmin=dd;
 812                                    ibak=i;
 813                            }
 814                         }
 815                 }
 816                 if (type==2)
 817                 {
 818                         if ((fabs(xx-x)<range) && (fabs(yy-y)<range) ) {
 819                            dd=sqrt(   (xx-x)*(xx-x) + (yy-y)*(yy-y)  );
 820                            if (dd<ddmin){
 821                                    ddmin=dd;
 822                                    ibak=i;
 823                            }
 824                         }
 825                 }
 826         }
 827         return ibak;
 828 }
 829 // ----------------------------------------------------------------------------
 830 manualPoint* manualContourModel::GetManualPoint(int id)
 831 {
 832         return _lstPoints[id];
 833 }
 834 // ----------------------------------------------------------------------------
 835 int manualContourModel::GetSizeLstPoints()
 836 {
 837         return _lstPoints.size();
 838 }
 839 //----------------------------------------------------------------------------
 840 int manualContourModel::GetNumberOfPointsSpline()
 841 {
 842         return _sizePointsContour;
 843 }
 844 //----------------------------------------------------------------------------
 845 void manualContourModel::SetNumberOfPointsSpline(int size)
 846 {
 847         _sizePointsContour = size;
 848 }
 849
 850
 851 // ----------------------------------------------------------------------------
 852
 853 void manualContourModel::SetCloseContour(bool closeContour)
 854 {
 855         _closeContour = closeContour;
 856         if (_closeContour==true)
 857         {
 858                 _cntSplineX->ClosedOn();
 859                 _cntSplineY->ClosedOn();
 860                 _cntSplineZ->ClosedOn();
 861         } else {
 862                 _cntSplineX->ClosedOff();
 863                 _cntSplineY->ClosedOff();
 864                 _cntSplineZ->ClosedOff();
 865         }
 866 }
 867
 868 // ----------------------------------------------------------------------------
 869 bool manualContourModel::IfCloseContour()
 870 {
 871         return _closeContour;
 872 }
 873
 874 // ----------------------------------------------------------------------------
 875
 876 void manualContourModel::UpdateSpline() // virtual
 877 {
 878         int i, np;
 879     np  = _lstPoints.size();
 880         manualPoint     *mp;
 881         _cntSplineX->RemoveAllPoints();
 882         _cntSplineY->RemoveAllPoints();
 883         _cntSplineZ->RemoveAllPoints();
 884     for( i = 0; i < np; i++ ) {
 885                 mp = GetManualPoint(i);
 886         _cntSplineX->AddPoint( i, mp->GetX() );
 887         _cntSplineY->AddPoint( i, mp->GetY() );
 888         _cntSplineZ->AddPoint( i, mp->GetZ() );
 889     } //  rof
 890
 891 //JSTG 25-02-08 ---------------------------------------------------------------------------------------------
 892         if (this->_closeContour==true)
 893         {
 894                 _delta_JSTG = (double) (np) / double (_sizePointsContour - 1);  //Without the -1 the curve is not close
 895         } else {
 896                 _delta_JSTG = (double) (np-1) / double (_sizePointsContour );  //Without the -1 the curve is not close
 897         }
 898 //-----------------------------------------------------------------------------------------------------------
 899 }
 900
 901 //---------------------------------------------------------------------------------
 902
 903 /*void manualContourModel::GetSplineiPoint(int i, double &x, double &y, double &z)
 904 {
 905         double delta=(double)(_lstPoints.size()) / (double)(_sizePointsContour);
 906         double t = delta*(double)i;
 907         GetSplinePoint(t, x, y, z);
 908 }*/
 909
 910 //-----------------------------------------------------------------------------
 911
 912 //JSTG 25-02-08 ---------------------------------------------------------------
 913 void manualContourModel::GetSpline_i_Point(int i, double *x, double *y, double *z) // virtal
 914 {
 915         GetSpline_t_Point(i*_delta_JSTG,x,y,z);
 916 }
 917
 918 // ----------------------------------------------------------------------------
 919
 920 //JSTG 25-02-08 ---------------------------------------------------------------
 921 void manualContourModel::GetSpline_t_Point(double t, double *x, double *y, double *z)
 922 {
 923                 if (_lstPoints.size()==0)
 924         {
 925                 *x      = 0;
 926                 *y      = 0;
 927                 *z      = 0;
 928         }
 929         if (_lstPoints.size()==1)
 930         {
 931                 manualPoint     *mp;
 932                 mp      = GetManualPoint(0);
 933                 *x      = mp->GetX();
 934                 *y      = mp->GetY();
 935                 *z      = mp->GetZ();
 936         }
 937         if (_lstPoints.size()>=2)
 938         {
 939                 *x      = _cntSplineX->Evaluate(t);
 940                 *y      = _cntSplineY->Evaluate(t);
 941                 *z      = _cntSplineZ->Evaluate(t);
 942         }
 943 }
 944
 945 // ----------------------------------------------------------------------------
 946
 947
 948 /*void manualContourModel::GetSplinePoint(double t, double &x, double &y, double &z)
 949 {
 950         if (_lstPoints.size()==0)
 951         {
 952                 x       = 0;
 953                 y       = 0;
 954                 z       = 0;
 955         }
 956         if (_lstPoints.size()==1)
 957         {
 958                 manualPoint     *mp;
 959                 mp      = GetManualPoint(0);
 960                 x       = mp->GetX();
 961                 y       = mp->GetY();
 962                 z       = mp->GetZ();
 963         }
 964         if (_lstPoints.size()>=2)
 965         {
 966                 x       = _cntSplineX->Evaluate(t);
 967                 y       = _cntSplineY->Evaluate(t);
 968                 z       = _cntSplineZ->Evaluate(t);
 969         }
 970 }*/
 971 // ----------------------------------------------------------------------------
 972 double manualContourModel::GetPathSize()
 973 {
 974         double result = 0;
 975         double x1,y1,z1;
 976         double x2,y2,z2;
 977
 978 // JSTG 25-02-08 -----------------------------
 979         //double t,delta;
 980         //int i,np,nps;
 981         int i;
 982 //--------------------------------------------
 983
 984         if (_lstPoints.size()==2)
 985         {
 986                 x1=_lstPoints[0]->GetX();
 987                 y1=_lstPoints[0]->GetY();
 988                 z1=_lstPoints[0]->GetZ();
 989                 x2=_lstPoints[1]->GetX();
 990                 y2=_lstPoints[1]->GetY();
 991                 z2=_lstPoints[1]->GetZ();
 992                 result = sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) + (z2-z1)*(z2-z1) );
 993         }
 994         if (_lstPoints.size()>2)
 995         {
 996
 997 // JSTG 25-02-08 ------------------------------------------
 998                 //np  = _lstPoints.size( );
 999                 //nps = 200;
1000                 //delta=( double ) ( np  ) / ( double ) ( nps  );
1001                 UpdateSpline();
1002                 //GetSplinePoint(0,x1,y1,z1);
1003                 GetSpline_i_Point(0,&x1,&y1,&z1);
1004
1005                 //for( i = 1; i < nps; i++ )
1006                 for( i = 1; i < GetNumberOfPointsSpline(); i++ )
1007                 {
1008                         //t = delta * (double)i;
1009                         //GetSplinePoint(t,x2,y2,z2);
1010                         GetSpline_i_Point(i,&x2,&y2,&z2);
1011 //---------------------------------------------------------
1012                         result=result + sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) + (z2-z1)*(z2-z1) );
1013                         x1=x2;
1014                         y1=y2;
1015                         z1=z2;
1016                 }// for
1017         }
1018
1019         return result;
1020 }
1021 // ----------------------------------------------------------------------------
1022 double manualContourModel::GetPathArea()
1023 {
1024         double result = 555;
1025         if ((_lstPoints.size()>=3) && IfCloseContour()==true )
1026         {
1027                 double area;
1028 //JSTG 25-02-08 ---------------------------------------------
1029                 //double ti,tj;
1030 //-----------------------------------------------------------
1031                 double x1,y1,z1;
1032                 double x2,y2,z2;
1033                 bool okArea=true;
1034                 int i, j;
1035
1036                 // This uses Green's theorem:
1037                 // A = 1/2 * sum( xiyi+1 - xi+1yi); pO == pN
1038                 // A < 0 -> A = |A| (a negative value could raise because points are
1039                 // given in clockwise order).
1040
1041 //JSTG 25-02-08 -------------------------------------------------
1042                 //int np  = _lstPoints.size( );
1043                 //int nps = 200;
1044                 int nps = GetNumberOfPointsSpline();
1045                 //double delta=( double ) ( np  ) / ( double ) ( nps  );
1046                 UpdateSpline();
1047                 for( i = 0, area = 0.0; i < nps; i++ )
1048                 {
1049                         j = ( i + 1 ) % nps;
1050                         //ti = delta * (double)i;
1051                         //tj = delta * (double)j;
1052                         //GetSplinePoint(ti,x1,y1,z1);
1053                         //GetSplinePoint(tj,x2,y2,z2);
1054                         GetSpline_i_Point(i,&x1,&y1,&z1);
1055                         GetSpline_i_Point(j,&x2,&y2,&z2);
1056 //----------------------------------------------------------------
1057                         area +=
1058                                         (x1 * y2 ) -
1059                                         ( x2 * y1 );
1060                         if (z1!=z2)
1061                         {
1062                                 okArea=false;
1063                         }
1064                 }// for
1065                 area /= 2.0;
1066                 area = fabs( area );
1067
1068 /*
1069                 for( i = 0, area = 0.0; i < _lstPoints.size(); i++ )
1070                 {
1071                         j = ( i + 1 ) % _lstPoints.size();
1072                         //  Area
1073                         area +=
1074                                         (_lstPoints[i]->GetX() * _lstPoints[j]->GetY() ) -
1075                                         ( _lstPoints[j]->GetX() * _lstPoints[i]->GetY() );
1076                         if (_lstPoints[0]->GetZ()!=_lstPoints[i]->GetZ())
1077                         {
1078                                 okArea=false;
1079                         }
1080                 } // rof
1081                 area /= 2.0;
1082                 area = fabs( area );
1083 */
1084
1085                 if (okArea==true)
1086                 {
1087                         result = area;
1088                 } else {
1089                         result = -1;
1090                 }
1091
1092         } else {
1093                 result = 0;
1094         }
1095         return result;
1096 }
1097
1098 // ----------------------------------------------------------------------------
1099 // p[x,y,z]   :  data in
1100 // rp[x,y,z]  :  data out  result point
1101 // rn[x,y,z]  :  data out   result normal
1102
1103 void manualContourModel::GetNearestPointAndNormal(double *p, double *rp,  double *rn)
1104 {
1105         double  distMin=999999999;
1106         double  dist,dx,dy,dz;
1107         double  x1,y1,z1;
1108         double  x2,y2,z2;
1109         int             i,np,nps;
1110
1111 //JSTG 25-02-08 -------------------
1112         //double  tback;
1113         int iback;
1114         //double        t,delta;
1115 //---------------------------------
1116
1117         np      = _lstPoints.size( );
1118         if (np>=2)
1119         {
1120 // JSTG 25-02-08 ------------------------------------------
1121                 //nps           = 200;
1122                 nps = GetNumberOfPointsSpline();
1123                 //delta = ( double ) ( np  ) / ( double ) ( nps  );
1124                 UpdateSpline();
1125                 //GetSplinePoint(0,x1,y1,z1);
1126                 GetSpline_i_Point(0,&x1,&y1,&z1);
1127                 for( i = 0; i < nps; i++ )
1128                 {
1129                         //t = delta * (double)i;
1130                         //GetSplinePoint(t,x1,y1,z1);
1131                         GetSpline_i_Point(i,&x1,&y1,&z1);
1132 //----------------------------------------------------------
1133                         dx= x1-p[0];
1134                         dy= y1-p[1];
1135                         dz= z1-p[2];
1136                         dist = sqrt( dx*dx + dy*dy + dz*dz );
1137                         if (dist<distMin)
1138                         {
1139                                 distMin  = dist;
1140 //JSTG                  tback = t;
1141                                 iback = i;
1142                                 rp[0] = x1;
1143                                 rp[1] = y1;
1144                                 rp[2] = z1;
1145                                 rn[0] = x2-x1;
1146                                 rn[1] = y2-y1;
1147                                 rn[2] = z2-z1;
1148                         }
1149                         x2=x1;
1150                         y2=y1;
1151                         z2=z1;
1152                 }// for
1153
1154 // JSTG 25-02-08 ------------------------------------------
1155                 //if (tback==0)
1156                 if (iback==0)
1157                 {
1158                         //t = delta * (double)1.0;
1159                         //GetSplinePoint(t,x1,y1,z1);
1160                         GetSpline_i_Point(i,&x1,&y1,&z1);
1161 //----------------------------------------------------------
1162                         rn[0]=rp[0]-x1;
1163                         rn[1]=rp[1]-y1;
1164                         rn[2]=rp[2]-z1;
1165                 }
1166         }
1167         else
1168         {
1169                 rp[0] = 0;
1170                 rp[1] = 0;
1171                 rp[2] = 0;
1172                 rn[0] = -1;
1173                 rn[1] = 0;
1174                 rn[2] = 0;
1175         }
1176 }
1177
1178 // ----------------------------------------------------------------------------
1179 manualContourModel * manualContourModel :: Clone() // virtual
1180 {
1181         manualContourModel * clone = new manualContourModel();
1182         CopyAttributesTo(clone);
1183         return clone;
1184 }
1185
1186 // ----------------------------------------------------------------------------
1187 void manualContourModel::Open(FILE *ff) // virtual
1188 {
1189         char tmp[255];
1190         int i;
1191         int numberOfControlPoints;
1192         double x,y,z;
1193
1194         fscanf(ff,"%s",tmp); // NumberOfControlPoints
1195         fscanf(ff,"%s",tmp); // ##
1196         numberOfControlPoints = atoi(tmp);
1197         for (i=0;i<numberOfControlPoints;i++)
1198         {
1199                 fscanf(ff,"%s",tmp); // X
1200                 x = atof(tmp);
1201                 fscanf(ff,"%s",tmp); // Y
1202                 y = atof(tmp);
1203                 fscanf(ff,"%s",tmp); // Z
1204                 z = atof(tmp);
1205                 AddPoint(x,y,z);
1206         }
1207 }
1208
1209
1210 // ----------------------------------------------------------------------------
1211 int manualContourModel::GetTypeModel() //virtual
1212 {
1213         // 0 spline
1214         // 1 spline
1215         // 2 rectangle
1216         // 3 circle
1217         // 4 BullEye
1218         // 5 BullEyeSector
1219         // 6 Line
1220         return 1;
1221 }
1222
1223 // ----------------------------------------------------------------------------
1224 void manualContourModel::Save(FILE *ff) // virtual
1225 {
1226         int i,size=_lstPoints.size();
1227         fprintf(ff,"TypeModel %d\n", GetTypeModel() );
1228         fprintf(ff,"NumberOfControlPoints %d\n",size);
1229         for (i=0;i<size;i++)
1230         {
1231                 manualPoint *mp=_lstPoints[i];
1232                 fprintf(ff,"%f %f %f\n", mp->GetX(), mp->GetY(), mp->GetZ() );
1233         }
1234 }
1235
1236
1237 // ---------------------------------------------------------------------------
1238
1239 void manualContourModel::CopyAttributesTo( manualContourModel * cloneObject)
1240 {
1241         // Fathers object
1242         //XXXX::CopyAttributesTo(cloneObject);
1243
1244         cloneObject->SetCloseContour( this->IfCloseContour() );
1245         int i, size = GetSizeLstPoints();
1246         for( i=0; i<size; i++ )
1247         {
1248                 cloneObject->AddManualPoint( GetManualPoint( i )->Clone() );
1249         }
1250         cloneObject->SetNumberOfPointsSpline( GetNumberOfPointsSpline () );
1251         cloneObject->SetCloseContour( _closeContour );
1252         cloneObject->UpdateSpline();
1253 }
1254
1255
1256 // ---------------------------------------------------------------------------
1257 void manualContourModel::AddManualPoint( manualPoint* theManualPoint )//private
1258 {
1259         _lstPoints.push_back( theManualPoint );
1260 }
1261
1262 std::vector<manualContourModel*> manualContourModel::ExploseModel(  )
1263 {
1264         std::vector<manualContourModel*> lstTmp;
1265         lstTmp.push_back(this);
1266         return lstTmp;
1267 }
1268
1269
1270 // ---------------------------------------------------------------------------
1271 // ----------------------------------------------------------------------------
1272 // ----------------------------------------------------------------------------
1273
1274 //int manualViewPoint::range=1;
1275
1276
1277 manualViewPoint::manualViewPoint(wxVtkBaseView *wxvtkbaseview){
1278         _selected                = false;
1279         _posibleSelected = false;
1280         _pts                     = NULL;
1281         _pd                              = NULL;
1282         _pointVtkActor   = NULL;
1283         _bboxMapper              = NULL;
1284         _wxvtkbaseview   = wxvtkbaseview;
1285         _spc[0]                  = 1;
1286         _spc[1]                  = 1;
1287         _spc[2]                  = 1;
1288
1289         _widthline               = 1;
1290
1291 }
1292 // ----------------------------------------------------------------------------
1293 manualViewPoint::~manualViewPoint(){
1294         DeleteVtkObjects();
1295 }
1296
1297 // ----------------------------------------------------------------------------
1298 void manualViewPoint::SetWidthLine( double width)
1299 {
1300         _widthline = width;
1301 }
1302
1303 // ----------------------------------------------------------------------------
1304 void manualViewPoint::SetSelected(bool selected){
1305         _selected=selected;
1306 }
1307 // ----------------------------------------------------------------------------
1308 void manualViewPoint::SetPosibleSelected(bool posibleSelected){
1309         _posibleSelected=posibleSelected;
1310 }
1311 // ----------------------------------------------------------------------------
1312 bool manualViewPoint::GetSelected(){
1313         return _selected;
1314 }
1315 // ----------------------------------------------------------------------------
1316 bool manualViewPoint::GetPosibleSelected(){
1317         return _posibleSelected;
1318 }
1319 // ----------------------------------------------------------------------------
1320 void manualViewPoint::DeleteVtkObjects(){
1321         if (_pointVtkActor      !=NULL)         { _pointVtkActor->Delete(); }
1322         if (_bboxMapper         !=NULL)         { _bboxMapper   ->Delete();     }
1323         if (_pts                        !=NULL)         { _pts                  ->Delete();     }
1324         if (_pd                         !=NULL)         { _pd                   ->Delete();     }
1325         _pointVtkActor  =       NULL;
1326         _bboxMapper             =       NULL;
1327         _pts                    =       NULL;
1328         _pd                             =       NULL;
1329 }
1330
1331
1332
1333 // ----------------------------------------------------------------------------
1334 vtkActor* manualViewPoint::CreateVtkPointActor()
1335 {
1336         DeleteVtkObjects();
1337
1338         _pts = vtkPoints::New();
1339         _pts->SetNumberOfPoints(8);
1340         _pts->SetPoint(0, -1000 , -1000 , 0 );
1341         _pts->SetPoint(1,  1000 , -1000 , 0     );
1342         _pts->SetPoint(2,  1000 ,  1000 , 0 );
1343         _pts->SetPoint(3, -1000 ,  1000 , 0 );
1344         _pts->SetPoint(4, -1000 ,  1000 , 0 );
1345         _pts->SetPoint(5, -1000 ,  1000 , 0 );
1346         _pts->SetPoint(6, -1000 ,  1000 , 0 );
1347         _pts->SetPoint(7, -1000 ,  1000 , 0 );
1348
1349         vtkCellArray *lines = vtkCellArray::New();
1350         lines->InsertNextCell(17);
1351         lines->InsertCellPoint(0);
1352         lines->InsertCellPoint(1);
1353         lines->InsertCellPoint(2);
1354         lines->InsertCellPoint(3);
1355         lines->InsertCellPoint(0);
1356         lines->InsertCellPoint(4);
1357         lines->InsertCellPoint(5);
1358         lines->InsertCellPoint(6);
1359         lines->InsertCellPoint(7);
1360         lines->InsertCellPoint(4);
1361         lines->InsertCellPoint(0);
1362         lines->InsertCellPoint(3);
1363         lines->InsertCellPoint(7);
1364         lines->InsertCellPoint(6);
1365         lines->InsertCellPoint(2);
1366         lines->InsertCellPoint(1);
1367         lines->InsertCellPoint(5);
1368
1369         _pd = vtkPolyData::New();
1370         _pd->SetPoints( _pts );
1371         _pd->SetLines( lines );
1372         lines->Delete();  //do not delete lines ??
1373
1374         _pointVtkActor  =       vtkActor::New();
1375     _bboxMapper         =       vtkPolyDataMapper::New();
1376
1377         _bboxMapper->SetInput(_pd);
1378         _bboxMapper->ImmediateModeRenderingOn();
1379         _pointVtkActor->SetMapper(_bboxMapper);
1380         _pointVtkActor->GetProperty()->BackfaceCullingOn();
1381         UpdateColorActor();
1382         _pd->ComputeBounds();
1383
1384         return _pointVtkActor;
1385 }
1386 // ----------------------------------------------------------------------------
1387 vtkActor* manualViewPoint::GetVtkActor(){
1388         return _pointVtkActor;
1389 }
1390 // ----------------------------------------------------------------------------
1391 void manualViewPoint::SetPositionXY(double x, double y,double i_range,double posZ)
1392 {
1393 //      double range=0.2; // i_range;
1394 //      double range=(double)manualViewPoint::range;
1395
1396         double range=i_range;
1397
1398 //EED 27 sep 2006
1399         x        = x * _spc[0];
1400         y        = y * _spc[1];
1401         posZ = posZ * _spc[2];
1402
1403         if (_pts!=NULL){
1404                 _pts->SetPoint(0, x-range, y+range, posZ-range);
1405                 _pts->SetPoint(1, x+range, y+range, posZ-range);
1406                 _pts->SetPoint(2, x+range, y-range, posZ-range);
1407                 _pts->SetPoint(3, x-range, y-range, posZ-range);
1408                 _pts->SetPoint(4, x-range, y+range, posZ+range);
1409                 _pts->SetPoint(5, x+range, y+range, posZ+range);
1410                 _pts->SetPoint(6, x+range, y-range, posZ+range);
1411                 _pts->SetPoint(7, x-range, y-range, posZ+range);
1412         }
1413 }
1414
1415
1416 // ----------------------------------------------------------------------------
1417 void manualViewPoint::UpdateColorActor()
1418 {
1419         if (_pointVtkActor!=NULL){
1420 //EED03
1421                 _pointVtkActor->GetProperty()->SetLineWidth( _widthline );
1422                 _pointVtkActor->GetProperty()->SetDiffuseColor(1,0,0);
1423                 if (_posibleSelected==true){
1424                         _pointVtkActor->GetProperty()->SetDiffuseColor(1,1,0);
1425                 }
1426         }
1427 }
1428 // ----------------------------------------------------------------------------
1429 void manualViewPoint::GetSpacing(double spc[3])
1430 {
1431         spc[0] = _spc[0];
1432         spc[1] = _spc[1];
1433         spc[2] = _spc[2];
1434 }
1435 // ----------------------------------------------------------------------------
1436 void manualViewPoint::SetSpacing(double spc[3])
1437 {
1438         _spc[0] = spc[0];
1439         _spc[1] = spc[1];
1440         _spc[2] = spc[2];
1441 }
1442
1443
1444
1445 // ----------------------------------------------------------------------------
1446 // ----------------------------------------------------------------------------
1447 // ----------------------------------------------------------------------------
1448
1449 manualViewContour::manualViewContour()
1450 {
1451         _id_viewPoint_for_text  =       0;
1452         _mesureScale                    =       1;
1453         _initialConoturModel = new manualContourModel();
1454 }
1455 // ----------------------------------------------------------------------------
1456 manualViewContour::~manualViewContour()
1457 {
1458         delete _initialConoturModel;
1459 }
1460 // ----------------------------------------------------------------------------
1461
1462 // ----------------------------------------------------------------------------
1463 manualViewContour * manualViewContour :: Clone()
1464 {
1465         manualViewContour * clone = new manualViewContour();
1466         CopyAttributesTo(clone);
1467         return clone;
1468 }
1469
1470 // ---------------------------------------------------------------------------
1471
1472 void manualViewContour::CopyAttributesTo( manualViewContour * cloneObject)
1473 {
1474         // Call to Fathers object
1475         manualViewBaseContour::CopyAttributesTo(cloneObject);
1476
1477         cloneObject->SetMesureScale(_mesureScale);
1478 }
1479
1480 // ---------------------------------------------------------------------------
1481
1482 int manualViewContour::GetType() // virtual
1483 {
1484         return 1;
1485 }
1486
1487 // ----------------------------------------------------------------------------
1488
1489 void manualViewContour::Save(FILE *pFile)
1490 {
1491         manualViewBaseContour::Save(pFile);
1492 }
1493
1494 // ----------------------------------------------------------------------------
1495
1496 void manualViewContour::Open(FILE *pFile)
1497 {
1498 }
1499
1500
1501
1502 // ----------------------------------------------------------------------------
1503 void manualViewContour::RefreshContour() // virtual
1504 {
1505
1506         int i,np,nps;
1507
1508 //JSTG 25-02-08 --------------------
1509         //double t,delta, x,y,z;
1510         double x,y,z;
1511 //----------------------------------
1512
1513         _manContModel->UpdateSpline();
1514     np  = GetNumberOfPoints( );
1515         //nps = GetNumberOfPointsSpline();
1516     nps = _manContModel->GetNumberOfPointsSpline();
1517         //delta=( double ) ( np  ) / ( double ) ( nps-1  );             //JSTG 25-02-08
1518
1519 //printf ("EED manualViewContour::RefreshContour>> %d %d \n", np,nps);
1520
1521         if ( _pts!=NULL )
1522         {
1523                 if (np>=2  )
1524                 {
1525                         for( i = 0; i < nps; i++ )
1526                         {
1527 //JSTG 25-02-08 ------------------------------------------------
1528                                 //t = delta * (double)i;
1529                                 //_manContModel->GetSplinePoint(t,x,y,z);
1530                                 _manContModel->GetSpline_i_Point(i,&x,&y,&z);
1531 //--------------------------------------------------------------
1532         // EED 27 sep 2006
1533         //                      _pts->SetPoint(i, x,y,z );
1534                                 _pts->SetPoint(i , x*_spc[0] , y*_spc[1] , z*_spc[2] );
1535 //if (i%15==0)
1536 //{
1537 //      printf ("EED manualViewContour::RefreshContour>> %d : %f %f %f \n", i,x,y,z);
1538 //}
1539
1540
1541                         }// for
1542                 }
1543                 else
1544                 {
1545                                 _pts->SetPoint(0, 0 , 0 , 0);
1546                                 _pts->SetPoint(1, 0 , 0 , 0);
1547                 } // if
1548         }
1549 }
1550
1551 // ----------------------------------------------------------------------------
1552 void manualViewContour::RefreshText()  // virtual
1553 {
1554
1555         if ((_textActor!=NULL) && ( _textActor->GetProperty()->GetOpacity()!=0 )){
1556                 int size = GetNumberOfPoints();
1557                 char text[50];
1558                 char resultText[50];
1559                 strcpy(resultText," ");
1560                 if (size==2)
1561                 {
1562                         strcpy(resultText,"L= ");
1563                         gcvt ( _mesureScale * this->_manContModel->GetPathSize() , 5, text );
1564                         strcat(resultText,text);
1565                 }
1566                 if (size>2)
1567                 {
1568                         if (_manContModel->IfCloseContour()==true)
1569                         {
1570                                 strcpy(resultText,"P= ");
1571                                 gcvt ( _mesureScale * this->_manContModel->GetPathSize() , 5, text );
1572                                 strcat(resultText,text);
1573                                 gcvt ( _mesureScale * _mesureScale * this->_manContModel->GetPathArea() , 5, text );
1574                                 strcat(resultText,"   A= ");
1575                                 strcat(resultText,text);
1576                         } else {
1577                                 strcpy(resultText,"L= ");
1578                                 gcvt (  _mesureScale * this->_manContModel->GetPathSize() , 5, text );
1579                                 strcat(resultText,text);
1580                         }
1581                 }
1582
1583                 _textActor -> SetInput(resultText);
1584
1585                 if (size>=1){
1586
1587                         int i;
1588                         for (i=0; i<size; i++)
1589                         {
1590                                 if (_lstViewPoints[i]->GetPosibleSelected()==true)
1591                                 {
1592                                         _id_viewPoint_for_text = i;
1593                                 }
1594                         }
1595
1596                         int id = _id_viewPoint_for_text;
1597                         double px = _manContModel->GetManualPoint(id)->GetX();
1598                         double py = _manContModel->GetManualPoint(id)->GetY();
1599
1600                         //EED 27 sep 2006
1601                         px=px*_spc[0];
1602                         py=py*_spc[1];
1603
1604                         _textActor->SetPosition(px+GetRange()+1,py);
1605                 }
1606
1607         }
1608 }
1609
1610 // ----------------------------------------------------------------------------
1611 bool manualViewContour::ifTouchContour(int x,int y,int z){
1612         bool result=false;
1613         double xx=x;
1614         double yy=y;
1615         double zz=z;
1616         double ppA[3];
1617         double ppB[3];
1618         double d1,d2,d3;
1619         TransfromeCoordViewWorld(xx,yy,zz);
1620
1621 //EED 27 sep 2006
1622         xx = xx * _spc[0];
1623         yy = yy * _spc[1];
1624         zz = zz * _spc[2];
1625
1626     unsigned int i, nps,nps_t;
1627     nps   = _sizePointsContour;
1628         if (this->_manContModel->IfCloseContour()==true)
1629         {
1630                 nps_t = nps;
1631         } else {
1632                 nps_t = nps-1;
1633         }
1634
1635         //ED
1636         printf("\n>%d ",nps_t);
1637
1638         for( i = 0; i < nps_t; i++ )
1639         {
1640                 _pts->GetPoint(i%nps, ppA);
1641                 _pts->GetPoint((i+1)%nps, ppB);
1642                 d1= sqrt( (ppA[0]-xx)*(ppA[0]-xx) + (ppA[1]-yy)*(ppA[1]-yy) + (ppA[2]-zz)*(ppA[2]-zz));
1643                 d2= sqrt( (ppB[0]-xx)*(ppB[0]-xx) + (ppB[1]-yy)*(ppB[1]-yy) + (ppB[2]-zz)*(ppB[2]-zz));
1644                 d3= sqrt( (ppB[0]-ppA[0])*(ppB[0]-ppA[0]) + (ppB[1]-ppA[1])*(ppB[1]-ppA[1]) + (ppB[2]-ppA[2])*(ppB[2]-ppA[2]));
1645
1646                 //ED
1647                 printf("%d %f %f %f - ", i,d1,d2,d3);
1648
1649                 if (  ((d1+d2)>=d3) &&  ((d1+d2)<=d3*1.3) )
1650                 {
1651                         result=true;
1652                         i=nps;
1653                 }
1654         }
1655         return result;
1656 }
1657
1658 // ----------------------------------------------------------------------------
1659 void manualViewContour::DeletePoint(int id) // virtual
1660 {
1661         if (_lstViewPoints.size()>2)
1662         {
1663                 manualViewBaseContour::DeletePoint( id );
1664         }
1665 }
1666 // ----------------------------------------------------------------------------
1667
1668 void manualViewContour::ClearPoint(int id)
1669 {
1670         manualViewBaseContour::DeletePoint( id );
1671 }
1672
1673 //-------------------------------------------------------------------
1674 void manualViewContour::SetMesureScale(double mesureScale)
1675 {
1676         _mesureScale = mesureScale;
1677 }
1678 //-------------------------------------------------------------------
1679 void manualViewContour::InitMove(int x, int y, int z)
1680 {
1681         _initialConoturModel->DeleteAllPoints();
1682
1683         manualPoint *mp = NULL;
1684         double XX=x;
1685         double YY=y;
1686         double ZZ=z;
1687         TransfromeCoordViewWorld(XX,YY,ZZ);
1688
1689         int i, manualPointsSZ = _manContModel->GetSizeLstPoints();
1690         for ( i=0; i<manualPointsSZ; i++ )
1691         {
1692                 mp = _manContModel->GetManualPoint( i );
1693                 this->_initialConoturModel->AddPoint( mp->GetX() - XX, mp->GetY() - YY, mp->GetZ() );
1694         }
1695 }
1696 //-------------------------------------------------------------------
1697 void manualViewContour::MoveContour(int x, int y, int z)
1698 {
1699         manualPoint *mpOrigin = NULL;
1700         manualPoint *mpMoving = NULL;
1701         double XX=x;
1702         double YY=y;
1703         double ZZ=z;
1704
1705         TransfromeCoordViewWorld(XX,YY,ZZ);
1706
1707         int i, manualPointsSZ = _manContModel->GetSizeLstPoints();
1708         for ( i=0; i<manualPointsSZ; i++ )
1709         {
1710                 mpOrigin = _manContModel->GetManualPoint( i );
1711                 mpMoving = _initialConoturModel->GetManualPoint(i);
1712                 mpOrigin->SetPoint( mpMoving->GetX()+XX, mpMoving->GetY() + YY, mpMoving->GetZ() );
1713         }
1714         UpdateViewPoints();
1715 }
1716 void manualViewContour::MoveContour(int horizontalUnits, int verticalUnits )
1717 {
1718         manualPoint *mpOrigin = NULL;
1719
1720         int i, manualPointsSZ = _manContModel->GetSizeLstPoints();
1721         for ( i=0; i<manualPointsSZ; i++ )
1722         {
1723                 mpOrigin = _manContModel->GetManualPoint( i );
1724                 mpOrigin->SetPoint( mpOrigin->GetX()+horizontalUnits, mpOrigin->GetY()+verticalUnits, mpOrigin->GetZ() );
1725         }
1726         UpdateViewPoints();
1727 }
1728 // ----------------------------------------------------------------------------
1729 // ----------------------------------------------------------------------------
1730 // ----------------------------------------------------------------------------
1731
1732
1733 manualView3VContour::manualView3VContour(int type)
1734 {
1735         _type=type;
1736 // JSTG 25-02-08 ------------------------------
1737         //_manContModel= new manualContourModel();
1738 //---------------------------------------------
1739 }
1740 // ----------------------------------------------------------------------------
1741 manualView3VContour::~manualView3VContour()
1742 {
1743 }
1744
1745
1746
1747 // ----------------------------------------------------------------------------
1748 manualView3VContour * manualView3VContour :: Clone()
1749 {
1750         manualView3VContour * clone = new manualView3VContour( GetType() );
1751         CopyAttributesTo(clone);
1752         return clone;
1753 }
1754
1755 // ---------------------------------------------------------------------------
1756
1757 void manualView3VContour::CopyAttributesTo( manualView3VContour * cloneObject)
1758 {
1759         // Fathers object
1760         manualViewContour::CopyAttributesTo(cloneObject);
1761 }
1762
1763 int manualView3VContour::GetType()
1764 {
1765         return _type;
1766 }
1767
1768 // ----------------------------------------------------------------------------
1769 void manualView3VContour::FilterCordinateXYZ(double &x,double &y,double &z)
1770 {
1771         if (_type==0)
1772         {
1773                 x=-1000;
1774         }
1775         if (_type==1)
1776         {
1777                 y=500;
1778         }
1779         if (_type==2)
1780         {
1781                 z=-1000;
1782         }
1783 }
1784 // ----------------------------------------------------------------------------
1785
1786 void manualView3VContour::RefreshContour()  // virtula
1787 {
1788         manualViewContour::RefreshContour();
1789         int i;
1790         double pp[3];
1791 // JSTG 25-02-08 ----------------------------------------
1792         //int nps = GetNumberOfPointsSpline();
1793         int nps = _manContModel->GetNumberOfPointsSpline();
1794 //-------------------------------------------------------
1795         for( i = 0; i < nps; i++ )
1796         {
1797                 _pts->GetPoint( i, pp );
1798                 FilterCordinateXYZ(pp[0],pp[1],pp[2]);
1799
1800 //EED 27 sep 2006
1801                 _pts->SetPoint( i, pp[0] , pp[1] ,pp[2] );
1802         }
1803
1804 }
1805
1806 // ----------------------------------------------------------------------------
1807
1808 void manualView3VContour::UpdateViewPoint(int id){  // virtual
1809         double x,y,z;
1810         manualPoint             *mp             = _manContModel->GetManualPoint(id);
1811         x=mp->GetX();
1812         y=mp->GetY();
1813         z=mp->GetZ();
1814
1815         FilterCordinateXYZ(x,y,z);
1816         _lstViewPoints[id]->SetPositionXY( x , y ,GetRange(), z );
1817 }
1818
1819 // ----------------------------------------------------------------------------
1820
1821 int     manualView3VContour::GetIdPoint(int x, int y, int z) // virtual
1822 {
1823         int ii=-1;
1824         if (_manContModel!=NULL){
1825                 double xx=x;
1826                 double yy=y;
1827                 double zz=z;
1828                 TransfromeCoordViewWorld(xx,yy,zz,-1);
1829                 ii=_manContModel->GetIdPoint(xx,yy,zz,GetRange(),_type);
1830         }
1831         return ii;
1832 }
1833
1834 // ----------------------------------------------------------------------------
1835 bool manualView3VContour::ifTouchContour(int x,int y,int z){ // virtual
1836         bool result=false;
1837         double xx=x;
1838         double yy=y;
1839         double zz=z;
1840         double ppA[3];
1841         double ppB[3];
1842         double d1,d2,d3;
1843         TransfromeCoordViewWorld(xx,yy,zz,-1);
1844
1845 //EED 27 sep 2006
1846         xx = xx * _spc[0];
1847         yy = yy * _spc[1];
1848         zz = zz * _spc[2];
1849
1850     unsigned int i, nps,nps_t;
1851     nps   = _sizePointsContour;
1852         if (this->_manContModel->IfCloseContour()==true)
1853         {
1854                 nps_t = nps;
1855         } else {
1856                 nps_t = nps-1;
1857         }
1858         FilterCordinateXYZ(xx,yy,zz);
1859
1860     for( i = 0; i < nps_t; i++ ) {
1861                 _pts->GetPoint(i%nps, ppA);
1862                 _pts->GetPoint((i+1)%nps, ppB);
1863                 FilterCordinateXYZ(ppA[0],ppA[1],ppA[2]);
1864                 FilterCordinateXYZ(ppB[0],ppB[1],ppB[2]);
1865                 d1= sqrt( (ppA[0]-xx)*(ppA[0]-xx) + (ppA[1]-yy)*(ppA[1]-yy) + (ppA[2]-zz)*(ppA[2]-zz));
1866                 d2= sqrt( (ppB[0]-xx)*(ppB[0]-xx) + (ppB[1]-yy)*(ppB[1]-yy) + (ppB[2]-zz)*(ppB[2]-zz));
1867                 d3= sqrt( (ppB[0]-ppA[0])*(ppB[0]-ppA[0]) + (ppB[1]-ppA[1])*(ppB[1]-ppA[1]) + (ppB[2]-ppA[2])*(ppB[2]-ppA[2]));
1868                 if (  ((d1+d2)>=d3) &&  ((d1+d2)<=d3*1.3) ) {
1869                         result=true;
1870                         i=nps;
1871                 }
1872         }
1873         return result;
1874 }
1875 // ----------------------------------------------------------------------------
1876 // ----------------------------------------------------------------------------
1877 // ----------------------------------------------------------------------------
1878 manualView3DContour::manualView3DContour()
1879 {
1880 }
1881 // ----------------------------------------------------------------------------
1882 manualView3DContour::~manualView3DContour()
1883 {
1884 }
1885
1886 // ----------------------------------------------------------------------------
1887 manualView3DContour * manualView3DContour :: Clone()
1888 {
1889         manualView3DContour * clone = new manualView3DContour();
1890         CopyAttributesTo(clone);
1891         return clone;
1892 }
1893
1894 // ---------------------------------------------------------------------------
1895 void manualView3DContour::CopyAttributesTo( manualView3DContour * cloneObject)
1896 {
1897         // Fathers object
1898         manualViewContour::CopyAttributesTo(cloneObject);
1899
1900         cloneObject->SetDimensions ( _w , _h , _d );
1901 }
1902 // ----------------------------------------------------------------------------
1903 void manualView3DContour::SetDimensions(int w, int h, int d)
1904 {
1905         _w = w;
1906         _h = h;
1907         _d = d;
1908 }
1909 // ----------------------------------------------------------------------------
1910 void manualView3DContour::TransfromeCoordViewWorld(double &X, double &Y, double &Z, int type)
1911 {
1912         X = _vtkmprbasedata->GetX();
1913         Y = _vtkmprbasedata->GetY();
1914         Z = _vtkmprbasedata->GetZ();
1915 }
1916 // ----------------------------------------------------------------------------
1917 void manualView3DContour::SetVtkMPRBaseData(vtkMPRBaseData *vtkmprbasedata)
1918 {
1919         _vtkmprbasedata = vtkmprbasedata;
1920 }
1921 // ----------------------------------------------------------------------------
1922 int manualView3DContour::GetIdPoint2(int x, int y)
1923 {
1924         int id = -1;
1925         double p[3],pA[3],pB[3];
1926
1927         double pickPoint[ 3 ], cameraPos[ 3 ];
1928         vtkPointPicker* picker = vtkPointPicker::New( );
1929         vtkRenderer *pRenderer = this->GetWxVtkBaseView()->GetRenderer();
1930         picker->Pick( x, y, 0.0, pRenderer );
1931         pRenderer->GetActiveCamera( )->GetPosition( cameraPos );
1932         picker->GetPickPosition( pickPoint );
1933         picker->Delete( );
1934
1935         UtilVtk3DGeometriSelection utilVtk3Dgeometriselection;
1936         utilVtk3Dgeometriselection.SetDimentions(_w,_h,_d);
1937
1938         if( utilVtk3Dgeometriselection.FindCubePointsFromPoints( pA, pB, pickPoint, cameraPos )  )
1939         {
1940                 double dist,distMin=999999999;
1941                 int i,size=this->_manContModel->GetSizeLstPoints();
1942                 for (i=0;i<size;i++)
1943                 {
1944                         manualPoint *mp = this->_manContModel->GetManualPoint(i);
1945                         p[0] = mp->GetX();
1946                         p[1] = mp->GetY();
1947                         p[2] = mp->GetZ();
1948                         dist=utilVtk3Dgeometriselection.DistanceMinPointToLine(p,pA,pB);
1949                         if ( (dist<=2*GetRange()) && (dist<distMin) )
1950                         {
1951                                 distMin = dist;
1952                                 id              = i;
1953                         }
1954                 }
1955         }
1956         return id;
1957 }
1958 // ----------------------------------------------------------------------------
1959 int manualView3DContour::SelectPosiblePoint ( int x, int y, int z )// virtual
1960 {
1961         SelectAllPossibleSelected(false);
1962         int id=GetIdPoint2(x,y);
1963         if (id!=-1)
1964         {
1965                 SetPointPosibleSelected(id,true);
1966         }
1967         return id;
1968 }
1969
1970
1971
1972
1973 // ----------------------------------------------------------------------------
1974 // ----------------------------------------------------------------------------
1975 // ----------------------------------------------------------------------------
1976
1977
1978
1979
1980 // ----------------------------------------------------------------------------
1981 // ----------------------------------------------------------------------------
1982 // ----------------------------------------------------------------------------
1983 manualViewBullEyeSector::manualViewBullEyeSector()
1984 {
1985 }
1986
1987 // ----------------------------------------------------------------------------
1988 void manualViewBullEyeSector::RefreshContour()
1989 {
1990 //EED004
1991         int i,nps;
1992         double x,y,z;
1993 //----------------------------------
1994
1995         _manContModel->UpdateSpline();
1996     nps = _manContModel->GetNumberOfPointsSpline();
1997
1998         if ( _pts!=NULL )
1999         {
2000                 for( i = 0; i < nps; i++ )
2001                 {
2002                         _manContModel->GetSpline_i_Point(i,&x,&y,&z);
2003                         _pts->SetPoint(i , x*_spc[0] , y*_spc[1] , z*_spc[2] );
2004                 }// for
2005         }
2006
2007 }
2008
2009 // ----------------------------------------------------------------------------
2010 // ----------------------------------------------------------------------------
2011 // ----------------------------------------------------------------------------
2012
2013
2014 manualViewBullEye::manualViewBullEye()
2015 {
2016 }
2017
2018 // ----------------------------------------------------------------------------
2019 manualViewBullEye::~manualViewBullEye()
2020 {
2021         // BullEye(s)
2022         int i,size=lstSectorBullEye.size();
2023         for (i=0;i<size;i++)
2024         {
2025                 delete lstSectorBullEye[i];
2026         }
2027         lstSectorBullEye.clear();
2028 }
2029
2030
2031 // ----------------------------------------------------------------------------
2032 manualViewBullEye * manualViewBullEye :: Clone()
2033 {
2034         manualViewBullEye * clone = new manualViewBullEye();
2035         CopyAttributesTo(clone);
2036         return clone;
2037 }
2038
2039 // ---------------------------------------------------------------------------
2040
2041 void manualViewBullEye::CopyAttributesTo( manualViewBullEye * cloneObject)
2042 {
2043         // Fathers object
2044         manualViewBaseContour::CopyAttributesTo(cloneObject);
2045 }
2046
2047
2048 // ----------------------------------------------------------------------------
2049 int manualViewBullEye::GetType() // virtual
2050 {
2051         return 4;
2052 }
2053
2054
2055 // ----------------------------------------------------------------------------
2056 void manualViewBullEye::RefreshContour() // virtual
2057 {
2058         // External Rectangle
2059         manualViewRoi::RefreshContour();
2060
2061         _manContModel->UpdateSpline();
2062     int np      = GetNumberOfPoints( );
2063         // Refres sectors of BullEye(s)
2064
2065         if (np>=2  )
2066         {
2067                 int i,size = lstSectorBullEye.size();
2068                 for (i=0;i<size;i++)
2069                 {
2070                         lstSectorBullEye[i]->RefreshContour();
2071                 } // for
2072         } // if
2073
2074
2075 }
2076
2077 // ----------------------------------------------------------------------------
2078 void manualViewBullEye::ConstructVTKObjects() // virtual
2079 {
2080         manualViewRoi::ConstructVTKObjects();
2081
2082         double spc[3];
2083         this->GetSpacing(spc);
2084         manualViewBullEyeSector *mvbc;
2085         manualContourModelBullEye *mcmbe = (manualContourModelBullEye*)this->_manContModel;
2086         int i,size = mcmbe->GetSizeOfSectorLst();
2087         for ( i=0 ; i<size ; i++ )
2088         {
2089                 mvbc = new manualViewBullEyeSector();
2090                 mvbc->SetModel( mcmbe->GetModelSector(i) );
2091                 mvbc->SetWxVtkBaseView( this->GetWxVtkBaseView()  );
2092                 mvbc->SetRange( 2 );
2093                 mvbc->SetZ( 1000 );
2094                 mvbc->SetSpacing(spc);
2095                 mvbc->SetColorNormalContour(1, 0, 0);
2096 //              mvbc->SetColorEditContour(0.5, 0.5, 0.5);
2097 //              mvbc->SetColorSelectContour(1, 0.8, 0);
2098                 mvbc->SetWidthLine( this->GetWidthLine()  );
2099 //EED004
2100                 mvbc->ConstructVTKObjects();
2101                 lstSectorBullEye.push_back( mvbc );
2102         }
2103
2104
2105 }
2106
2107 // ----------------------------------------------------------------------------
2108 void manualViewBullEye::AddSplineActor()  // virtual
2109 {
2110         manualViewRoi::AddSplineActor();
2111         int i,size=lstSectorBullEye.size();
2112         for (i=0;i<size;i++)
2113         {
2114                 lstSectorBullEye[i]->AddSplineActor();
2115         }
2116 }
2117
2118 // ----------------------------------------------------------------------------
2119 void manualViewBullEye::RemoveSplineActor()  // virtual
2120 {
2121         manualViewRoi::RemoveSplineActor();
2122         int i,size=lstSectorBullEye.size();
2123         for (i=0;i<size;i++)
2124         {
2125                 lstSectorBullEye[i]->RemoveSplineActor();
2126         }
2127 }
2128
2129
2130 // ----------------------------------------------------------------------------
2131 // ----------------------------------------------------------------------------
2132 // ----------------------------------------------------------------------------
2133
2134 manualViewRoi::manualViewRoi()
2135 {
2136         _sizePointsContour=5;
2137 }
2138 // ----------------------------------------------------------------------------
2139 manualViewRoi::~manualViewRoi()
2140 {
2141 }
2142
2143
2144 // ----------------------------------------------------------------------------
2145 manualViewRoi * manualViewRoi :: Clone()
2146 {
2147         manualViewRoi * clone = new manualViewRoi();
2148         CopyAttributesTo(clone);
2149         return clone;
2150 }
2151
2152 // ---------------------------------------------------------------------------
2153
2154 void manualViewRoi::CopyAttributesTo( manualViewRoi * cloneObject)
2155 {
2156         // Fathers object
2157         manualViewBaseContour::CopyAttributesTo(cloneObject);
2158 }
2159
2160 // ----------------------------------------------------------------------------
2161 void manualViewRoi::RefreshContour() // virtual
2162 {
2163     unsigned int i,ii, np;
2164     np  = GetNumberOfPoints( );
2165         if ( np > 0)
2166         {
2167                 if (np>=2)
2168                 {
2169                         manualPoint     *mp;
2170                         for( i = 0; i < np+1; i++ ) {
2171                                 ii=i%np;
2172                                 mp = _manContModel->GetManualPoint(ii);
2173
2174         //EEDx6
2175                                 double XX=mp->GetX(),YY=mp->GetY(),ZZ=mp->GetZ();
2176         //                      wxVtk2DBaseView *wxvtk2Dbasevie = (wxVtk2DBaseView*)this->GetWxVtkBaseView();
2177         //                      wxvtk2Dbasevie->TransformCoordinate_spacing_ModelToView(XX,YY,ZZ);
2178
2179         //EED 27 sep 2007
2180         //                      _pts->SetPoint(i, XX,YY,ZZ );
2181                                 _pts->SetPoint(i, XX*_spc[0] , YY*_spc[1] , ZZ*_spc[2] );
2182                         } //  rof
2183
2184                 } else {
2185                                 _pts->SetPoint(0, 0 , 0 , 0);
2186                                 _pts->SetPoint(1, 0 , 0 , 0);
2187                 } // if
2188         }
2189 }
2190
2191 // ----------------------------------------------------------------------------
2192 int manualViewRoi::GetType() // virtual
2193 {
2194         return 2;
2195 }
2196
2197 // ----------------------------------------------------------------------------
2198
2199 void manualViewRoi::GetMinMax(double &minX,double &minY, double &maxX, double &maxY)
2200 {
2201         double  pp[3];
2202         manualPoint *mp;
2203     unsigned int i;
2204
2205         minX=99999;
2206         minY=99999;
2207         maxX=-99999;
2208         maxY=-99999;
2209
2210         unsigned int size=(unsigned int) _manContModel->GetSizeLstPoints();
2211
2212         for( i = 0; i < size; i++ )
2213         {
2214
2215                 mp=_manContModel->GetManualPoint(i);
2216                 pp[0]=mp->GetX();
2217                 pp[1]=mp->GetY();
2218
2219                 // min X
2220                 if (pp[0]<minX)
2221                 {
2222                         minX=pp[0];
2223                 }
2224                 //min Y
2225                 if (pp[1]<minY)
2226                 {
2227                         minY=pp[1];
2228                 }
2229                 //max X
2230                 if (pp[0]>maxX)
2231                 {
2232                         maxX=pp[0];
2233                 }
2234                 // max Y
2235                 if (pp[1]>maxY)
2236                 {
2237                         maxY=pp[1];
2238                 }
2239         }
2240
2241         if ( size<1 )
2242         {
2243                 minX=0;
2244                 maxX=0;
2245                 minY=0;
2246                 maxY=0;
2247         }
2248 }
2249
2250 // ----------------------------------------------------------------------------
2251
2252 bool manualViewRoi::ifTouchContour(int x,int y, int z) // virtual
2253 {
2254         bool    result=false;
2255         double  px1=99999,py1=99999,px2=-9999,py2=-99999;
2256
2257         GetMinMax(px1,py1, px2, py2);
2258
2259         double xx=x;
2260         double yy=y;
2261         double zz=z;
2262         TransfromeCoordViewWorld(xx,yy,zz);
2263
2264         bool ok1=false;
2265         bool ok2=false;
2266         double ddx=GetRange();
2267         double ddy=GetRange();
2268
2269         if ((xx>px1-ddx)&&(xx<px2+ddx) &&  (yy>py1-ddy)&&(yy<py2+ddy))
2270         {
2271                 ok1=true;
2272         }
2273
2274         if ((xx>px1+ddx)&&(xx<px2-ddx) &&  (yy>py1+ddy)&&(yy<py2-ddy))
2275         {
2276                 ok2=true;
2277         }
2278
2279         if ((ok1==true) && (ok2==false))
2280         {
2281                 result=true;
2282         }
2283
2284         return result;
2285 }
2286
2287
2288 // ----------------------------------------------------------------------------
2289
2290 void manualViewRoi::InitMove(int x, int y, int z)  // virtual
2291 {
2292         manualPoint *mp;
2293         double XX=x;
2294         double YY=y;
2295         double ZZ=z;
2296         TransfromeCoordViewWorld(XX,YY,ZZ);
2297
2298         if (_manContModel->GetSizeLstPoints()==4){
2299                 mp = _manContModel->GetManualPoint(0);
2300                 _dp0[0]= mp->GetX() - XX;
2301                 _dp0[1]= mp->GetY() - YY;
2302                 _dp0[2]= mp->GetZ();
2303
2304                 mp = _manContModel->GetManualPoint(1);
2305                 _dp1[0]= mp->GetX() - XX;
2306                 _dp1[1]= mp->GetY() - YY;
2307                 _dp1[2]= mp->GetZ();
2308
2309                 mp = _manContModel->GetManualPoint(2);
2310                 _dp2[0]= mp->GetX() - XX;
2311                 _dp2[1]= mp->GetY() - YY;
2312                 _dp2[2]= mp->GetZ();
2313
2314                 mp = _manContModel->GetManualPoint(3);
2315                 _dp3[0]= mp->GetX() - XX;
2316                 _dp3[1]= mp->GetY() - YY;
2317                 _dp3[2]= mp->GetZ();
2318         }
2319 }
2320
2321 // ----------------------------------------------------------------------------
2322
2323 void manualViewRoi::MoveContour(int x, int y, int z) // virtual
2324 {
2325         manualPoint *mp;
2326         double XX=x;
2327         double YY=y;
2328         double ZZ=z;
2329         TransfromeCoordViewWorld(XX,YY,ZZ);
2330
2331         mp = _manContModel->GetManualPoint(0);
2332         mp->SetPoint(_dp0[0]+XX,_dp0[1]+YY,_dp0[2]);
2333
2334         mp = _manContModel->GetManualPoint(1);
2335         mp->SetPoint(_dp1[0]+XX,_dp1[1]+YY,_dp0[2]);
2336
2337         mp = _manContModel->GetManualPoint(2);
2338         mp->SetPoint(_dp2[0]+XX,_dp2[1]+YY,_dp0[2]);
2339
2340         mp = _manContModel->GetManualPoint(3);
2341         mp->SetPoint(_dp3[0]+XX,_dp3[1]+YY,_dp0[2]);
2342
2343         UpdateViewPoint(0);
2344         UpdateViewPoint(1);
2345         UpdateViewPoint(2);
2346         UpdateViewPoint(3);
2347
2348 }
2349
2350
2351
2352 // ----------------------------------------------------------------------------
2353 // ----------------------------------------------------------------------------
2354 // ----------------------------------------------------------------------------
2355
2356 // EED08
2357
2358 manualViewCircle::manualViewCircle()
2359 {
2360 //      _sizePointsContour=5;   // default 100
2361 }
2362 // ----------------------------------------------------------------------------
2363 manualViewCircle::~manualViewCircle()
2364 {
2365 }
2366
2367
2368 // ----------------------------------------------------------------------------
2369 manualViewCircle * manualViewCircle :: Clone()
2370 {
2371         manualViewCircle * clone = new manualViewCircle();
2372         CopyAttributesTo(clone);
2373         return clone;
2374 }
2375
2376 // ---------------------------------------------------------------------------
2377
2378 void manualViewCircle::CopyAttributesTo( manualViewCircle * cloneObject)
2379 {
2380         // Fathers object
2381         manualViewBaseContour::CopyAttributesTo(cloneObject);
2382 }
2383
2384
2385 // ----------------------------------------------------------------------------
2386 /*
2387 void manualViewCircle::RefreshContour(){ // virtual
2388
2389         manualPoint     *mpA,*mpB;
2390     unsigned int i, np,nps;
2391         double angle,radio;
2392         double difX,difY;
2393         double XX,YY,ZZ;
2394     np  = GetNumberOfPoints( );
2395         nps = _manContModel->GetNumberOfPointsSpline();
2396         double deltaAngle=(3.14159265*2)/(nps-1);
2397         if ( np > 0)
2398         {
2399                 if (np==2)
2400                 {
2401                         mpA             = _manContModel->GetManualPoint(0);
2402                         mpB             = _manContModel->GetManualPoint(1);
2403                         difX    = mpA->GetX() - mpB->GetX();
2404                         difY    = mpA->GetY() - mpB->GetY();
2405                         radio   = sqrt( difX*difX + difY*difY );
2406                         manualContourModelCircle *manContModelCir = (manualContourModelCircle*)_manContModel;
2407                         manContModelCir->SetRadio(radio);
2408
2409                         for( i = 0; i < nps; i++ ) {
2410                                 manContModelCir->GetSpline_i_Point(i, &XX, &YY, &ZZ);
2411 //                              angle = deltaAngle*i;
2412 //                              XX = cos(angle)*radio+mpA->GetX();
2413 //                              YY = sin(angle)*radio+mpA->GetY();
2414                                 ZZ = mpA->GetZ();
2415                                 _pts->SetPoint(i, XX*_spc[0] , YY*_spc[1] , ZZ*_spc[2] );
2416                         } //  rof
2417                 } else {
2418                                 _pts->SetPoint(0, 0 , 0 , 0);
2419                                 _pts->SetPoint(1, 0 , 0 , 0);
2420                 } // if
2421         }
2422 }
2423 */
2424
2425 // ----------------------------------------------------------------------------
2426 int manualViewCircle::GetType() // virtual
2427 {
2428         return 3;
2429 }
2430
2431 // ----------------------------------------------------------------------------
2432
2433 void manualViewCircle::GetMinMax(double &minX,double &minY, double &maxX, double &maxY)
2434 {
2435         manualPoint     *mpA,*mpB;
2436     unsigned int  np;
2437         double radio;
2438         double difX,difY;
2439     np  = GetNumberOfPoints( );
2440         if (np==2)
2441         {
2442                 mpA             = _manContModel->GetManualPoint(0);
2443                 mpB             = _manContModel->GetManualPoint(1);
2444                 difX    = mpA->GetX() - mpB->GetX();
2445                 difY    = mpA->GetY() - mpB->GetY();
2446                 radio   = sqrt( difX*difX + difY*difY );
2447                 minX=mpA->GetX()-radio;
2448                 minY=mpA->GetY()-radio;
2449                 maxX=mpA->GetX()+radio;
2450                 maxY=mpA->GetY()+radio;
2451         } else {
2452                 minX=0;
2453                 maxX=0;
2454                 minY=0;
2455                 maxY=0;
2456         }
2457 }
2458
2459 /*
2460 // ----------------------------------------------------------------------------
2461 bool manualViewCircle::ifTouchContour(int x,int y, int z) // virtual
2462 {
2463         bool    result=false;
2464         double  px1=99999,py1=99999,px2=-9999,py2=-99999;
2465
2466         GetMinMax(px1,py1, px2, py2);
2467
2468         double xx=x;
2469         double yy=y;
2470         double zz=z;
2471         TransfromeCoordViewWorld(xx,yy,zz);
2472
2473         bool ok1=false;
2474         bool ok2=false;
2475         double ddx=GetRange();
2476         double ddy=GetRange();
2477
2478         if ((xx>px1-ddx)&&(xx<px2+ddx) &&  (yy>py1-ddy)&&(yy<py2+ddy))
2479         {
2480                 ok1=true;
2481         }
2482
2483         if ((xx>px1+ddx)&&(xx<px2-ddx) &&  (yy>py1+ddy)&&(yy<py2-ddy))
2484         {
2485                 ok2=true;
2486         }
2487
2488         if ((ok1==true) && (ok2==false))
2489         {
2490                 result=true;
2491         }
2492
2493         return result;
2494 }
2495 */
2496
2497 // ----------------------------------------------------------------------------
2498
2499 void manualViewCircle::InitMove(int x, int y, int z)  // virtual
2500 {
2501         manualPoint *mp;
2502         double XX=x;
2503         double YY=y;
2504         double ZZ=z;
2505         TransfromeCoordViewWorld(XX,YY,ZZ);
2506
2507         if (_manContModel->GetSizeLstPoints()==2){
2508                 mp = _manContModel->GetManualPoint(0);
2509                 _dp0[0]= mp->GetX() - XX;
2510                 _dp0[1]= mp->GetY() - YY;
2511                 _dp0[2]= mp->GetZ();
2512
2513                 mp = _manContModel->GetManualPoint(1);
2514                 _dp1[0]= mp->GetX() - XX;
2515                 _dp1[1]= mp->GetY() - YY;
2516                 _dp1[2]= mp->GetZ();
2517 /*
2518                 mp = _manContModel->GetManualPoint(2);
2519                 _dp2[0]= mp->GetX() - XX;
2520                 _dp2[1]= mp->GetY() - YY;
2521                 _dp2[2]= mp->GetZ();
2522
2523                 mp = _manContModel->GetManualPoint(3);
2524                 _dp3[0]= mp->GetX() - XX;
2525                 _dp3[1]= mp->GetY() - YY;
2526                 _dp3[2]= mp->GetZ();
2527 */
2528         }
2529 }
2530
2531
2532 // ----------------------------------------------------------------------------
2533 void manualViewCircle::MoveContour(int x, int y, int z) // virtual
2534 {
2535         manualPoint *mp;
2536         double XX=x;
2537         double YY=y;
2538         double ZZ=z;
2539         TransfromeCoordViewWorld(XX,YY,ZZ);
2540
2541         mp = _manContModel->GetManualPoint(0);
2542         mp->SetPoint(_dp0[0]+XX,_dp0[1]+YY,_dp0[2]);
2543
2544         mp = _manContModel->GetManualPoint(1);
2545         mp->SetPoint(_dp1[0]+XX,_dp1[1]+YY,_dp0[2]);
2546
2547 //      mp = _manContModel->GetManualPoint(2);
2548 //      mp->SetPoint(_dp2[0]+XX,_dp2[1]+YY,_dp0[2]);
2549
2550 //      mp = _manContModel->GetManualPoint(3);
2551 //      mp->SetPoint(_dp3[0]+XX,_dp3[1]+YY,_dp0[2]);
2552
2553         UpdateViewPoint(0);
2554         UpdateViewPoint(1);
2555 //      UpdateViewPoint(2);
2556 //      UpdateViewPoint(3);
2557
2558 }
2559
2560
2561
2562 // ----------------------------------------------------------------------------
2563 // ----------------------------------------------------------------------------
2564 // ----------------------------------------------------------------------------
2565
2566 // AD:02-09
2567
2568 manualViewLine::manualViewLine()
2569 {
2570 }
2571 // ----------------------------------------------------------------------------
2572 manualViewLine::~manualViewLine()
2573 {
2574 }
2575
2576
2577 // ----------------------------------------------------------------------------
2578 manualViewLine * manualViewLine :: Clone()
2579 {
2580         manualViewLine * clone = new manualViewLine();
2581         CopyAttributesTo(clone);
2582         return clone;
2583 }
2584
2585 // ---------------------------------------------------------------------------
2586
2587 void manualViewLine::CopyAttributesTo( manualViewLine * cloneObject)
2588 {
2589         // Fathers object
2590         manualViewBaseContour::CopyAttributesTo(cloneObject);
2591 }
2592
2593 // ----------------------------------------------------------------------------
2594 int manualViewLine::GetType() // virtual
2595 {
2596         return 6;
2597 }
2598
2599
2600 // ----------------------------------------------------------------------------
2601
2602 void manualViewLine::InitMove(int x, int y, int z)  // virtual
2603 {
2604         manualPoint *mp;
2605         double XX=x;
2606         double YY=y;
2607         double ZZ=z;
2608         TransfromeCoordViewWorld(XX,YY,ZZ);
2609
2610         if (_manContModel->GetSizeLstPoints()==2)
2611         {
2612                 mp = _manContModel->GetManualPoint(0);
2613                 _dp0[0]= mp->GetX() - XX;
2614                 _dp0[1]= mp->GetY() - YY;
2615                 _dp0[2]= mp->GetZ();
2616
2617                 mp = _manContModel->GetManualPoint(1);
2618                 _dp1[0]= mp->GetX() - XX;
2619                 _dp1[1]= mp->GetY() - YY;
2620                 _dp1[2]= mp->GetZ();
2621
2622         }
2623 }
2624
2625
2626 // ----------------------------------------------------------------------------
2627 void manualViewLine::MoveContour(int x, int y, int z) // virtual
2628 {
2629         manualPoint *mp;
2630         double XX=x;
2631         double YY=y;
2632         double ZZ=z;
2633         TransfromeCoordViewWorld(XX,YY,ZZ);
2634
2635         mp = _manContModel->GetManualPoint(0);
2636         mp->SetPoint(_dp0[0]+XX,_dp0[1]+YY,_dp0[2]);
2637
2638         mp = _manContModel->GetManualPoint(1);
2639         mp->SetPoint(_dp1[0]+XX,_dp1[1]+YY,_dp0[2]);
2640
2641
2642         UpdateViewPoint(0);
2643         UpdateViewPoint(1);
2644 }
2645
2646
2647 // ----------------------------------------------------------------------------
2648 // ----------------------------------------------------------------------------
2649 // ----------------------------------------------------------------------------
2650
2651
2652 manualViewBaseContour::manualViewBaseContour()
2653 {
2654         _show_text                      = true;
2655         _textActor                      = NULL;
2656         _manContModel           = NULL;
2657         _wxvtkbaseview          = NULL;
2658         _selected                       = false;
2659         _posibleSelected        = false;
2660         _viewControlPoints      = false;
2661         _pts                            = NULL;
2662         _pd                                     = NULL;
2663         _contourVtkActor        = NULL;
2664         _bboxMapper                     = NULL;
2665         _range                          = 1;
2666         _sizePointsContour      = 100;
2667         _spc[0]                         = 1;
2668         _spc[1]                         = 1;
2669         _spc[2]                         = 1;
2670
2671         _coulorEdit_r           = 1;
2672         _coulorEdit_g           = 1;
2673         _coulorEdit_b           = 0;
2674
2675         _coulorNormal_r         = 1;
2676         _coulorNormal_g         = 0;
2677         _coulorNormal_b         = 1;
2678
2679         _coulorSelection_r      = 0;
2680         _coulorSelection_g      = 1;
2681         _coulorSelection_b      = 0;
2682
2683         _widthline                      = 1;
2684
2685 }
2686 // ----------------------------------------------------------------------------
2687 manualViewBaseContour::~manualViewBaseContour()
2688 {
2689         int i,size=_lstViewPoints.size();
2690         for (i=0;i<size; i++){
2691                 delete _lstViewPoints[i];
2692         }
2693         _lstViewPoints.clear();
2694 }
2695 // ----------------------------------------------------------------------------
2696
2697
2698 int manualViewBaseContour::GetType() // virtual
2699 {
2700 // Information...
2701 //int manualViewBaseContour::GetType()          0;
2702 //int manualViewContour::GetType()                      1;
2703 //int manualViewRoi::GetType()                          2;
2704 //int manualViewCircle::GetType()                       3;
2705 //int manualViewStar::GetType()                         4;
2706 //int manualViewLine::GetType()                         6;
2707
2708
2709         return 0;
2710 }
2711 // ----------------------------------------------------------------------------
2712
2713 void manualViewBaseContour::Save(FILE *pFile)
2714 {
2715         fprintf(pFile,"TypeView %d\n", GetType() );
2716 }
2717
2718 // ----------------------------------------------------------------------------
2719 void manualViewBaseContour::Open(FILE *pFile)
2720 {
2721 }
2722
2723 // ----------------------------------------------------------------------------
2724 void manualViewBaseContour :: AddCompleteContourActor(  bool ifControlPoints )
2725 {
2726         _viewControlPoints = ifControlPoints;
2727          /*vtkRenderer * theRenderer = */  _wxvtkbaseview->GetRenderer();  // JPRx ??
2728          //Adding the spline
2729          AddSplineActor();
2730
2731          AddTextActor();
2732          //Adding each control point
2733          if( ifControlPoints )
2734                 AddControlPoints();
2735          RefreshContour();
2736          Refresh();
2737 }
2738 // ---------------------------------------------------------------------------
2739
2740 void manualViewBaseContour :: RemoveCompleteContourActor()
2741 {
2742         /*vtkRenderer * theRenderer =*/  _wxvtkbaseview->GetRenderer(); // JPRx ??
2743          //Removing the spline
2744         RemoveSplineActor();
2745         RemoveTextActor();
2746
2747         //Removing each point
2748         RemoveControlPoints();
2749         RefreshContour();
2750         Refresh();
2751 }
2752 // ---------------------------------------------------------------------------
2753 manualViewBaseContour *  manualViewBaseContour :: Clone( )//virtual
2754 {
2755         manualViewBaseContour * clone = new manualViewBaseContour();
2756         CopyAttributesTo(clone);
2757         return clone;
2758
2759 }
2760
2761 // ---------------------------------------------------------------------------
2762
2763 void manualViewBaseContour::CopyAttributesTo( manualViewBaseContour * cloneObject)
2764 {
2765         // Fathers object
2766         //XXXX::CopyAttributesTo(cloneObject);
2767
2768         cloneObject-> SetWxVtkBaseView( this->_wxvtkbaseview );
2769         cloneObject-> SetSelected( this->GetSelected() );
2770         cloneObject-> SetPosibleSelected( this->GetPosibleSelected() );
2771         cloneObject-> SetIfViewControlPoints( this->GetIfViewControlPoints() );
2772         cloneObject-> SetRange( this->GetRange() );
2773         cloneObject-> SetZ( this->GetZ() );
2774         cloneObject-> SetSpacing( _spc );
2775         cloneObject-> SetColorNormalContour( _coulorNormal_r, _coulorNormal_g, _coulorNormal_b );
2776         cloneObject-> SetColorEditContour( _coulorEdit_r, _coulorEdit_g, _coulorEdit_b );
2777         cloneObject-> SetColorSelectContour( _coulorSelection_r, _coulorSelection_g, _coulorSelection_b );
2778
2779         int i, size = _lstViewPoints.size();
2780         for ( i=0; i<size; i++ )
2781         {
2782                 cloneObject->AddPoint(  );
2783         }
2784 }
2785
2786 // ----------------------------------------------------------------------------
2787 void manualViewBaseContour :: AddSplineActor()
2788 {
2789         vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
2790         if (_contourVtkActor!=NULL)
2791                 theRenderer->AddActor( _contourVtkActor  );
2792 }
2793 // ----------------------------------------------------------------------------
2794 void manualViewBaseContour :: RemoveSplineActor() // virtual
2795 {
2796         vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
2797         if (_contourVtkActor!=NULL)
2798                 theRenderer->RemoveActor( _contourVtkActor );
2799 }
2800 // ----------------------------------------------------------------------------
2801 void manualViewBaseContour :: RemoveControlPoints()
2802 {
2803         if (_wxvtkbaseview!=NULL){
2804                 vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
2805                 int i,size=_lstViewPoints.size();
2806                 for (i=0;i<size; i++)
2807                 {
2808                         vtkActor * pointActor = _lstViewPoints[i]->GetVtkActor();
2809                         theRenderer->RemoveActor( pointActor );
2810                 } // for
2811         } // if
2812         SetIfViewControlPoints( false );
2813 }
2814 // ----------------------------------------------------------------------------
2815 void manualViewBaseContour :: AddControlPoints()
2816 {
2817         vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
2818         SetIfViewControlPoints( true );
2819          if( _viewControlPoints )
2820          {
2821                 int i,size=_lstViewPoints.size();
2822                 for (i=0;i<size; i++)
2823                 {
2824                         vtkActor * pointActor = _lstViewPoints[i]->GetVtkActor();
2825                         theRenderer->AddActor( pointActor );
2826                 }
2827          }
2828 }
2829 // ----------------------------------------------------------------------------
2830 void manualViewBaseContour::AddTextActor()
2831 {
2832         _wxvtkbaseview->GetRenderer()->AddActor2D( _textActor );
2833 }
2834 // ----------------------------------------------------------------------------
2835 void manualViewBaseContour::RemoveTextActor()
2836 {
2837         _wxvtkbaseview->GetRenderer()->RemoveActor2D( _textActor );
2838 }
2839 // ----------------------------------------------------------------------------
2840 void manualViewBaseContour::DeleteVtkObjects()
2841 {
2842         if ( _contourVtkActor   != NULL )       { _contourVtkActor  -> Delete(); }
2843         if ( _bboxMapper                != NULL )       { _bboxMapper           -> Delete(); }
2844         if ( _pts                               != NULL )       { _pts                          -> Delete(); }
2845         if ( _pd                                != NULL )       { _pd                           -> Delete(); }
2846         _contourVtkActor        = NULL;
2847         _bboxMapper                     = NULL;
2848         _pts                            = NULL;
2849         _pd                                     = NULL;
2850 }
2851
2852
2853 // ----------------------------------------------------------------------------
2854 void manualViewBaseContour::SetWidthLine(double width)
2855 {
2856         _widthline = width;
2857         this->UpdateColorActor();
2858
2859         // for the control points
2860         int id, size = _lstViewPoints.size();
2861         for( id=0; id<size; id++)
2862         {
2863                 this->_lstViewPoints[id]->SetWidthLine(_widthline);
2864         }
2865
2866 }
2867
2868 // ----------------------------------------------------------------------------
2869 double manualViewBaseContour::GetWidthLine()
2870 {
2871         return _widthline;
2872 }
2873
2874 // ----------------------------------------------------------------------------
2875 void manualViewBaseContour::ConstructVTKObjects()
2876 {
2877 //JSTG 29-02-08 -----------------------------------------------
2878         //int i , nps = _sizePointsContour;
2879         int i;
2880         int nps = _manContModel->GetNumberOfPointsSpline();
2881 //-------------------------------------------------------------
2882         DeleteVtkObjects();
2883         _pts = vtkPoints::New();
2884         _pts->SetNumberOfPoints(nps);
2885
2886         for (i=0 ; i<nps ; i++){
2887                 _pts->SetPoint(i,       0       , 0     , 0 );
2888         }
2889         // This is for the boundaring inicialisation
2890         _pts->SetPoint(0,       -1000   , -1000 , -1000 );
2891         _pts->SetPoint(1,       1000    , 1000  , 1000 );
2892
2893         vtkCellArray *lines = vtkCellArray::New();
2894         lines->InsertNextCell( nps /* +1 */ );
2895         for ( i=0 ; i<nps+1 ; i++ ){
2896                 lines->InsertCellPoint(i % nps );
2897         }
2898
2899         _pd = vtkPolyData::New();
2900         _pd->SetPoints( _pts );
2901         _pd->SetLines( lines );
2902         lines->Delete();  //do not delete lines ??
2903
2904         _contourVtkActor        =       vtkActor::New();
2905     _bboxMapper                 =       vtkPolyDataMapper::New();
2906     _bboxMapper->ScalarVisibilityOff( );
2907
2908         _bboxMapper->SetInput(_pd);
2909         _bboxMapper->ImmediateModeRenderingOn();
2910         _contourVtkActor->SetMapper(_bboxMapper);
2911         _contourVtkActor->GetProperty()->BackfaceCullingOff();
2912
2913         UpdateColorActor();
2914
2915         _pd->ComputeBounds();
2916
2917         //      Text
2918         _textActor = vtkTextActor::New();
2919 //      _textActor->SetDisplayPosition(200, 200);
2920         _textActor->SetInput("");
2921         // Set coordinates to match the old vtkScaledTextActor default value
2922 //      _textActor->GetPosition2Coordinate()->SetCoordinateSystemToNormalizedViewport();
2923 //      _textActor->GetPosition2Coordinate()->SetValue( 0.2 , 0.2 );
2924         _textActor->GetPositionCoordinate()->SetCoordinateSystemToWorld ();
2925 //      _textActor->GetPositionCoordinate()->SetValue( 0.8 , 0.8 );
2926
2927         vtkTextProperty *tprop = _textActor->GetTextProperty();
2928         tprop->SetFontSize(14);
2929         tprop->SetFontFamilyToArial();
2930         tprop->SetColor(0, 0, 1);
2931 }
2932 // ----------------------------------------------------------------------------
2933 void manualViewBaseContour::CreateNewContour()
2934 {
2935         ConstructVTKObjects();
2936         /*
2937         _wxvtkbaseview->GetRenderer()->AddActor( _contourVtkActor );
2938         _wxvtkbaseview->GetRenderer()->AddActor2D(_textActor);*/
2939         AddCompleteContourActor();
2940 }
2941 // ----------------------------------------------------------------------------
2942 void manualViewBaseContour::UpdateViewPoint(int id) // virtual
2943 {
2944         manualPoint             *mp             = _manContModel->GetManualPoint(id);
2945
2946 //EEDx6
2947                         double XX=mp->GetX(),YY=mp->GetY(),ZZ=mp->GetZ();
2948 //                      wxVtk2DBaseView *wxvtk2Dbasevie = (wxVtk2DBaseView*)this->GetWxVtkBaseView();
2949 //                      wxvtk2Dbasevie->TransformCoordinate_spacing_ModelToView(XX,YY,ZZ);
2950
2951         _lstViewPoints[id]->SetPositionXY( XX , YY ,_range, ZZ );
2952 }
2953
2954 // ----------------------------------------------------------------------------
2955 void manualViewBaseContour :: UpdateViewPoints()
2956 {
2957         int id, size = _lstViewPoints.size();
2958         for( id=0; id<size; id++)
2959         {
2960                 UpdateViewPoint( id );
2961         }
2962 }
2963
2964 // ----------------------------------------------------------------------------
2965 void manualViewBaseContour::AddPoint()
2966 {
2967         manualViewPoint *mvp    = new manualViewPoint( this->GetWxVtkBaseView() );
2968         AddPoint( mvp );
2969 }
2970 // ----------------------------------------------------------------------------
2971 void manualViewBaseContour::AddPoint( manualViewPoint * manualViewPoint )
2972 {
2973         _lstViewPoints.push_back( manualViewPoint );
2974
2975         // EED 3 oct 2006
2976         manualViewPoint->SetSpacing(_spc);
2977
2978         vtkActor *actor = manualViewPoint->CreateVtkPointActor();
2979         _wxvtkbaseview->GetRenderer()->AddActor( actor );
2980 }
2981
2982 // ----------------------------------------------------------------------------
2983 void manualViewBaseContour::InsertPoint(int id)
2984 {
2985         manualViewPoint         *mvp    = new manualViewPoint( this->GetWxVtkBaseView() );
2986
2987 // EED 3 oct 2006
2988         mvp->SetSpacing(_spc);
2989
2990         std::vector<manualViewPoint*>::iterator itNum = _lstViewPoints.begin() + id;
2991         _lstViewPoints.insert(itNum,mvp);
2992         _wxvtkbaseview->GetRenderer()->AddActor( mvp->CreateVtkPointActor() );
2993 }
2994 // ----------------------------------------------------------------------------
2995 void manualViewBaseContour::DeleteContour()
2996 {
2997         RemoveCompleteContourActor();
2998         /*if (_contourVtkActor!=NULL){
2999                 _wxvtkbaseview->GetRenderer()->RemoveActor( _contourVtkActor );
3000         }*/
3001         DeleteVtkObjects();
3002         int i,size=_lstViewPoints.size();
3003         for (i=0;i<size;i++){
3004                 manualViewBaseContour::DeletePoint(0);
3005         }
3006         Refresh();
3007 }
3008 // ----------------------------------------------------------------------------
3009 void manualViewBaseContour::DeletePoint(int id) // virtual
3010 {
3011         int size=_lstViewPoints.size();
3012         if ( (id>=0) && (id<size) ){
3013                 manualViewPoint         *mvp    =_lstViewPoints[id];
3014 //EED ups1
3015 //              _handlePicker->DeletePickList(mvp->GetVtkActor());
3016                 _wxvtkbaseview->GetRenderer()->RemoveActor( mvp->GetVtkActor() );
3017                 std::vector<manualViewPoint*>::iterator itNum = _lstViewPoints.begin() + id;
3018                 _lstViewPoints.erase(itNum);
3019                 delete mvp;
3020                 Refresh();
3021         }
3022 }
3023 // ----------------------------------------------------------------------------
3024 void manualViewBaseContour::DeletePoint(int x, int y, int z)
3025 {
3026         int id=GetIdPoint(x,y,z);
3027         if (id!=-1){
3028                 DeletePoint(id);
3029         }
3030 }
3031 // ----------------------------------------------------------------------------
3032 void manualViewBaseContour::SetSelected(bool selected)
3033 {
3034         _selected=selected;
3035 }
3036 // ----------------------------------------------------------------------------
3037 void manualViewBaseContour::SetPosibleSelected(bool posibleSelected)
3038 {
3039         _posibleSelected=posibleSelected;
3040 }
3041 // ----------------------------------------------------------------------------
3042 bool manualViewBaseContour::GetEditable()
3043 {
3044         return *_editable;
3045 }
3046 // ----------------------------------------------------------------------------
3047 void manualViewBaseContour::SetEditable( bool * condition )
3048 {
3049         _editable = condition;
3050 }
3051 // ----------------------------------------------------------------------------
3052 bool manualViewBaseContour::GetSelected()
3053 {
3054         return _selected;
3055 }
3056 // ----------------------------------------------------------------------------
3057 bool manualViewBaseContour::GetPosibleSelected()
3058 {
3059         return _posibleSelected;
3060 }
3061 // ----------------------------------------------------------------------------
3062 void manualViewBaseContour::DeleteSelectedPoints()
3063 {
3064         int i,size=_lstViewPoints.size();
3065         for (i=size-1;i>=0;i--){
3066                 if (_lstViewPoints[i]->GetSelected()==true){
3067                         DeletePoint(i);
3068                 }
3069         }
3070         Refresh();
3071 }
3072 // ----------------------------------------------------------------------------
3073 void manualViewBaseContour::SelectPoint(int i, bool select)
3074 {
3075         _lstViewPoints[i]->SetSelected(select);
3076 }
3077 // ----------------------------------------------------------------------------
3078 void manualViewBaseContour::SelectLstPoints()
3079 {
3080         // ToDo
3081 }
3082 // ----------------------------------------------------------------------------
3083 void manualViewBaseContour::SelectAllPoints(bool select)
3084 {
3085         int i,size=_lstViewPoints.size();
3086         for (i=0;i<size;i++){
3087                 SelectPoint(i,select);
3088         }
3089 }
3090 //-----------------------------------------------------------------------------
3091 void manualViewBaseContour:: SetIfViewControlPoints(bool ifShow)
3092 {
3093         _viewControlPoints = ifShow;
3094 }
3095 // ----------------------------------------------------------------------------
3096 bool manualViewBaseContour:: GetIfViewControlPoints()
3097 {
3098         return _viewControlPoints;
3099 }
3100
3101 // ----------------------------------------------------------------------------
3102 void manualViewBaseContour::SetPointPosibleSelected(int id,bool select)
3103 {
3104         _lstViewPoints[id]->SetPosibleSelected(select);
3105 }
3106 // ----------------------------------------------------------------------------
3107 void manualViewBaseContour::SetPointSelected(int id,bool select)
3108 {
3109         _lstViewPoints[id]->SetSelected(select);
3110 }
3111 // ----------------------------------------------------------------------------
3112 void manualViewBaseContour::SelectAllPossibleSelected(bool select)
3113 {
3114         int i,size=_lstViewPoints.size();
3115         for (i=0;i<size;i++){
3116                 SetPointPosibleSelected(i,select);
3117         }
3118 }
3119 // ----------------------------------------------------------------------------
3120 int manualViewBaseContour::SelectPosiblePoint(int x, int y, int z)  // virtual
3121 {
3122         SelectAllPossibleSelected(false);
3123
3124     int id = GetIdPoint(x,y,z);
3125         if (id!=-1)
3126         {
3127                 SetPointPosibleSelected(id,true);
3128         }
3129         return id;
3130 }
3131 // ----------------------------------------------------------------------------
3132 bool manualViewBaseContour::SelectPosibleContour(int x, int y, int z)
3133 {
3134         bool result=false;
3135         SetPosibleSelected(result);
3136     int id = GetIdPoint(x,y,z);
3137         if( !GetEditable() && !_selected && id!= -1)
3138         {
3139                 result=true;
3140                 SetPosibleSelected(result);
3141         }
3142         else
3143         {
3144                 if ( (GetEditable()==true) && (id==-1 ) && (this->_lstViewPoints.size()>=2) )
3145                 {
3146                         if (ifTouchContour(x,y,z)==true)
3147                         {
3148                                 result=true;
3149                                 SetPosibleSelected(result);
3150                         }
3151                 }
3152
3153                 if (GetEditable()==false)
3154                 {
3155                         if (ifTouchContour(x,y,z)==true)
3156                         {
3157                                 result=true;
3158                                 SetPosibleSelected(result);
3159                         }
3160                 }
3161
3162
3163         }
3164         return result;
3165 }
3166 // ----------------------------------------------------------------------------
3167 bool manualViewBaseContour::ifTouchContour(int x,int y, int z) // virtual
3168 {
3169         return false;
3170 }
3171 // ----------------------------------------------------------------------------
3172 void manualViewBaseContour::UnSelectPoint(int i){
3173         _lstViewPoints[i]->SetSelected(false);
3174         Refresh();
3175 }
3176 // ----------------------------------------------------------------------------
3177 void manualViewBaseContour::UnSelectLstPoints(){
3178         // ToDo
3179 }
3180 // ----------------------------------------------------------------------------
3181 void manualViewBaseContour::UnSelectAllPoints(){
3182         int i,size=_lstViewPoints.size();
3183         for (i=0;i<size;i++){
3184                 UnSelectPoint(i);
3185         }
3186         Refresh();
3187 }
3188 // ----------------------------------------------------------------------------
3189 void manualViewBaseContour::SetModel(manualContourModel *manContModel){
3190         _manContModel=manContModel;
3191 }
3192 // ----------------------------------------------------------------------------
3193 void manualViewBaseContour::SetWxVtkBaseView(wxVtkBaseView *wxvtkbaseview){
3194         _wxvtkbaseview = wxvtkbaseview;
3195 }
3196 // ----------------------------------------------------------------------------
3197 void manualViewBaseContour::RefreshContour()  // Virtual
3198 {
3199 }
3200 // ----------------------------------------------------------------------------
3201 double* manualViewBaseContour::GetVectorPointsXManualContour(){
3202         double pp[3];
3203         int i,size = _sizePointsContour;
3204         double *vx = (double*)malloc(sizeof(double)*size);
3205         for (i=0;i<size;i++){
3206                 _pts->GetPoint(i,pp);
3207                 vx[i]=pp[0];
3208         }
3209         return vx;
3210 }
3211 // ----------------------------------------------------------------------------
3212 double* manualViewBaseContour::GetVectorPointsYManualContour()
3213 {
3214         double pp[3];
3215         int i,size = _sizePointsContour;
3216         double *vy = (double*)malloc(sizeof(double)*size);
3217         for (i=0;i<size;i++){
3218                 _pts->GetPoint(i,pp);
3219                 vy[i]=pp[1];
3220         }
3221         return vy;
3222 }
3223 // ----------------------------------------------------------------------------
3224 double* manualViewBaseContour::GetVectorPointsZManualContour()
3225 {
3226         double pp[3];
3227         int i,size = _sizePointsContour;
3228         double *vz = (double*)malloc(sizeof(double)*size);
3229         for (i=0;i<size;i++){
3230                 _pts->GetPoint(i,pp);
3231                 vz[i]=pp[2];
3232         }
3233         return vz;
3234 }
3235 // ----------------------------------------------------------------------------
3236 void manualViewBaseContour::Refresh() // virtual
3237 {
3238         if (_contourVtkActor!=NULL){
3239                 RefreshContour();
3240         }
3241         int i,size=_lstViewPoints.size();
3242         for (i=0;i<size;i++){
3243                 UpdateViewPoint(i);
3244                 _lstViewPoints[i]->UpdateColorActor();
3245         }
3246         UpdateColorActor();
3247
3248         if (_show_text==true)
3249         {
3250                 RefreshText();
3251         }
3252
3253         vtkRenderWindowInteractor *vri = _wxvtkbaseview->GetWxVTKRenderWindowInteractor ();
3254         if (vri==NULL)
3255         {
3256                 _wxvtkbaseview->GetRenWin()->Render();
3257         }
3258
3259 }
3260 // ----------------------------------------------------------------------------
3261 void manualViewBaseContour::RefreshText()  // virtual
3262 {
3263         if( _textActor!=NULL)
3264                 _textActor -> SetInput(" ");
3265 }
3266 // ----------------------------------------------------------------------------
3267 void manualViewBaseContour::SetColorNormalContour(double r, double g, double b)
3268 {
3269         _coulorNormal_r = r;
3270         _coulorNormal_g = g;
3271         _coulorNormal_b = b;
3272 }
3273 // ----------------------------------------------------------------------------
3274 void manualViewBaseContour::GetColorNormalContour(double &r, double &g, double &b)
3275 {
3276         r = _coulorNormal_r;
3277         g = _coulorNormal_g;
3278         b = _coulorNormal_b;
3279 }
3280 // ----------------------------------------------------------------------------
3281 void manualViewBaseContour::SetColorEditContour(double r, double g, double b)
3282 {
3283         _coulorEdit_r = r;
3284         _coulorEdit_g = g;
3285         _coulorEdit_b = b;
3286 }
3287 // ----------------------------------------------------------------------------
3288 void manualViewBaseContour::GetColorEditContour(double &r, double &g, double &b)
3289 {
3290         r = _coulorEdit_r;
3291         g = _coulorEdit_g;
3292         b = _coulorEdit_b;
3293 }
3294 // ----------------------------------------------------------------------------
3295 void manualViewBaseContour::SetColorSelectContour(double r, double g, double b)
3296 {
3297         _coulorSelection_r = r;
3298         _coulorSelection_g = g;
3299         _coulorSelection_b = b;
3300 }
3301 // ----------------------------------------------------------------------------
3302 void manualViewBaseContour::GetColorSelectContour(double &r, double &g, double &b)
3303 {
3304         r = _coulorSelection_r;
3305         g = _coulorSelection_g;
3306         b = _coulorSelection_b;
3307 }
3308 // ----------------------------------------------------------------------------
3309 void manualViewBaseContour::UpdateColorActor()
3310 {
3311         if (_contourVtkActor!=NULL)
3312         {
3313                 _contourVtkActor->GetProperty()->SetLineWidth( _widthline );
3314                 _contourVtkActor->GetProperty()->SetDiffuseColor( _coulorNormal_r , _coulorNormal_g , _coulorNormal_b );
3315                 if (_posibleSelected || (_posibleSelected && GetEditable() ) )
3316                 {
3317                         _contourVtkActor->GetProperty()->SetDiffuseColor( _coulorEdit_r , _coulorEdit_g , _coulorEdit_b );
3318                 }
3319                 if( _selected )
3320                 {
3321                         _contourVtkActor->GetProperty()->SetDiffuseColor( _coulorSelection_r , _coulorSelection_g , _coulorSelection_b );
3322                 }
3323         }
3324 }
3325 // ----------------------------------------------------------------------------
3326 int     manualViewBaseContour::GetIdPoint(int x, int y, int z) // virtual
3327 {
3328         int ii = -1;
3329         if (_manContModel!=NULL){
3330                 double xx = x;
3331                 double yy = y;
3332                 double zz = z;
3333                 TransfromeCoordViewWorld(xx,yy,zz);
3334                 ii=_manContModel->GetIdPoint(xx,yy,zz,_range,-1);
3335         }
3336         return ii;
3337 }
3338
3339 // ----------------------------------------------------------------------------
3340
3341
3342 int manualViewBaseContour::GetNumberOfPoints()
3343 {
3344         return _lstViewPoints.size();
3345 }
3346
3347 // ----------------------------------------------------------------------------
3348
3349 //JSTG 25-02-08 ---------------------------------------------------------------
3350 /*int manualViewBaseContour::GetNumberOfPointsSpline()
3351 {
3352         return _sizePointsContour;
3353 }*/
3354 //----------------------------------------------------------------------------
3355
3356 //JSTG 25-02-08 ---------------------------------------------------------------
3357 /*void manualViewBaseContour::SetNumberOfPointsSpline(int size)
3358 {
3359         _sizePointsContour = size;
3360 }*/
3361 //----------------------------------------------------------------------------
3362 // virtual
3363 void manualViewBaseContour::TransfromeCoordViewWorld(double &X, double &Y, double &Z, int type)  // Virtual
3364 {
3365         _wxvtkbaseview->TransfromeCoordScreenToWorld(X, Y, Z, type);
3366
3367
3368 //EED 27 sep 2007
3369 //   //EEDx6
3370 //      wxVtk2DBaseView *wxvtk2Dbaseview = (wxVtk2DBaseView*)_wxvtkbaseview;
3371 //      wxvtk2Dbaseview->TransformCoordinate_spacing_ModelToView(X,Y,Z);
3372
3373 }
3374 // ----------------------------------------------------------------------------
3375 void manualViewBaseContour::SetRange(int range)
3376 {
3377         _range=range;
3378 }
3379 // ----------------------------------------------------------------------------
3380 int     manualViewBaseContour::GetRange()
3381 {
3382         return _range;
3383 }
3384 // ----------------------------------------------------------------------------
3385 void manualViewBaseContour::SetZ(int z)
3386 {
3387 //      _Z=z;
3388 }
3389 // ----------------------------------------------------------------------------
3390 int     manualViewBaseContour::GetZ()
3391 {
3392 //      return _Z;
3393         return 0;
3394 }
3395 // ----------------------------------------------------------------------------
3396 void manualViewBaseContour::InitMove(int x, int y, int z) // virtual
3397 {
3398
3399 }
3400 // ----------------------------------------------------------------------------
3401 void manualViewBaseContour::MoveContour(int x, int y, int z) // virtual
3402 {
3403 }
3404 // ----------------------------------------------------------------------------
3405 void manualViewBaseContour::MoveContour(int horizontalUnits, int verticalUnits )// virtual
3406 {
3407
3408 }
3409 // ----------------------------------------------------------------------------
3410 void manualViewBaseContour::GetMinMax( double &minX,double &minY, double &minZ, double &maxX, double &maxY, double &maxZ )// virtual
3411 {
3412         double  pp[3];
3413         manualPoint *mp;
3414         int i;
3415         int size=_manContModel->GetSizeLstPoints();
3416         minX=99999;
3417         minY=99999;
3418         maxX=-99999;
3419         maxY=-99999;
3420         bool ifFindZ = minZ!=-1.0 && maxZ!=-1.0;
3421         if ( ifFindZ )
3422         {
3423                 minZ=99999;
3424                 maxZ=-99999;
3425         }
3426         for( i = 0; i < size; i++ )
3427         {
3428                 mp=_manContModel->GetManualPoint(i);
3429                 pp[0]=mp->GetX();
3430                 pp[1]=mp->GetY();
3431                 if ( ifFindZ )
3432                         pp[2]=mp->GetZ();
3433
3434                 // min X
3435                 if (pp[0]<minX)
3436                 {
3437                         minX=pp[0];
3438                 }
3439                 //min Y
3440                 if (pp[1]<minY)
3441                 {
3442                         minY=pp[1];
3443                 }
3444                 //max X
3445                 if (pp[0]>maxX)
3446                 {
3447                         maxX=pp[0];
3448                 }
3449                 // max Y
3450                 if (pp[1]>maxY)
3451                 {
3452                         maxY=pp[1];
3453                 }
3454                 if ( ifFindZ )
3455                 {
3456                         // min Z
3457                         if (pp[2]<minZ)
3458                         {
3459                                 minZ=pp[2];
3460                         }
3461                         // max Z
3462                         if (pp[2]>maxZ)
3463                         {
3464                                 maxZ=pp[2];
3465                         }
3466                 }
3467         }
3468         if ( size<1 )
3469         {
3470                 minX = 0;
3471                 maxX = 0;
3472
3473                 minY = 0;
3474                 maxY = 0;
3475
3476                 minZ = 0;
3477                 maxZ = 0;
3478         }
3479 }
3480 // ----------------------------------------------------------------------------
3481 void manualViewBaseContour::ClearContour()
3482 {
3483         if (_contourVtkActor!=NULL){
3484                 _wxvtkbaseview->GetRenderer()->RemoveActor( _contourVtkActor );
3485         }
3486         DeleteVtkObjects();
3487         int i,size=_lstViewPoints.size();
3488         for (i=0;i<size;i++){
3489                 ClearPoint(0);
3490         }
3491         Refresh();
3492 }
3493 // ----------------------------------------------------------------------------
3494 void manualViewBaseContour::ClearPoint(int id)
3495 {
3496         DeletePoint(id);
3497 }
3498 // ----------------------------------------------------------------------------
3499 void manualViewBaseContour::SetVisible(bool ok)
3500 {
3501         double opacity;
3502         if (ok==true)
3503         {
3504                 opacity=1;
3505         } else {
3506                 opacity=0;
3507         }
3508
3509         vtkActor *actor;
3510         int i,size=_lstViewPoints.size();
3511         for (i=0;i<size;i++){
3512                 actor = _lstViewPoints[i]->GetVtkActor();
3513                 actor->GetProperty()->SetOpacity( opacity );
3514         }
3515         _contourVtkActor->GetProperty()->SetOpacity( opacity );
3516         _textActor->GetProperty()->SetOpacity( opacity );
3517         _textActor->SetInput(" ");
3518
3519 }
3520 // ----------------------------------------------------------------------------
3521 void manualViewBaseContour::SetShowText(bool ok)
3522 {
3523         _show_text = ok;
3524         if (_show_text==false)
3525         {
3526                 _textActor->SetInput(" ");
3527         }
3528 }
3529 // ----------------------------------------------------------------------------
3530 wxVtkBaseView *manualViewBaseContour::GetWxVtkBaseView()
3531 {
3532         return this->_wxvtkbaseview;
3533 }
3534 // ----------------------------------------------------------------------------
3535 void manualViewBaseContour::GetSpacing(double spc[3])
3536 {
3537         spc[0] = _spc[0];
3538         spc[1] = _spc[1];
3539         spc[2] = _spc[2];
3540 }
3541 // ----------------------------------------------------------------------------
3542 void manualViewBaseContour::SetSpacing(double spc[3])
3543 {
3544         _spc[0] = spc[0];
3545         _spc[1] = spc[1];
3546         _spc[2] = spc[2];
3547 }
3548
3549
3550 // ----------------------------------------------------------------------------
3551 // ----------------------------------------------------------------------------
3552 // ----------------------------------------------------------------------------
3553
3554 // _type = 0  Sagital
3555 // _type = 1  Coronal
3556 // _type = 2  Axial
3557 // _type = -1 View 3D
3558
3559 manualContour3VControler::manualContour3VControler(int type)
3560 {
3561         _type=type;
3562
3563 //EEDhh
3564 //      _manViewBaseCont1 = NULL;
3565 //      _manViewBaseCont2 = NULL;
3566 //      _manViewBaseCont3 = NULL;
3567 }
3568 //----------------------------------------------------------------------------
3569 manualContour3VControler::~manualContour3VControler()
3570 {
3571 }
3572
3573 // ----------------------------------------------------------------------------
3574 manualContour3VControler * manualContour3VControler :: Clone()  // virtual
3575 {
3576         manualContour3VControler * clone = new manualContour3VControler( this->GetType() );
3577         CopyAttributesTo(clone);
3578         return clone;
3579 }
3580
3581 // ---------------------------------------------------------------------------
3582 void manualContour3VControler::CopyAttributesTo( manualContour3VControler * cloneObject)
3583 {
3584         // Fathers object
3585         manualContourControler::CopyAttributesTo(cloneObject);
3586
3587         cloneObject->SetVtkMPRBaseData( this->GetVtkMPRBaseData() );
3588
3589         // Remember to add ManualViewBaseContour with "AddManualViewBaseContour"
3590
3591 }
3592 // ----------------------------------------------------------------------------
3593 int manualContour3VControler::GetType()
3594 {
3595         return _type;
3596 }
3597
3598 // ----------------------------------------------------------------------------
3599 void manualContour3VControler::AddPoint_Others()
3600 {
3601         manualViewBaseContour *mvbc;
3602         int i,size=this->_lstManualViewBaseContour.size();
3603         for ( i = 0 ; i < size ; i++ )
3604         {
3605                 mvbc = _lstManualViewBaseContour[i];
3606                 mvbc->AddPoint();
3607         }
3608
3609 // EEDhh
3610 //      if (_manViewBaseCont1!=NULL){
3611 //              _manViewBaseCont1->AddPoint();
3612 //              _manViewBaseCont2->AddPoint();
3613 //              _manViewBaseCont3->AddPoint();
3614 //              this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3615 //      }
3616
3617         this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3618 }
3619 // ----------------------------------------------------------------------------
3620 void manualContour3VControler::AddPoint( int x, int y, int z ) // virtual
3621 {
3622
3623         z=(int)_vtkmprbasedata->GetZ();
3624         if (GetManualContourModel()!=NULL){
3625                 double  xx      = x;
3626                 double  yy      = y;
3627                 double  zz      = z;
3628                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz,_type);
3629
3630                 if (_type==0)
3631                 {
3632                         xx=_vtkmprbasedata->GetX();
3633                 }
3634
3635                 if (_type==1)
3636                 {
3637                         yy=_vtkmprbasedata->GetY();
3638                 }
3639
3640
3641                 /*int   id              = */ GetManualContourModel()->AddPoint(xx,yy,zz);  // JPRx
3642                 GetManualViewBaseContour()->AddPoint();
3643                 AddPoint_Others();
3644
3645         }
3646 }
3647
3648 // ----------------------------------------------------------------------------
3649 void manualContour3VControler::InsertPoint_Others(int id)
3650 {
3651
3652         manualViewBaseContour *mvbc;
3653         int i,size=this->_lstManualViewBaseContour.size();
3654         for ( i = 0 ; i < size ; i++ )
3655         {
3656                 mvbc = _lstManualViewBaseContour[i];
3657                 mvbc->InsertPoint(id);
3658         }
3659
3660 /*EEDhh
3661         if (_manViewBaseCont1!=NULL){
3662                 _manViewBaseCont1->InsertPoint(id);
3663                 _manViewBaseCont2->InsertPoint(id);
3664                 _manViewBaseCont3->InsertPoint(id);
3665                 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3666         }
3667 */
3668
3669         this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3670
3671 }
3672 // ----------------------------------------------------------------------------
3673 void manualContour3VControler::InsertPoint(int x, int y, int z)
3674 {
3675         int id=-1;
3676         if (GetManualContourModel()!=NULL){
3677                 if (GetManualContourModel()->GetSizeLstPoints()>1){
3678                         z=(int)_vtkmprbasedata->GetZ();
3679                         double                          xx              = x;
3680                         double                          yy              = y;
3681                         double                          zz              = z;
3682                         GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz,_type);
3683                         if (_type==0)
3684                         {
3685                                 xx=_vtkmprbasedata->GetX();
3686                         }
3687
3688                         if (_type==1)
3689                         {
3690                                 yy=_vtkmprbasedata->GetY();
3691                         }
3692
3693                         id      = GetManualContourModel()->InsertPoint(xx,yy,zz);
3694
3695                         GetManualViewBaseContour()->InsertPoint(id);
3696                         InsertPoint_Others(0);
3697
3698                 } else {
3699                         AddPoint(x,y,z);
3700                 }
3701         }
3702 }
3703 // ----------------------------------------------------------------------------
3704
3705 // EEDhh
3706 /*
3707 void manualContour3VControler::SetModelView (   manualContourModel *manContModel,
3708                                                                                                 manualViewBaseContour *manViewBaseCont0,
3709                                                                                                 manualViewBaseContour *manViewBaseCont1,
3710                                                                                                 manualViewBaseContour *manViewBaseCont2,
3711                                                                                                 manualViewBaseContour *manViewBaseCont3)
3712 {
3713         manualContourControler::SetModelView(manContModel,manViewBaseCont0);
3714         _manViewBaseCont1 = manViewBaseCont1;
3715         _manViewBaseCont2 = manViewBaseCont2;
3716         _manViewBaseCont3 = manViewBaseCont3;
3717 }
3718 */
3719
3720 // ----------------------------------------------------------------------------
3721 void manualContour3VControler::AddManualViewBaseContour( manualViewBaseContour *manViewBaseCont )
3722 {
3723         _lstManualViewBaseContour.push_back( manViewBaseCont );
3724 }
3725
3726 // ----------------------------------------------------------------------------
3727 void manualContour3VControler::SetVtkMPRBaseData (vtkMPRBaseData *vtkmprbasedata )
3728 {
3729         _vtkmprbasedata=vtkmprbasedata;
3730 }
3731 // ----------------------------------------------------------------------------
3732 vtkMPRBaseData *manualContour3VControler::GetVtkMPRBaseData()
3733 {
3734         return _vtkmprbasedata;
3735 }
3736 // ----------------------------------------------------------------------------
3737 void manualContour3VControler::SetPoint( int id ,int x ,int y ,int z ) // virtual
3738 {
3739         z=(int)_vtkmprbasedata->GetZ();
3740         if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
3741                 double xx = x;
3742                 double yy = y;
3743                 double zz = z;
3744                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz,_type);
3745
3746                 if (_type==0)
3747                 {
3748                         xx=_vtkmprbasedata->GetX();
3749                 }
3750                 if (_type==1)
3751                 {
3752                         yy=_vtkmprbasedata->GetY();
3753                 }
3754
3755                 manualPoint     *mp     = GetManualContourModel()->GetManualPoint(id);
3756                 mp->SetPoint(xx,yy,zz);
3757
3758         }
3759 }
3760 // ----------------------------------------------------------------------------
3761 void manualContour3VControler::DeleteActualMousePoint_Others(int id)
3762 {
3763         manualViewBaseContour *mvbc;
3764         int i,size=this->_lstManualViewBaseContour.size();
3765         for ( i = 0 ; i < size ; i++ )
3766         {
3767                 mvbc = _lstManualViewBaseContour[i];
3768                 mvbc->DeletePoint(id);
3769                 mvbc->Refresh();
3770         }
3771
3772 /*
3773         if (_manViewBaseCont1!=NULL){
3774                 _manViewBaseCont1->DeletePoint(id);
3775                 _manViewBaseCont2->DeletePoint(id);
3776                 _manViewBaseCont3->DeletePoint(id);
3777
3778                 _manViewBaseCont1->Refresh();
3779                 _manViewBaseCont2->Refresh();
3780                 _manViewBaseCont3->Refresh();
3781
3782                 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3783         }
3784 */
3785         this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3786 }
3787 // ----------------------------------------------------------------------------
3788 void manualContour3VControler::DeleteActualMousePoint(int x, int y)// virtual
3789 {
3790         int id=GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
3791         if (id!=-1){
3792                 manualContourBaseControler::DeleteActualMousePoint( x , y );
3793                 DeleteActualMousePoint_Others( id );
3794         }
3795 }
3796 // ----------------------------------------------------------------------------
3797 void manualContour3VControler::MouseMove_Others(int id) // virtual
3798 {
3799         manualViewBaseContour *mvbc;
3800         int i,size=this->_lstManualViewBaseContour.size();
3801         for ( i = 0 ; i < size ; i++ )
3802         {
3803                 mvbc = _lstManualViewBaseContour[i];
3804                 mvbc->SelectAllPossibleSelected(false);
3805                 if (id!=-1)
3806                 {
3807                         mvbc->SetPointPosibleSelected(id,true);
3808                 }
3809                 mvbc->SetPosibleSelected  (  GetManualViewBaseContour()->GetPosibleSelected()  );
3810                 mvbc->Refresh();
3811         }
3812
3813 // EEDhh
3814 /*
3815         if (_manViewBaseCont1!=NULL){
3816                 _manViewBaseCont1->SelectAllPossibleSelected(false);
3817                 _manViewBaseCont2->SelectAllPossibleSelected(false);
3818                 _manViewBaseCont3->SelectAllPossibleSelected(false);
3819                 if (id!=-1){
3820                         _manViewBaseCont1->SetPointPosibleSelected(id,true);
3821                         _manViewBaseCont2->SetPointPosibleSelected(id,true);
3822                         _manViewBaseCont3->SetPointPosibleSelected(id,true);
3823                 }
3824                 _manViewBaseCont1->SetPosibleSelected  (  GetManualViewBaseContour()->GetPosibleSelected()  );
3825                 _manViewBaseCont2->SetPosibleSelected  (  GetManualViewBaseContour()->GetPosibleSelected()  );
3826                 _manViewBaseCont3->SetPosibleSelected  (  GetManualViewBaseContour()->GetPosibleSelected()  );
3827
3828                 _manViewBaseCont1->Refresh();
3829                 _manViewBaseCont2->Refresh();
3830                 _manViewBaseCont3->Refresh();
3831
3832                 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3833         }
3834 */
3835         this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3836
3837 }
3838
3839 // ----------------------------------------------------------------------------
3840 void manualContour3VControler::MouseMove(int x, int y) // virtual
3841 {
3842         manualContourControler::MouseMove( x , y );
3843         int id=GetManualViewBaseContour()->GetIdPoint(x,y,GetZ());
3844         MouseMove_Others( id );
3845 }
3846
3847 // ----------------------------------------------------------------------------
3848 void manualContour3VControler::OnChar_Others()
3849 {
3850         manualViewBaseContour *mvbc;
3851         int i,size=this->_lstManualViewBaseContour.size();
3852         for ( i = 0 ; i < size ; i++ )
3853         {
3854                 mvbc = _lstManualViewBaseContour[i];
3855                 mvbc->Refresh();
3856         }
3857 // EEDhh
3858 /*
3859                 _manViewBaseCont1->Refresh();
3860                 _manViewBaseCont2->Refresh();
3861                 _manViewBaseCont3->Refresh();
3862 */
3863         this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3864 }
3865 // ----------------------------------------------------------------------------
3866 bool manualContour3VControler::OnChar()
3867 {
3868         manualContourControler::OnChar();
3869         OnChar_Others();
3870         return true;
3871 }
3872 // ----------------------------------------------------------------------------
3873 void manualContour3VControler::ResetContour() // virtual
3874 {
3875         manualContourControler::ResetContour();
3876         ResetContour_Others();
3877 }
3878
3879 // ----------------------------------------------------------------------------
3880 void manualContour3VControler::ResetContour_Others()
3881 {
3882         manualViewBaseContour *mvbc;
3883         int i,size=this->_lstManualViewBaseContour.size();
3884         for ( i = 0 ; i < size ; i++ )
3885         {
3886                 mvbc = _lstManualViewBaseContour[i];
3887                 mvbc->DeleteContour();
3888                 mvbc->CreateNewContour();
3889         }
3890
3891 // EEDhh
3892 /*
3893         _manViewBaseCont1->DeleteContour();
3894         _manViewBaseCont2->DeleteContour();
3895         _manViewBaseCont3->DeleteContour();
3896         _manViewBaseCont1->CreateNewContour();
3897         _manViewBaseCont2->CreateNewContour();
3898         _manViewBaseCont3->CreateNewContour();
3899 */
3900 }
3901
3902 // ----------------------------------------------------------------------------
3903 // ----------------------------------------------------------------------------
3904 // ----------------------------------------------------------------------------
3905 manualContour3DControler::manualContour3DControler()
3906 {
3907 }
3908 // ----------------------------------------------------------------------------
3909 manualContour3DControler::~manualContour3DControler()
3910 {
3911 }
3912 // ----------------------------------------------------------------------------
3913 manualContour3DControler * manualContour3DControler :: Clone()  // virtual
3914 {
3915         manualContour3DControler * clone = new manualContour3DControler();
3916         CopyAttributesTo(clone);
3917         return clone;
3918 }
3919
3920 // ---------------------------------------------------------------------------
3921 void manualContour3DControler::CopyAttributesTo( manualContour3DControler * cloneObject)
3922 {
3923         // Fathers object
3924         manualContourControler::CopyAttributesTo(cloneObject);
3925
3926         cloneObject->SetVtkMPRBaseData( this->GetVtkMPRBaseData() );
3927 }
3928
3929 // ----------------------------------------------------------------------------
3930 bool  manualContour3DControler::OnLeftButtonDown()
3931 {
3932         int X,Y;
3933         wxVTKRenderWindowInteractor *wxVTKiren;
3934         wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
3935         wxVTKiren->GetEventPosition(X,Y);
3936         MouseClickLeft(X,Y);
3937         return true;
3938 }
3939 // ----------------------------------------------------------------------------
3940 void manualContour3DControler::ResetOrientationPlane()
3941 {
3942         double p[3],rp[3],rn[3];
3943         p[0] = this->GetVtkMPRBaseData()->GetX(  );
3944         p[1] = this->GetVtkMPRBaseData()->GetY(  );
3945         p[2] = this->GetVtkMPRBaseData()->GetZ(  );
3946         this->GetManualContourModel()->GetNearestPointAndNormal(p,rp,rn);
3947         this->GetVtkMPRBaseData()->SetNormal(rn[0],rn[1],rn[2]);
3948 }
3949 // ----------------------------------------------------------------------------
3950 void manualContour3DControler::MouseClickLeft(int x, int y) // virtual
3951 {
3952         manualView3DContour *manualview3Dcontour=(manualView3DContour*)GetManualViewBaseContour();
3953         int id=manualview3Dcontour->GetIdPoint2(x,y);
3954         if ( (GetState()==0) && (id!=-1) )
3955         {
3956                 manualPoint *mp = this->GetManualContourModel()->GetManualPoint(id);
3957
3958                 this->GetVtkMPRBaseData()->SetX( mp->GetX() );
3959                 this->GetVtkMPRBaseData()->SetY( mp->GetY() );
3960                 this->GetVtkMPRBaseData()->SetZ( mp->GetZ() );
3961                 ResetOrientationPlane();
3962                 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3963         }
3964
3965
3966         manualContourControler::MouseClickLeft(x,y);
3967
3968 }
3969 // ----------------------------------------------------------------------------
3970 bool manualContour3DControler::OnChar()
3971 {
3972         bool ok=true;
3973         manualContourControler::OnChar();
3974         char keyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
3975         if (keyCode==32){
3976                 ok=false;
3977                 ResetOrientationPlane();
3978                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
3979         }
3980         return ok;
3981 }
3982
3983 // ----------------------------------------------------------------------------
3984 void manualContour3DControler::SetVtkMPRBaseData (vtkMPRBaseData *vtkmprbasedata )
3985 {
3986         _vtkmprbasedata=vtkmprbasedata;
3987 }
3988 // ----------------------------------------------------------------------------
3989 vtkMPRBaseData *manualContour3DControler::GetVtkMPRBaseData()
3990 {
3991         return _vtkmprbasedata;
3992 }
3993
3994 // ----------------------------------------------------------------------------
3995 void manualContour3DControler::InsertPoint(int x, int y, int z ) // virtual
3996 {
3997         manualContourControler::InsertPoint(  x,  y,  z );
3998         ResetOrientationPlane();
3999 }
4000
4001
4002
4003 // ----------------------------------------------------------------------------
4004 // ----------------------------------------------------------------------------
4005 // ----------------------------------------------------------------------------
4006
4007 manualContour3V3DControler::manualContour3V3DControler()
4008 {
4009 }
4010 // ----------------------------------------------------------------------------
4011 manualContour3V3DControler::~manualContour3V3DControler()
4012 {
4013 }
4014
4015 // ----------------------------------------------------------------------------
4016 manualContour3V3DControler * manualContour3V3DControler :: Clone()  // virtual
4017 {
4018         manualContour3V3DControler * clone = new manualContour3V3DControler();
4019         CopyAttributesTo(clone);
4020         return clone;
4021 }
4022
4023 // ---------------------------------------------------------------------------
4024 void manualContour3V3DControler::CopyAttributesTo( manualContour3V3DControler * cloneObject)
4025 {
4026         // Fathers object
4027         manualContour3DControler::CopyAttributesTo(cloneObject);
4028
4029         cloneObject->SetManualContour3VControler( this->GetManualContour3VControler() );
4030 }
4031 // ----------------------------------------------------------------------------
4032 void manualContour3V3DControler::InsertPoint(int x, int y, int z ) // virtual
4033 {
4034         manualContour3DControler::InsertPoint(  x,  y,  z );
4035         _manualcontour3Vcontroler->InsertPoint_Others(0);
4036 }
4037 // ----------------------------------------------------------------------------
4038 void manualContour3V3DControler::AddPoint( int x, int y, int z )
4039 {
4040         manualContour3DControler::AddPoint(  x,  y,  z );
4041         _manualcontour3Vcontroler->AddPoint_Others();
4042 }
4043 // ----------------------------------------------------------------------------
4044 void manualContour3V3DControler::DeleteActualMousePoint(int x, int y)
4045 {
4046         int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
4047         manualContour3DControler::DeleteActualMousePoint( x , y );
4048         _manualcontour3Vcontroler->DeleteActualMousePoint_Others(id);
4049 }
4050 // ----------------------------------------------------------------------------
4051 void manualContour3V3DControler::MouseMove( int x, int y )
4052 {
4053         int ss =this->_vtkInteractorStyleBaseView->vtkInteractorStyle::GetState();
4054         if ((this->GetState()!=7) && (ss!=1)){
4055                 manualContour3DControler::MouseMove( x , y );
4056                 int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
4057                 _manualcontour3Vcontroler->MouseMove_Others(id);
4058         }
4059 }
4060 // ----------------------------------------------------------------------------
4061 void manualContour3V3DControler::SetManualContour3VControler(manualContour3VControler *manualcontour3Vcontroler)
4062 {
4063         _manualcontour3Vcontroler = manualcontour3Vcontroler;
4064 }
4065 // ----------------------------------------------------------------------------
4066 manualContour3VControler *manualContour3V3DControler::GetManualContour3VControler()
4067 {
4068         return _manualcontour3Vcontroler;
4069 }
4070 // ----------------------------------------------------------------------------
4071 bool manualContour3V3DControler::OnChar() // virtual
4072 {
4073         if (manualContour3DControler::OnChar()==false )
4074         {
4075                 _manualcontour3Vcontroler->OnChar_Others();
4076         }
4077         return true;
4078 }
4079
4080 // ----------------------------------------------------------------------------
4081 void manualContour3V3DControler::ResetContour() // virtual
4082 {
4083         manualContourControler::ResetContour();
4084         _manualcontour3Vcontroler->ResetContour_Others();
4085 }
4086
4087
4088 // ----------------------------------------------------------------------------
4089 // ----------------------------------------------------------------------------
4090 // ----------------------------------------------------------------------------
4091
4092 // _state = 0  // ..nothing..
4093 // _state = 1  // move with add point
4094 // _state = 5  // move
4095 // _state = 6  // move with insert point
4096 // _state = 7  // move with non selection
4097
4098 manualContourControler::manualContourControler()
4099 {
4100         _easyCreation = true;
4101
4102 }
4103 // ----------------------------------------------------------------------------
4104 manualContourControler::~manualContourControler()
4105 {
4106 }
4107 // ----------------------------------------------------------------------------
4108 manualContourControler * manualContourControler :: Clone()  // virtual
4109 {
4110         manualContourControler * clone = new manualContourControler();
4111         CopyAttributesTo(clone);
4112         return clone;
4113 }
4114 // ---------------------------------------------------------------------------
4115 void manualContourControler::CopyAttributesTo( manualContourControler * cloneObject)
4116 {
4117         // Fathers object
4118         manualContourBaseControler::CopyAttributesTo(cloneObject);
4119         cloneObject->SetEasyCreation( this->GetEasyCreation() );
4120 }
4121
4122 // ----------------------------------------------------------------------------
4123 void manualContourControler::Configure() //virtual
4124 {
4125  //     this->_manContModel->SetNumberOfPointsSpline(100);
4126 }
4127
4128 // ----------------------------------------------------------------------------
4129 void manualContourControler::MouseClickLeft(int x, int y){
4130
4131
4132         bool ok = false;
4133         int z   = GetZ();
4134         int size= GetManualViewBaseContour()->GetNumberOfPoints();
4135
4136         // Insert a Control Point with shift+ClickLeft
4137         // int tt = GetState();  // JPRx
4138         vtkRenderWindowInteractor *vtkrenderwindowinteractor = _vtkInteractorStyleBaseView->GetInteractor();
4139 //EED3131
4140         if( IsEditable() )
4141         {
4142                 if ( (_vtkInteractorStyleBaseView!=NULL) && (GetState()==0) && ( (vtkrenderwindowinteractor!=NULL) && (vtkrenderwindowinteractor->GetShiftKey()==1) ) )
4143                 {
4144                         ok=true;
4145                         InsertPoint(x,y,z);
4146                         size++;
4147                 }
4148                 // Start to Insert Control Points with ClickLeft (Empty contour)
4149                 if ((GetState()==0) && (size==0) && (_easyCreation==true) )
4150                 {
4151                         ok=true;
4152                         SetState(1);
4153                         AddPoint(x,y,z);
4154                 }
4155                 // Continuie to Insert Control Points with ClickLeft (After being empty the contour)
4156                 if ((GetState()==1) && (_easyCreation==true) )
4157                 {
4158                         ok=true;
4159                         AddPoint(x,y,z);
4160                         _bakIdPoint=GetNumberOfPointsManualContour() - 1;
4161                 }
4162                 // Insert Control Points IF Contour si Selected
4163                 if ((GetState()==0) && GetManualViewBaseContour()->GetPosibleSelected() )
4164                 {
4165                         ok=true;
4166                         InsertPoint(x,y,z);
4167                         _bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4168                         SetState(6);
4169                 }
4170                 // Chose id of Control Point to be move
4171                 if ( (GetState()==0 || GetState()==6) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) )
4172                 {
4173                         ok=true;
4174                         _bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4175                         SetState(5);
4176                 }
4177                 // If nothing selected _state=7
4178                 if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)==-1 ) )
4179                 {
4180                         //ok=true;
4181                         _bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4182                         SetState(7);
4183                 }
4184         }
4185         else
4186         {
4187                 SetPosibleToMove( true );
4188                 GetManualViewBaseContour()->SetSelected( GetManualViewBaseContour()->GetPosibleSelected() );
4189         }
4190         if ( GetState() == 0 && GetManualViewBaseContour()->GetPosibleSelected() )
4191         {
4192                 SetMoving( true );
4193                 ok=true;
4194                 GetManualViewBaseContour()->InitMove(x,y,z);
4195                 SetState(6);
4196         }
4197         if (ok==true)
4198         {
4199                 GetManualViewBaseContour()->Refresh();
4200         }
4201 }
4202 // ----------------------------------------------------------------------------
4203 void manualContourControler::MouseMove(int x, int y) // virtual
4204 {
4205         int z=GetZ();
4206         GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
4207         GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
4208         if (GetState()==1){     SetPoint( _bakIdPoint , x , y ,z); }
4209         if (GetState()==5){     SetPoint( _bakIdPoint , x , y ,z); }
4210         if ( GetState()==6 && !IsEditable() && GetPosibleToMove() &&IsMoving() )
4211         {
4212                 GetManualViewBaseContour()->MoveContour(x,y,z);
4213         }
4214         if (GetState()!=7 || GetManualViewBaseContour()->GetPosibleSelected() ){
4215                 GetManualViewBaseContour()->Refresh();
4216                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4217         }
4218         if (!IsEditable())
4219         {
4220                 GetManualViewBaseContour()->RemoveControlPoints();
4221                 GetManualViewBaseContour()->RemoveTextActor();
4222                 GetManualViewBaseContour()->Refresh();
4223                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4224         }
4225
4226 }
4227
4228 // ----------------------------------------------------------------------------
4229 void manualContourControler::MouseDLeft( int x, int y)//virtual
4230 {
4231         manualContourBaseControler::MouseDLeft( x, y);
4232         if ( IsEditable() )
4233         {
4234                 GetManualViewBaseContour()->AddControlPoints();
4235                 GetManualViewBaseContour()->AddTextActor();
4236                 GetManualViewBaseContour()->Refresh();
4237                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4238         }
4239 }
4240 // ----------------------------------------------------------------------------
4241 void manualContourControler::SetEasyCreation(bool easyCreation)
4242 {
4243         _easyCreation=easyCreation;
4244 }
4245 // ----------------------------------------------------------------------------
4246 bool manualContourControler::GetEasyCreation()
4247 {
4248         return _easyCreation;
4249 }
4250
4251
4252 // ----------------------------------------------------------------------------
4253 // ----------------------------------------------------------------------------
4254 // ----------------------------------------------------------------------------
4255 manualContourPerpPlaneControler::manualContourPerpPlaneControler()
4256 {
4257         _flagMouseMove = true;
4258 }
4259 // ----------------------------------------------------------------------------
4260 manualContourPerpPlaneControler::~manualContourPerpPlaneControler()
4261 {
4262 }
4263 // ----------------------------------------------------------------------------
4264 manualContourPerpPlaneControler * manualContourPerpPlaneControler :: Clone()  // virtual
4265 {
4266         manualContourPerpPlaneControler * clone = new manualContourPerpPlaneControler();
4267         CopyAttributesTo(clone);
4268         return clone;
4269 }
4270
4271 // ---------------------------------------------------------------------------
4272 void manualContourPerpPlaneControler::CopyAttributesTo( manualContourPerpPlaneControler * cloneObject)
4273 {
4274         // Fathers object
4275         manualContourControler::CopyAttributesTo(cloneObject);
4276
4277         cloneObject->SetVtkMPRBaseData( this->GetVtkMPRBaseData() );
4278         cloneObject->SetManualContour3VControler( this->GetManualContour3VControler() );
4279         cloneObject->SetVtkInteractorStylePlane2D( this->GetVtkInteractorStylePlane2D() );
4280 }
4281
4282 // ----------------------------------------------------------------------------
4283 void manualContourPerpPlaneControler::SetVtkMPRBaseData(vtkMPRBaseData *vtkmprbasedata)
4284 {
4285         _vtkmprbasedata = vtkmprbasedata;
4286 }
4287
4288 // ----------------------------------------------------------------------------
4289 vtkMPRBaseData *manualContourPerpPlaneControler::GetVtkMPRBaseData()
4290 {
4291         return _vtkmprbasedata;
4292 }
4293
4294
4295 // ----------------------------------------------------------------------------
4296 void manualContourPerpPlaneControler::InsertPoint(int x, int y, int z ) // virtual
4297 {
4298         manualContourControler::InsertPoint(  x,  y,  z );
4299         _manualcontour3Vcontroler->InsertPoint_Others(0);
4300 }
4301 // ----------------------------------------------------------------------------
4302 void manualContourPerpPlaneControler::AddPoint( int x, int y, int z )
4303 {
4304         manualContourControler::AddPoint(  x,  y,  z );
4305         _manualcontour3Vcontroler->AddPoint_Others();
4306 }
4307 // ----------------------------------------------------------------------------
4308 void manualContourPerpPlaneControler::DeleteActualMousePoint(int x, int y)
4309 {
4310         int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
4311         manualContourControler::DeleteActualMousePoint( x , y );
4312         _manualcontour3Vcontroler->DeleteActualMousePoint_Others(id);
4313 }
4314 // ----------------------------------------------------------------------------
4315 void manualContourPerpPlaneControler::MouseMove( int x, int y )
4316 {
4317         _flagMouseMove = true;
4318         int ss =this->_vtkInteractorStyleBaseView->vtkInteractorStyle::GetState();
4319         if ((this->GetState()!=7) && (ss!=1)){
4320                 manualContourControler::MouseMove( x , y );
4321                 int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
4322                 if (id!=-1)
4323                 {
4324                         _manualcontour3Vcontroler->MouseMove_Others(id);
4325                         _flagMouseMove = false;
4326                 }
4327         }
4328 }
4329 // ----------------------------------------------------------------------------
4330 void manualContourPerpPlaneControler::SetManualContour3VControler(manualContour3VControler *manualcontour3Vcontroler)
4331 {
4332         _manualcontour3Vcontroler = manualcontour3Vcontroler;
4333 }
4334 // ----------------------------------------------------------------------------
4335 manualContour3VControler * manualContourPerpPlaneControler::GetManualContour3VControler()
4336 {
4337         return _manualcontour3Vcontroler;
4338 }
4339 // ----------------------------------------------------------------------------
4340 bool manualContourPerpPlaneControler::OnChar() // virtual
4341 {
4342         if (manualContourControler::OnChar()==false )
4343         {
4344                 _manualcontour3Vcontroler->OnChar_Others();
4345         }
4346         return true;
4347 }
4348 // ----------------------------------------------------------------------------
4349 bool manualContourPerpPlaneControler::OnMouseMove() //  virtual
4350 {
4351         manualContourControler::OnMouseMove();
4352         return _flagMouseMove;
4353 }
4354 // ----------------------------------------------------------------------------
4355 bool manualContourPerpPlaneControler::OnLeftDClick() //         virtual
4356 {
4357         manualContourControler::OnLeftDClick();
4358         return _flagMouseDClick;
4359 }
4360 // ----------------------------------------------------------------------------
4361 void manualContourPerpPlaneControler::ResetContour() // virtual
4362 {
4363         manualContourControler::ResetContour();
4364         _manualcontour3Vcontroler->ResetContour_Others();
4365 }
4366
4367 // ----------------------------------------------------------------------------
4368 void manualContourPerpPlaneControler::MouseDLeft( int x, int y) // virtual
4369 {
4370         _flagMouseDClick=true;
4371         manualContourControler::MouseDLeft(x,y);
4372
4373         if (GetManualViewBaseContour()->ifTouchContour(x,y,0)==true)
4374         {
4375                 _flagMouseDClick = false;
4376                 _vtkinteractorstyleplane2D->OnLeftDClick();
4377                 ResetOrientationPlane();
4378                 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
4379         }
4380
4381 //      int id=GetManualViewBaseContour()->GetIdPoint(x,y,GetZ());
4382 //              if ( (GetState()==0) && (id!=-1) )
4383 //      {
4384 //              manualPoint *mp = this->GetManualContourModel()->GetManualPoint(id);
4385 //              _vtkmprbasedata->SetX( mp->GetX() );
4386 //              _vtkmprbasedata->SetY( mp->GetY() );
4387 //              _vtkmprbasedata->SetZ( mp->GetZ() );
4388 //              ResetOrientationPlane();
4389 //              this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
4390 //      }
4391 }
4392
4393
4394
4395 // ----------------------------------------------------------------------------
4396 void manualContourPerpPlaneControler::ResetOrientationPlane()
4397 {
4398         double p[3],rp[3],rn[3];
4399         p[0] = _vtkmprbasedata->GetX(  );
4400         p[1] = _vtkmprbasedata->GetY(  );
4401         p[2] = _vtkmprbasedata->GetZ(  );
4402         this->GetManualContourModel()->GetNearestPointAndNormal(p,rp,rn);
4403
4404         _vtkmprbasedata->SetNormal(rn[0],rn[1],rn[2]);
4405 }
4406
4407 // ----------------------------------------------------------------------------
4408 void manualContourPerpPlaneControler::SetVtkInteractorStylePlane2D(InteractorStyleMaracas *vtkinteractorstyleplane2D)
4409 {
4410         _vtkinteractorstyleplane2D = vtkinteractorstyleplane2D;
4411 }
4412 // ----------------------------------------------------------------------------
4413 InteractorStyleMaracas * manualContourPerpPlaneControler::GetVtkInteractorStylePlane2D()
4414 {
4415         return _vtkinteractorstyleplane2D;
4416 }
4417
4418 // ----------------------------------------------------------------------------
4419 // ----------------------------------------------------------------------------
4420 // ----------------------------------------------------------------------------
4421
4422 // _state = 0  // ..nothing..
4423 // _state = 5  // move point
4424 // _state = 6  // move all
4425 // _state = 7  // Empty mouse drag
4426
4427 manualRoiControler::manualRoiControler()
4428 {
4429 }
4430 // ----------------------------------------------------------------------------
4431 manualRoiControler::~manualRoiControler()
4432 {
4433 }
4434 // ----------------------------------------------------------------------------
4435 manualRoiControler * manualRoiControler :: Clone()  // virtual
4436 {
4437         manualRoiControler * clone = new manualRoiControler();
4438         CopyAttributesTo(clone);
4439         return clone;
4440 }
4441
4442 // ---------------------------------------------------------------------------
4443 void manualRoiControler::CopyAttributesTo( manualRoiControler * cloneObject)
4444 {
4445         // Fathers object
4446         manualContourBaseControler::CopyAttributesTo(cloneObject);
4447 }
4448
4449 // ----------------------------------------------------------------------------
4450 void manualRoiControler::Configure() //virtual
4451 {
4452         this->GetManualContourModel()->SetNumberOfPointsSpline(5);
4453 }
4454
4455 // ----------------------------------------------------------------------------
4456 void manualRoiControler::MouseClickLeft(int x, int y){
4457         int z = GetZ();
4458         if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) ){
4459                 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4460                 SetState(5);
4461         }
4462         if ((GetState()==0) && (GetManualViewBaseContour()->GetPosibleSelected()==true))        {
4463                 GetManualViewBaseContour()->InitMove(x,y,z);
4464                 SetState(6);
4465         }
4466         int size=GetManualViewBaseContour()->GetNumberOfPoints();
4467         if (GetState()==0) {
4468                 if (size==0){
4469                         AddPoint(x,y,z);
4470                         AddPoint(x,y,z);
4471                         AddPoint(x,y,z);
4472                         AddPoint(x,y,z);
4473                 } else {
4474                         SetPoint(0,x,y,z);
4475                         SetPoint(1,x,y,z);
4476                         SetPoint(2,x,y,z);
4477                         SetPoint(3,x,y,z);
4478                 }
4479                 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4480                 SetState(5);
4481         }
4482         GetManualViewBaseContour()->Refresh();
4483 }
4484 // ----------------------------------------------------------------------------
4485 void manualRoiControler::MouseMove(int x, int y) // virtual
4486 {
4487         int z=GetZ();
4488
4489 //      this->_vtkInteractorStyleBaseView->
4490
4491         GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
4492         GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
4493
4494         if (GetState()==5){
4495                 SetPoint( bakIdPoint , x , y ,z);
4496                 if (bakIdPoint==0)
4497                 {
4498                         SetPointX( 1 , x );
4499                         SetPointY( 3 , y );
4500                 }
4501                 if (bakIdPoint==1)
4502                 {
4503                         SetPointX( 0 , x );
4504                         SetPointY( 2 , y );
4505                 }
4506                 if (bakIdPoint==2)
4507                 {
4508                         SetPointX( 3 , x );
4509                         SetPointY( 1 , y );
4510                 }
4511                 if (bakIdPoint==3)
4512                 {
4513                         SetPointX( 2 , x );
4514                         SetPointY( 0 , y );
4515                 }
4516         }
4517         if (GetState()==6){
4518                 GetManualViewBaseContour()->MoveContour(x,y,z);
4519         }
4520         GetManualViewBaseContour()->Refresh();
4521 }
4522 // ----------------------------------------------------------------------------
4523 void manualRoiControler::DeleteActualMousePoint(int x, int y)  // virtual
4524 {
4525 }
4526 // ----------------------------------------------------------------------------
4527 void manualRoiControler::InitRoi(int ww, int hh, double porcentage)
4528 {
4529         int zz;
4530         manualPoint *mp;
4531
4532         if (GetManualContourModel()->GetSizeLstPoints() ==0)
4533         {
4534                 zz = GetZ();
4535                 AddPoint(0,0,zz);
4536                 AddPoint(0,0,zz);
4537                 AddPoint(0,0,zz);
4538                 AddPoint(0,0,zz);
4539         }
4540
4541         double pp1=porcentage;
4542         double pp2=1-porcentage;
4543
4544         mp = GetManualContourModel()->GetManualPoint(2);
4545         zz=(int)mp->GetZ();
4546         mp->SetPoint(ww*pp1,hh*pp1,zz);
4547
4548         mp = GetManualContourModel()->GetManualPoint(1);
4549         zz=(int)mp->GetZ();
4550         mp->SetPoint(ww*pp2,hh*pp1,zz);
4551
4552         mp = GetManualContourModel()->GetManualPoint(0);
4553         zz=(int)mp->GetZ();
4554         mp->SetPoint(ww*pp2,hh*pp2,zz);
4555
4556         mp = GetManualContourModel()->GetManualPoint(3);
4557         zz=(int)mp->GetZ();
4558         mp->SetPoint(ww*pp1,hh*pp2,zz);
4559
4560         GetManualViewBaseContour() ->UpdateViewPoint(0);
4561         GetManualViewBaseContour() ->UpdateViewPoint(1);
4562         GetManualViewBaseContour() ->UpdateViewPoint(2);
4563         GetManualViewBaseContour() ->UpdateViewPoint(3);
4564
4565         SetState(0);
4566         GetManualViewBaseContour()->Refresh();
4567 }
4568
4569 // ----------------------------------------------------------------------------
4570 void manualRoiControler::SetRoi(int x1, int y1,int x2, int y2)
4571 {
4572         manualPoint *mp;
4573         InitRoi( 0 , 0 , 0.2 );
4574         mp = GetManualContourModel()->GetManualPoint(2);
4575         mp->SetPointX(x1);
4576         mp->SetPointY(y1);
4577
4578         mp = GetManualContourModel()->GetManualPoint(1);
4579         mp->SetPointX(x2);
4580         mp->SetPointY(y1);
4581
4582         mp = GetManualContourModel()->GetManualPoint(0);
4583         mp->SetPointX(x2);
4584         mp->SetPointY(y2);
4585
4586         mp = GetManualContourModel()->GetManualPoint(3);
4587         mp->SetPointX(x1);
4588         mp->SetPointY(y2);
4589
4590         GetManualViewBaseContour() ->UpdateViewPoint(0);
4591         GetManualViewBaseContour() ->UpdateViewPoint(1);
4592         GetManualViewBaseContour() ->UpdateViewPoint(2);
4593         GetManualViewBaseContour() ->UpdateViewPoint(3);
4594 }
4595
4596
4597 // ----------------------------------------------------------------------------
4598 // ----------------------------------------------------------------------------
4599 // ----------------------------------------------------------------------------
4600
4601 // EED08
4602
4603 // _state = 0  // ..nothing..
4604 // _state = 5  // move point
4605 // _state = 6  // move all
4606 // _state = 7  // Empty mouse drag
4607
4608 manualCircleControler::manualCircleControler()
4609 {
4610 }
4611 // ----------------------------------------------------------------------------
4612 manualCircleControler::~manualCircleControler()
4613 {
4614 }
4615 // ----------------------------------------------------------------------------
4616 manualCircleControler * manualCircleControler :: Clone()  // virtual
4617 {
4618         manualCircleControler * clone = new manualCircleControler();
4619         CopyAttributesTo(clone);
4620         return clone;
4621 }
4622
4623 // ---------------------------------------------------------------------------
4624 void manualCircleControler::CopyAttributesTo( manualCircleControler * cloneObject)
4625 {
4626         // Fathers object
4627         manualContourBaseControler::CopyAttributesTo(cloneObject);
4628 }
4629
4630 // ----------------------------------------------------------------------------
4631 void manualCircleControler::Configure() //virtual
4632 {
4633 //      this->GetManualContourModel()->SetNumberOfPointsSpline(5);
4634 }
4635
4636 // ----------------------------------------------------------------------------
4637 void manualCircleControler::MouseClickLeft(int x, int y){
4638         int z = GetZ();
4639         if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) ){
4640                 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4641                 SetState(5);
4642         }
4643         if ((GetState()==0) && (GetManualViewBaseContour()->GetPosibleSelected()==true))        {
4644                 GetManualViewBaseContour()->InitMove(x,y,z);
4645                 SetState(6);
4646         }
4647         int size=GetManualViewBaseContour()->GetNumberOfPoints();
4648         if (GetState()==0) {
4649                 if (size==0){
4650                         AddPoint(x,y,z);
4651                         AddPoint(x,y,z);
4652 //                      AddPoint(x,y,z);
4653 //                      AddPoint(x,y,z);
4654                 } else {
4655                         SetPoint(0,x,y,z);
4656                         SetPoint(1,x,y,z);
4657 //                      SetPoint(2,x,y,z);
4658 //                      SetPoint(3,x,y,z);
4659                 }
4660                 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4661                 SetState(5);
4662         }
4663         GetManualViewBaseContour()->Refresh();
4664 }
4665 // ----------------------------------------------------------------------------
4666
4667 void manualCircleControler::MouseMove(int x, int y) // virtual
4668 {
4669         int z=GetZ();
4670
4671 //      this->_vtkInteractorStyleBaseView->
4672
4673         GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
4674         GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
4675
4676         if (GetState()==5){
4677                 SetPoint( bakIdPoint , x , y ,z);
4678 /*
4679                 if (bakIdPoint==0)
4680                 {
4681                         SetPointX( 1 , x );
4682                         SetPointY( 3 , y );
4683                 }
4684                 if (bakIdPoint==1)
4685                 {
4686                         SetPointX( 0 , x );
4687                         SetPointY( 2 , y );
4688                 }
4689
4690                 if (bakIdPoint==2)
4691                 {
4692                         SetPointX( 3 , x );
4693                         SetPointY( 1 , y );
4694                 }
4695                 if (bakIdPoint==3)
4696                 {
4697                         SetPointX( 2 , x );
4698                         SetPointY( 0 , y );
4699                 }
4700 */
4701         }
4702         if (GetState()==6){
4703                 GetManualViewBaseContour()->MoveContour(x,y,z);
4704         }
4705         GetManualViewBaseContour()->Refresh();
4706 }
4707
4708
4709 // ----------------------------------------------------------------------------
4710 void manualCircleControler::DeleteActualMousePoint(int x, int y)  // virtual
4711 {
4712 }
4713 // ----------------------------------------------------------------------------
4714
4715 void manualCircleControler::InitRoi(int ww, int hh, double porcentage)
4716 {
4717         int zz;
4718         manualPoint *mp;
4719
4720         if (GetManualContourModel()->GetSizeLstPoints() ==0)
4721         {
4722                 zz = GetZ();
4723                 AddPoint(0,0,zz);
4724                 AddPoint(0,0,zz);
4725 //              AddPoint(0,0,zz);
4726 //              AddPoint(0,0,zz);
4727         }
4728
4729         double pp1=porcentage;
4730         double pp2=1-porcentage;
4731
4732 //      mp = GetManualContourModel()->GetManualPoint(2);
4733 //      zz=(int)mp->GetZ();
4734 //      mp->SetPoint(ww*pp1,hh*pp1,zz);
4735
4736         mp = GetManualContourModel()->GetManualPoint(1);
4737         zz=(int)mp->GetZ();
4738         mp->SetPoint(ww*pp2,hh*pp1,zz);
4739
4740         mp = GetManualContourModel()->GetManualPoint(0);
4741         zz=(int)mp->GetZ();
4742         mp->SetPoint(ww*pp2,hh*pp2,zz);
4743
4744 //      mp = GetManualContourModel()->GetManualPoint(3);
4745 //      zz=(int)mp->GetZ();
4746 //      mp->SetPoint(ww*pp1,hh*pp2,zz);
4747
4748         GetManualViewBaseContour() ->UpdateViewPoint(0);
4749         GetManualViewBaseContour() ->UpdateViewPoint(1);
4750 //      GetManualViewBaseContour() ->UpdateViewPoint(2);
4751 //      GetManualViewBaseContour() ->UpdateViewPoint(3);
4752
4753         SetState(0);
4754         GetManualViewBaseContour()->Refresh();
4755 }
4756
4757 // ----------------------------------------------------------------------------
4758 /*
4759 void manualCircleControler::SetRoi(int x1, int y1,int x2, int y2)
4760 {
4761         manualPoint *mp;
4762         InitRoi( 0 , 0 , 0.2 );
4763         mp = GetManualContourModel()->GetManualPoint(2);
4764         mp->SetPointX(x1);
4765         mp->SetPointY(y1);
4766
4767         mp = GetManualContourModel()->GetManualPoint(1);
4768         mp->SetPointX(x2);
4769         mp->SetPointY(y1);
4770
4771         mp = GetManualContourModel()->GetManualPoint(0);
4772         mp->SetPointX(x2);
4773         mp->SetPointY(y2);
4774
4775         mp = GetManualContourModel()->GetManualPoint(3);
4776         mp->SetPointX(x1);
4777         mp->SetPointY(y2);
4778
4779         GetManualViewBaseContour() ->UpdateViewPoint(0);
4780         GetManualViewBaseContour() ->UpdateViewPoint(1);
4781         GetManualViewBaseContour() ->UpdateViewPoint(2);
4782         GetManualViewBaseContour() ->UpdateViewPoint(3);
4783 }
4784 */
4785
4786
4787 // ----------------------------------------------------------------------------
4788 // ----------------------------------------------------------------------------
4789 // ----------------------------------------------------------------------------
4790
4791 // AD:02-09
4792
4793 // _state = 0  // ..nothing..
4794 // _state = 5  // move point
4795 // _state = 6  // move all
4796 // _state = 7  // Empty mouse drag
4797
4798 manualLineControler::manualLineControler()
4799 {
4800 }
4801 // ----------------------------------------------------------------------------
4802 manualLineControler::~manualLineControler()
4803 {
4804 }
4805 // ----------------------------------------------------------------------------
4806 manualLineControler * manualLineControler :: Clone()  // virtual
4807 {
4808         manualLineControler * clone = new manualLineControler();
4809         CopyAttributesTo(clone);
4810         return clone;
4811 }
4812
4813 // ---------------------------------------------------------------------------
4814 void manualLineControler::CopyAttributesTo( manualLineControler * cloneObject)
4815 {
4816         // Fathers object
4817         manualContourBaseControler::CopyAttributesTo(cloneObject);
4818 }
4819
4820 // ----------------------------------------------------------------------------
4821 void manualLineControler::MouseClickLeft(int x, int y){
4822         int z = GetZ();
4823         if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) ){
4824                 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4825                 SetState(5);
4826         }
4827         if ((GetState()==0) && (GetManualViewBaseContour()->GetPosibleSelected()==true))        {
4828                 GetManualViewBaseContour()->InitMove(x,y,z);
4829                 SetState(6);
4830         }
4831         int size=GetManualViewBaseContour()->GetNumberOfPoints();
4832         if (GetState()==0) {
4833                 if (size==0){
4834                         AddPoint(x,y,z);
4835                         AddPoint(x,y,z);
4836                 } else {
4837                         SetPoint(0,x,y,z);
4838                         SetPoint(1,x,y,z);
4839                 }
4840                 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4841                 SetState(5);
4842         }
4843         GetManualViewBaseContour()->Refresh();
4844 }
4845 // ----------------------------------------------------------------------------
4846
4847 void manualLineControler::MouseMove(int x, int y) // virtual
4848 {
4849         int z=GetZ();
4850
4851         GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
4852         GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
4853
4854         if (GetState()==5)
4855         {
4856                 SetPoint( bakIdPoint , x , y ,z);
4857         }
4858         if (GetState()==6)
4859         {
4860                 GetManualViewBaseContour()->MoveContour(x,y,z);
4861         }
4862         GetManualViewBaseContour()->Refresh();
4863 }
4864
4865
4866 // ----------------------------------------------------------------------------
4867 void manualLineControler::DeleteActualMousePoint(int x, int y)  // virtual
4868 {
4869 }
4870 // ----------------------------------------------------------------------------
4871
4872 void manualLineControler::InitRoi(int ww, int hh, double porcentage)
4873 {
4874         int zz;
4875         manualPoint *mp;
4876
4877         if (GetManualContourModel()->GetSizeLstPoints() ==0)
4878         {
4879                 zz = GetZ();
4880                 AddPoint(0,0,zz);
4881                 AddPoint(0,0,zz);
4882         }
4883
4884         double pp1=porcentage;
4885         double pp2=1-porcentage;
4886
4887         mp = GetManualContourModel()->GetManualPoint(0);
4888         zz=(int)mp->GetZ();
4889         mp->SetPoint(ww*pp2,hh*pp2,zz);
4890
4891         mp = GetManualContourModel()->GetManualPoint(1);
4892         zz=(int)mp->GetZ();
4893         mp->SetPoint(ww*pp2,hh*pp1,zz);
4894
4895         GetManualViewBaseContour() ->UpdateViewPoint(0);
4896         GetManualViewBaseContour() ->UpdateViewPoint(1);
4897
4898         SetState(0);
4899         GetManualViewBaseContour()->Refresh();
4900 }
4901
4902 // ----------------------------------------------------------------------------
4903 // ----------------------------------------------------------------------------
4904 // ----------------------------------------------------------------------------
4905
4906
4907 manualContourBaseControler::manualContourBaseControler()
4908 {
4909         _manViewBaseCont        = NULL;
4910         _manContModel           = NULL;
4911         _state                          = 0;
4912         _z                                      = -900;
4913         _editable                       = true;
4914         _posibleToMove          = true;
4915         _moving                         = false;
4916         _created                        = false;
4917         _keyBoardMoving         = false;
4918 }
4919 // ----------------------------------------------------------------------------
4920 manualContourBaseControler::~manualContourBaseControler()
4921 {
4922 }
4923
4924 // ----------------------------------------------------------------------------
4925 manualContourBaseControler * manualContourBaseControler :: Clone()  // virtual
4926 {
4927         manualContourBaseControler * clone = new manualContourBaseControler();
4928         CopyAttributesTo(clone);
4929         return clone;
4930 }
4931
4932 // ---------------------------------------------------------------------------
4933
4934 void manualContourBaseControler::CopyAttributesTo( manualContourBaseControler * cloneObject)
4935 {
4936         // Fathers object
4937         InteractorStyleMaracas::CopyAttributesTo(cloneObject);
4938         cloneObject->SetZ( this->GetZ() );
4939         cloneObject->SetState( this->GetState() );
4940         cloneObject->SetEditable( this->IsEditable() );
4941         cloneObject->SetPosibleToMove( this->GetPosibleToMove() );
4942         cloneObject->SetMoving( this->IsMoving() );
4943         cloneObject->SetCompleteCreation( this->GetIfCompleteCreation() );
4944         cloneObject->SetKeyBoardMoving( this->GetKeyBoardMoving() );
4945 }
4946
4947 // ----------------------------------------------------------------------------
4948 void manualContourBaseControler::Configure() //virtual
4949 {
4950 }
4951
4952 // ----------------------------------------------------------------------------
4953 bool manualContourBaseControler::OnChar()
4954 {
4955         if ( _vtkInteractorStyleBaseView!=NULL )
4956         {
4957                 char keyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
4958
4959                 int X,Y;
4960                 wxVTKRenderWindowInteractor *_wxVTKiren;
4961                 _wxVTKiren= _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
4962                 _wxVTKiren->GetEventPosition(X, Y);
4963                 //int Z = GetZ(); // JPRx
4964                 // Delete Point
4965                 if ((keyCode==8) || (keyCode==127))
4966                 {
4967
4968                         if (!GetManualViewBaseContour()->GetPosibleSelected()==true)
4969                         {
4970                                 DeleteActualMousePoint(X,Y);
4971                         }
4972                         GetManualViewBaseContour()->Refresh();
4973                         this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4974                 }
4975                 else
4976                 {
4977                         // Magnet
4978                         if (keyCode==32)
4979                         {
4980                                 Magnet(X,Y);
4981                                 GetManualViewBaseContour()->Refresh();
4982                                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4983                         }
4984                         else if( !IsEditable() )
4985                         {
4986                                 if ( keyCode == 'L' )
4987                                 {
4988                                         GetManualViewBaseContour()->MoveContour( -1, 0 );
4989                                         SetKeyBoardMoving( true );
4990                                 }
4991                                 else if ( keyCode == 'R' )
4992                                 {
4993                                         GetManualViewBaseContour()->MoveContour( 1, 0 );
4994                                         SetKeyBoardMoving( true );
4995                                 }
4996                                 else if ( keyCode == 'U' )
4997                                 {
4998                                         GetManualViewBaseContour()->MoveContour( 0, -1 );
4999                                         SetKeyBoardMoving( true );
5000                                 }
5001                                 else if ( keyCode == 'D' )
5002                                 {
5003                                         GetManualViewBaseContour()->MoveContour( 0, 1 );
5004                                         SetKeyBoardMoving( true );
5005                                 }
5006                                 else if ( keyCode == 'W' )//Diagonal left down
5007                                 {
5008                                         GetManualViewBaseContour()->MoveContour( -1, 1 );
5009                                         SetKeyBoardMoving( true );
5010                                 }
5011                                 else if ( keyCode == 'Q' )//Diagonal left up
5012                                 {
5013                                         GetManualViewBaseContour()->MoveContour( -1, -1 );
5014                                         SetKeyBoardMoving( true );
5015                                 }
5016                                 else if( keyCode == 'P' )//Diagonal right up
5017                                 {
5018                                         GetManualViewBaseContour()->MoveContour( 1, -1 );
5019                                         SetKeyBoardMoving( true );
5020                                 }
5021                                 else if( keyCode == 'M' )//Diagonal right down
5022                                 {
5023                                         GetManualViewBaseContour()->MoveContour( 1, 1 );
5024                                         SetKeyBoardMoving( true );
5025                                 }
5026                                 if( GetKeyBoardMoving() )
5027                                 {
5028                                         GetManualViewBaseContour()->Refresh();
5029                                         this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
5030                                 }
5031                         }
5032                 }
5033         }
5034         return true;
5035 }
5036 // ----------------------------------------------------------------------------
5037 bool manualContourBaseControler::OnMouseMove()
5038 {
5039         if ( _vtkInteractorStyleBaseView!=NULL)
5040         {
5041                 int X,Y;
5042                 wxVTKRenderWindowInteractor *_wxVTKiren;
5043                 _wxVTKiren= _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5044                 _wxVTKiren->GetEventPosition( X , Y );
5045
5046
5047                 if ( (_vtkInteractorStyleBaseView->GetInteractor()->GetControlKey()==0) &&
5048                         (_vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey()==0) ) {
5049                         MouseMove(X,Y);
5050                 }
5051         }
5052         return true;
5053 }
5054 // ----------------------------------------------------------------------------
5055 bool manualContourBaseControler::OnLeftButtonDown()
5056 {
5057         SetKeyBoardMoving( false );
5058         if ( _vtkInteractorStyleBaseView!=NULL )
5059         {
5060                 int X,Y;
5061                 wxVTKRenderWindowInteractor *wxVTKiren;
5062                 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5063                 wxVTKiren->GetEventPosition(X,Y);
5064
5065                 MouseClickLeft(X,Y);
5066         }
5067         return true;
5068 }
5069 // ----------------------------------------------------------------------------
5070 bool manualContourBaseControler::OnLeftButtonUp()
5071 {
5072         if ( _vtkInteractorStyleBaseView!=NULL )
5073         {
5074                 int X,Y;
5075                 wxVTKRenderWindowInteractor *wxVTKiren;
5076                 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5077                 wxVTKiren->GetEventPosition(X,Y);
5078                 MouseReleaseLeft(X,Y);
5079         }
5080         return true;
5081 }
5082 // ----------------------------------------------------------------------------
5083 bool manualContourBaseControler::OnLeftDClick()
5084 {
5085         if ( _vtkInteractorStyleBaseView!=NULL )
5086         {
5087                 int X,Y;
5088                 wxVTKRenderWindowInteractor *wxVTKiren;
5089                 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5090                 wxVTKiren->GetEventPosition(X,Y);
5091
5092                 this->MouseDLeft(X,Y);
5093         }
5094         return true;
5095 }
5096 // ----------------------------------------------------------------------------
5097 bool manualContourBaseControler::OnMiddleButtonDown()
5098 {
5099 //      SetKeyBoardMoving( false );
5100         if ( _vtkInteractorStyleBaseView!=NULL )
5101         {
5102                 int X,Y;
5103                 wxVTKRenderWindowInteractor *wxVTKiren;
5104                 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5105                 wxVTKiren->GetEventPosition(X,Y);
5106                 GetManualViewBaseContour()->InitMove( X, Y,GetZ());
5107         }
5108         return true;
5109 }
5110 // ----------------------------------------------------------------------------
5111 bool manualContourBaseControler::OnMiddleButtonUp()
5112 {
5113         return true;
5114 }
5115 // ----------------------------------------------------------------------------
5116 bool manualContourBaseControler::OnRightButtonDown()
5117 {
5118         if( _vtkInteractorStyleBaseView!= NULL )
5119         {
5120                 int X,Y;
5121                 wxVTKRenderWindowInteractor *wxVTKiren;
5122                 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5123                 wxVTKiren->GetEventPosition(X, Y);
5124
5125                 SetCompleteCreation( true );
5126                 SetKeyBoardMoving( false );
5127                 MouseClickRight(X,Y);
5128         }
5129         return true;
5130 }
5131 // ----------------------------------------------------------------------------
5132 bool manualContourBaseControler::OnRightButtonUp()
5133 {
5134         return true;
5135 }
5136 // ----------------------------------------------------------------------------
5137 void manualContourBaseControler::SetModelView(manualContourModel *manContModel, manualViewBaseContour *manViewBaseCont){
5138         _manContModel           =       manContModel;
5139         _manViewBaseCont        =       manViewBaseCont;
5140         _manViewBaseCont->SetEditable( &_editable );
5141 }
5142 // ----------------------------------------------------------------------------
5143 manualContourModel* manualContourBaseControler::GetManualContourModel()
5144 {
5145         return _manContModel;
5146 }
5147 // ----------------------------------------------------------------------------
5148 manualViewBaseContour* manualContourBaseControler::GetManualViewBaseContour()
5149 {
5150         return _manViewBaseCont;
5151 }
5152 // ----------------------------------------------------------------------------
5153 void manualContourBaseControler::MouseClickLeft(int x, int y) // virtual
5154 {
5155
5156 }
5157 // ----------------------------------------------------------------------------
5158 void manualContourBaseControler::MouseClickRight(int x, int y)
5159 {
5160         if (_state==1)
5161         {
5162                 _state=0;
5163         }
5164         SetEditable( false );
5165         SetPosibleToMove( false );
5166         //_state = 0;
5167         _state=7;
5168 }
5169 // ----------------------------------------------------------------------------
5170 void manualContourBaseControler::MouseReleaseLeft(int x, int y)
5171 {
5172         if (_state==5){ _state = 0; }
5173         if (_state==6){ _state = 0; }
5174         if (_state==7){ _state = 0; }
5175         SetMoving( false );
5176         GetManualViewBaseContour()->SelectPosibleContour(x,y,GetZ());
5177         if( GetIfCompleteCreation() && IsEditable() && !GetManualViewBaseContour()->GetPosibleSelected() && (GetManualViewBaseContour()->GetIdPoint(x,y,GetZ())==-1)  )
5178         {
5179                 SetEditable( false );
5180                 SetPosibleToMove( false );
5181         }
5182 }
5183 // ----------------------------------------------------------------------------
5184 void manualContourBaseControler::MouseDLeft(int x, int y )
5185 {
5186         if (_state==0)
5187         {
5188                 int z=GetZ();
5189                 GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
5190                 GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
5191                 if ( GetManualViewBaseContour()->GetPosibleSelected() )
5192                 {
5193                         _editable = true;
5194                 }
5195         }
5196 }
5197 // ----------------------------------------------------------------------------
5198 void manualContourBaseControler::MouseMove(int x, int y) // virtual
5199 {
5200 }
5201 // ----------------------------------------------------------------------------
5202 void manualContourBaseControler::SetState(int state)
5203 {
5204         _state=state;
5205 }
5206 // ----------------------------------------------------------------------------
5207 int manualContourBaseControler::GetState()
5208 {
5209         return _state;
5210 }
5211 // ----------------------------------------------------------------------------
5212 bool manualContourBaseControler::IsEditable( )
5213 {
5214         return _editable;
5215 }
5216 // ----------------------------------------------------------------------------
5217 void manualContourBaseControler::SetEditable(  bool condition  )
5218 {
5219         if (GetManualViewBaseContour()!=NULL) {
5220                 if( !condition )
5221                 {
5222                         GetManualViewBaseContour()->RemoveControlPoints();
5223                 }
5224                 GetManualViewBaseContour()->SetSelected( condition );
5225         }
5226         _editable = condition;
5227 }
5228
5229 // ----------------------------------------------------------------------------
5230 bool manualContourBaseControler::GetPosibleToMove()
5231 {
5232         return _posibleToMove;
5233 }
5234 // ----------------------------------------------------------------------------
5235 void manualContourBaseControler::SetPosibleToMove( bool condition )
5236 {
5237         _posibleToMove = condition;
5238 }
5239 // ----------------------------------------------------------------------------
5240 bool manualContourBaseControler::IsMoving()
5241 {
5242         return _moving;
5243 }
5244 // ----------------------------------------------------------------------------
5245 void manualContourBaseControler::SetMoving( bool condition )
5246 {
5247         _moving = condition;
5248 }
5249 // ----------------------------------------------------------------------------
5250 void manualContourBaseControler::SetCompleteCreation( bool condition )
5251 {
5252         _created = condition;
5253 }
5254 // ----------------------------------------------------------------------------
5255 bool manualContourBaseControler::GetIfCompleteCreation ( )
5256 {
5257         return _created;
5258 }
5259 // ----------------------------------------------------------------------------
5260 void manualContourBaseControler::SetKeyBoardMoving( bool condition )
5261 {
5262         _keyBoardMoving = condition;
5263 }
5264 // ----------------------------------------------------------------------------
5265 bool manualContourBaseControler::GetKeyBoardMoving(  )
5266 {
5267         return _keyBoardMoving;
5268 }
5269 // ----------------------------------------------------------------------------
5270 void manualContourBaseControler::CreateNewManualContour(){
5271         _manViewBaseCont->CreateNewContour();
5272 }
5273 // ----------------------------------------------------------------------------
5274 int     manualContourBaseControler::GetNumberOfPointsManualContour(){
5275         return _manViewBaseCont->GetNumberOfPoints();
5276 }
5277 // ----------------------------------------------------------------------------
5278
5279 //JSTG - 25-02-08 -------------------------------------------------------------
5280 int     manualContourBaseControler::GetNumberOfPointsSplineManualContour(){
5281         //return _manViewBaseCont->GetNumberOfPointsSpline();
5282         return _manContModel->GetNumberOfPointsSpline();
5283 }
5284 // ----------------------------------------------------------------------------
5285
5286 double* manualContourBaseControler::GetVectorPointsXManualContour(){
5287         return _manViewBaseCont->GetVectorPointsXManualContour();
5288 }
5289 // ----------------------------------------------------------------------------
5290 double* manualContourBaseControler::GetVectorPointsYManualContour(){
5291         return _manViewBaseCont->GetVectorPointsYManualContour();
5292 }
5293 // ----------------------------------------------------------------------------
5294 void manualContourBaseControler::DeleteContour(){
5295         _manViewBaseCont->DeleteContour();
5296         _manContModel->DeleteAllPoints();
5297 }
5298 // ----------------------------------------------------------------------------
5299 void manualContourBaseControler::DeleteActualMousePoint(int x, int y)// virtual
5300 {
5301         if ((_manContModel!=NULL) && (_manViewBaseCont!=NULL) )
5302         {
5303                 int id=_manViewBaseCont->GetIdPoint(x,y,GetZ());
5304                 if ((id!=-1) && (_manContModel->GetSizeLstPoints()>2) ){
5305                         _manContModel->DeletePoint(id);
5306                         _manViewBaseCont->DeletePoint(id);
5307                 }
5308         }
5309         _state = 0;
5310 }
5311
5312 // ----------------------------------------------------------------------------
5313 void manualContourBaseControler::Magnet(int x, int y)
5314 {
5315         if( IsEditable())
5316         {
5317                 /*int id= */ _manViewBaseCont->GetIdPoint(x,y,GetZ()); // JPRx
5318                 if (GetManualContourModel()!=NULL){
5319                         double  xx      = x;
5320                         double  yy      = y;
5321                         double  zz      = GetZ();
5322                         GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5323                         int                     id      = GetManualContourModel()->GetIdPoint(xx,yy,zz,32000,-1);
5324                         if (id!=-1)
5325                         {
5326                                 manualPoint     *mp     = GetManualContourModel()->GetManualPoint(id);
5327                                 mp->SetPoint(xx,yy,zz);
5328                         }
5329         //              GetManualViewBaseContour()->UpdateViewPoint(id);
5330                 }
5331                 _state = 0;
5332         }
5333 }
5334
5335 // ----------------------------------------------------------------------------
5336 void manualContourBaseControler::SetZ(int z)
5337 {
5338         _z=z;
5339 }
5340 // ----------------------------------------------------------------------------
5341 int manualContourBaseControler::GetZ()
5342 {
5343         return _z;
5344 }
5345 // ----------------------------------------------------------------------------
5346 void manualContourBaseControler::AddPoint(int x, int y, int z) // virtual
5347 {
5348         if (GetManualContourModel()!=NULL){
5349                 double  xx      = x;
5350                 double  yy      = y;
5351                 double  zz      = z;
5352                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5353                 /*int   id              =*/  GetManualContourModel()->AddPoint(xx,yy,zz);  // JPRx
5354                 GetManualViewBaseContour()->AddPoint();
5355 //              GetManualViewBaseContour()->UpdateViewPoint(id);
5356         }
5357 }
5358 // ----------------------------------------------------------------------------
5359 void manualContourBaseControler::InsertPoint(int x,int y,int z)  // virtual
5360 {
5361 //EEDzz
5362         int id=-1;
5363         if (GetManualContourModel()!=NULL){
5364                 double                          xx              = x;
5365                 double                          yy              = y;
5366                 double                          zz              = z;
5367                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5368                 if (GetManualContourModel()->GetSizeLstPoints()>1){
5369                         id = GetManualContourModel()->InsertPoint(xx,yy,zz);
5370                         GetManualViewBaseContour()->InsertPoint(id);
5371 //                      GetManualViewBaseContour()->UpdateViewPoint(id);
5372                 } else {
5373                         GetManualContourModel()->AddPoint(xx,yy,zz);
5374                         GetManualViewBaseContour()->AddPoint();
5375 //                      AddPoint(x,y,z);
5376 //                      GetManualViewBaseContour()->UpdateViewPoint(id);
5377                 }
5378         }
5379 }
5380
5381 // ----------------------------------------------------------------------------
5382 void manualContourBaseControler::SetPoint( int id ,int x , int y , int z){ // virtual
5383         if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
5384                 double xx = x;
5385                 double yy = y;
5386                 double zz = z;
5387                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5388                 manualPoint             *mp             = _manContModel->GetManualPoint(id);
5389                 mp->SetPoint(xx,yy,zz);
5390                 GetManualViewBaseContour()->UpdateViewPoint(id);
5391         }
5392 }
5393 // ----------------------------------------------------------------------------
5394 void manualContourBaseControler::SetPointX( int id ,int x  ){
5395         if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
5396                 double xx = x;
5397                 double yy = 0;
5398                 double zz = 0;
5399                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5400                 manualPoint             *mp             = _manContModel->GetManualPoint(id);
5401                 mp->SetPointX(xx);
5402                 GetManualViewBaseContour()->UpdateViewPoint(id);
5403         }
5404 }
5405 // ----------------------------------------------------------------------------
5406 void manualContourBaseControler::SetPointY( int id ,int y  ){
5407         if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
5408                 double xx = 0;
5409                 double yy = y;
5410                 double zz = 0;
5411                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5412                 manualPoint             *mp             = _manContModel->GetManualPoint(id);
5413                 mp->SetPointY(yy);
5414                 GetManualViewBaseContour()->UpdateViewPoint(id);
5415         }
5416 }
5417 // ----------------------------------------------------------------------------
5418 void manualContourBaseControler::SetPointZ( int id ,int z  ){
5419         if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
5420                 double xx = 0;
5421                 double yy = 0;
5422                 double zz = z;
5423                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5424                 manualPoint             *mp             = _manContModel->GetManualPoint(id);
5425                 mp->SetPointZ(zz);
5426                 GetManualViewBaseContour()->UpdateViewPoint(id);
5427         }
5428 }
5429 // ----------------------------------------------------------------------------
5430 void manualContourBaseControler::ResetContour() // virtual
5431 {
5432         this->DeleteContour();
5433         GetManualViewBaseContour()->CreateNewContour();
5434         this->SetState(0);
5435 }
5436