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 //EED01
2166         printf("EED manualViewRoi::RefreshContour np %d \n", np);
2167         if ( np > 0)
2168         {
2169                 if (np>=2)
2170                 {
2171                         manualPoint     *mp;
2172                         for( i = 0; i < np+1; i++ ) {
2173                                 ii=i%np;
2174                                 mp = _manContModel->GetManualPoint(ii);
2175
2176         //EEDx6
2177                                 double XX=mp->GetX(),YY=mp->GetY(),ZZ=mp->GetZ();
2178         //                      wxVtk2DBaseView *wxvtk2Dbasevie = (wxVtk2DBaseView*)this->GetWxVtkBaseView();
2179         //                      wxvtk2Dbasevie->TransformCoordinate_spacing_ModelToView(XX,YY,ZZ);
2180
2181         //EED 27 sep 2007
2182         //                      _pts->SetPoint(i, XX,YY,ZZ );
2183 printf("EED manualViewRoi::RefreshContour ZZ %f   _spc%f \n", ZZ, _spc[2] );
2184                                 _pts->SetPoint(i, XX*_spc[0] , YY*_spc[1] , ZZ*_spc[2] );
2185                         } //  rof
2186
2187                 } else {
2188                                 _pts->SetPoint(0, 0 , 0 , 0);
2189                                 _pts->SetPoint(1, 0 , 0 , 0);
2190                 } // if
2191         }
2192 }
2193
2194 // ----------------------------------------------------------------------------
2195 int manualViewRoi::GetType() // virtual
2196 {
2197         return 2;
2198 }
2199
2200 // ----------------------------------------------------------------------------
2201
2202 void manualViewRoi::GetMinMax(double &minX,double &minY, double &maxX, double &maxY)
2203 {
2204         double  pp[3];
2205         manualPoint *mp;
2206     unsigned int i;
2207
2208         minX=99999;
2209         minY=99999;
2210         maxX=-99999;
2211         maxY=-99999;
2212
2213         unsigned int size=(unsigned int) _manContModel->GetSizeLstPoints();
2214
2215         for( i = 0; i < size; i++ )
2216         {
2217
2218                 mp=_manContModel->GetManualPoint(i);
2219                 pp[0]=mp->GetX();
2220                 pp[1]=mp->GetY();
2221
2222                 // min X
2223                 if (pp[0]<minX)
2224                 {
2225                         minX=pp[0];
2226                 }
2227                 //min Y
2228                 if (pp[1]<minY)
2229                 {
2230                         minY=pp[1];
2231                 }
2232                 //max X
2233                 if (pp[0]>maxX)
2234                 {
2235                         maxX=pp[0];
2236                 }
2237                 // max Y
2238                 if (pp[1]>maxY)
2239                 {
2240                         maxY=pp[1];
2241                 }
2242         }
2243
2244         if ( size<1 )
2245         {
2246                 minX=0;
2247                 maxX=0;
2248                 minY=0;
2249                 maxY=0;
2250         }
2251 }
2252
2253 // ----------------------------------------------------------------------------
2254
2255 bool manualViewRoi::ifTouchContour(int x,int y, int z) // virtual
2256 {
2257         bool    result=false;
2258         double  px1=99999,py1=99999,px2=-9999,py2=-99999;
2259
2260         GetMinMax(px1,py1, px2, py2);
2261
2262         double xx=x;
2263         double yy=y;
2264         double zz=z;
2265         TransfromeCoordViewWorld(xx,yy,zz);
2266
2267         bool ok1=false;
2268         bool ok2=false;
2269         double ddx=GetRange();
2270         double ddy=GetRange();
2271
2272         if ((xx>px1-ddx)&&(xx<px2+ddx) &&  (yy>py1-ddy)&&(yy<py2+ddy))
2273         {
2274                 ok1=true;
2275         }
2276
2277         if ((xx>px1+ddx)&&(xx<px2-ddx) &&  (yy>py1+ddy)&&(yy<py2-ddy))
2278         {
2279                 ok2=true;
2280         }
2281
2282         if ((ok1==true) && (ok2==false))
2283         {
2284                 result=true;
2285         }
2286
2287         return result;
2288 }
2289
2290
2291 // ----------------------------------------------------------------------------
2292
2293 void manualViewRoi::InitMove(int x, int y, int z)  // virtual
2294 {
2295         manualPoint *mp;
2296         double XX=x;
2297         double YY=y;
2298         double ZZ=z;
2299         TransfromeCoordViewWorld(XX,YY,ZZ);
2300
2301         if (_manContModel->GetSizeLstPoints()==4){
2302                 mp = _manContModel->GetManualPoint(0);
2303                 _dp0[0]= mp->GetX() - XX;
2304                 _dp0[1]= mp->GetY() - YY;
2305                 _dp0[2]= mp->GetZ();
2306
2307                 mp = _manContModel->GetManualPoint(1);
2308                 _dp1[0]= mp->GetX() - XX;
2309                 _dp1[1]= mp->GetY() - YY;
2310                 _dp1[2]= mp->GetZ();
2311
2312                 mp = _manContModel->GetManualPoint(2);
2313                 _dp2[0]= mp->GetX() - XX;
2314                 _dp2[1]= mp->GetY() - YY;
2315                 _dp2[2]= mp->GetZ();
2316
2317                 mp = _manContModel->GetManualPoint(3);
2318                 _dp3[0]= mp->GetX() - XX;
2319                 _dp3[1]= mp->GetY() - YY;
2320                 _dp3[2]= mp->GetZ();
2321         }
2322 }
2323
2324 // ----------------------------------------------------------------------------
2325
2326 void manualViewRoi::MoveContour(int x, int y, int z) // virtual
2327 {
2328         manualPoint *mp;
2329         double XX=x;
2330         double YY=y;
2331         double ZZ=z;
2332         TransfromeCoordViewWorld(XX,YY,ZZ);
2333
2334         mp = _manContModel->GetManualPoint(0);
2335         mp->SetPoint(_dp0[0]+XX,_dp0[1]+YY,_dp0[2]);
2336
2337         mp = _manContModel->GetManualPoint(1);
2338         mp->SetPoint(_dp1[0]+XX,_dp1[1]+YY,_dp0[2]);
2339
2340         mp = _manContModel->GetManualPoint(2);
2341         mp->SetPoint(_dp2[0]+XX,_dp2[1]+YY,_dp0[2]);
2342
2343         mp = _manContModel->GetManualPoint(3);
2344         mp->SetPoint(_dp3[0]+XX,_dp3[1]+YY,_dp0[2]);
2345
2346         UpdateViewPoint(0);
2347         UpdateViewPoint(1);
2348         UpdateViewPoint(2);
2349         UpdateViewPoint(3);
2350
2351 }
2352
2353
2354
2355 // ----------------------------------------------------------------------------
2356 // ----------------------------------------------------------------------------
2357 // ----------------------------------------------------------------------------
2358
2359 // EED08
2360
2361 manualViewCircle::manualViewCircle()
2362 {
2363 //      _sizePointsContour=5;   // default 100
2364 }
2365 // ----------------------------------------------------------------------------
2366 manualViewCircle::~manualViewCircle()
2367 {
2368 }
2369
2370
2371 // ----------------------------------------------------------------------------
2372 manualViewCircle * manualViewCircle :: Clone()
2373 {
2374         manualViewCircle * clone = new manualViewCircle();
2375         CopyAttributesTo(clone);
2376         return clone;
2377 }
2378
2379 // ---------------------------------------------------------------------------
2380
2381 void manualViewCircle::CopyAttributesTo( manualViewCircle * cloneObject)
2382 {
2383         // Fathers object
2384         manualViewBaseContour::CopyAttributesTo(cloneObject);
2385 }
2386
2387
2388 // ----------------------------------------------------------------------------
2389 /*
2390 void manualViewCircle::RefreshContour(){ // virtual
2391
2392         manualPoint     *mpA,*mpB;
2393     unsigned int i, np,nps;
2394         double angle,radio;
2395         double difX,difY;
2396         double XX,YY,ZZ;
2397     np  = GetNumberOfPoints( );
2398         nps = _manContModel->GetNumberOfPointsSpline();
2399         double deltaAngle=(3.14159265*2)/(nps-1);
2400         if ( np > 0)
2401         {
2402                 if (np==2)
2403                 {
2404                         mpA             = _manContModel->GetManualPoint(0);
2405                         mpB             = _manContModel->GetManualPoint(1);
2406                         difX    = mpA->GetX() - mpB->GetX();
2407                         difY    = mpA->GetY() - mpB->GetY();
2408                         radio   = sqrt( difX*difX + difY*difY );
2409                         manualContourModelCircle *manContModelCir = (manualContourModelCircle*)_manContModel;
2410                         manContModelCir->SetRadio(radio);
2411
2412                         for( i = 0; i < nps; i++ ) {
2413                                 manContModelCir->GetSpline_i_Point(i, &XX, &YY, &ZZ);
2414 //                              angle = deltaAngle*i;
2415 //                              XX = cos(angle)*radio+mpA->GetX();
2416 //                              YY = sin(angle)*radio+mpA->GetY();
2417                                 ZZ = mpA->GetZ();
2418                                 _pts->SetPoint(i, XX*_spc[0] , YY*_spc[1] , ZZ*_spc[2] );
2419                         } //  rof
2420                 } else {
2421                                 _pts->SetPoint(0, 0 , 0 , 0);
2422                                 _pts->SetPoint(1, 0 , 0 , 0);
2423                 } // if
2424         }
2425 }
2426 */
2427
2428 // ----------------------------------------------------------------------------
2429 int manualViewCircle::GetType() // virtual
2430 {
2431         return 3;
2432 }
2433
2434 // ----------------------------------------------------------------------------
2435
2436 void manualViewCircle::GetMinMax(double &minX,double &minY, double &maxX, double &maxY)
2437 {
2438         manualPoint     *mpA,*mpB;
2439     unsigned int  np;
2440         double radio;
2441         double difX,difY;
2442     np  = GetNumberOfPoints( );
2443         if (np==2)
2444         {
2445                 mpA             = _manContModel->GetManualPoint(0);
2446                 mpB             = _manContModel->GetManualPoint(1);
2447                 difX    = mpA->GetX() - mpB->GetX();
2448                 difY    = mpA->GetY() - mpB->GetY();
2449                 radio   = sqrt( difX*difX + difY*difY );
2450                 minX=mpA->GetX()-radio;
2451                 minY=mpA->GetY()-radio;
2452                 maxX=mpA->GetX()+radio;
2453                 maxY=mpA->GetY()+radio;
2454         } else {
2455                 minX=0;
2456                 maxX=0;
2457                 minY=0;
2458                 maxY=0;
2459         }
2460 }
2461
2462 /*
2463 // ----------------------------------------------------------------------------
2464 bool manualViewCircle::ifTouchContour(int x,int y, int z) // virtual
2465 {
2466         bool    result=false;
2467         double  px1=99999,py1=99999,px2=-9999,py2=-99999;
2468
2469         GetMinMax(px1,py1, px2, py2);
2470
2471         double xx=x;
2472         double yy=y;
2473         double zz=z;
2474         TransfromeCoordViewWorld(xx,yy,zz);
2475
2476         bool ok1=false;
2477         bool ok2=false;
2478         double ddx=GetRange();
2479         double ddy=GetRange();
2480
2481         if ((xx>px1-ddx)&&(xx<px2+ddx) &&  (yy>py1-ddy)&&(yy<py2+ddy))
2482         {
2483                 ok1=true;
2484         }
2485
2486         if ((xx>px1+ddx)&&(xx<px2-ddx) &&  (yy>py1+ddy)&&(yy<py2-ddy))
2487         {
2488                 ok2=true;
2489         }
2490
2491         if ((ok1==true) && (ok2==false))
2492         {
2493                 result=true;
2494         }
2495
2496         return result;
2497 }
2498 */
2499
2500 // ----------------------------------------------------------------------------
2501
2502 void manualViewCircle::InitMove(int x, int y, int z)  // virtual
2503 {
2504         manualPoint *mp;
2505         double XX=x;
2506         double YY=y;
2507         double ZZ=z;
2508         TransfromeCoordViewWorld(XX,YY,ZZ);
2509
2510         if (_manContModel->GetSizeLstPoints()==2){
2511                 mp = _manContModel->GetManualPoint(0);
2512                 _dp0[0]= mp->GetX() - XX;
2513                 _dp0[1]= mp->GetY() - YY;
2514                 _dp0[2]= mp->GetZ();
2515
2516                 mp = _manContModel->GetManualPoint(1);
2517                 _dp1[0]= mp->GetX() - XX;
2518                 _dp1[1]= mp->GetY() - YY;
2519                 _dp1[2]= mp->GetZ();
2520 /*
2521                 mp = _manContModel->GetManualPoint(2);
2522                 _dp2[0]= mp->GetX() - XX;
2523                 _dp2[1]= mp->GetY() - YY;
2524                 _dp2[2]= mp->GetZ();
2525
2526                 mp = _manContModel->GetManualPoint(3);
2527                 _dp3[0]= mp->GetX() - XX;
2528                 _dp3[1]= mp->GetY() - YY;
2529                 _dp3[2]= mp->GetZ();
2530 */
2531         }
2532 }
2533
2534
2535 // ----------------------------------------------------------------------------
2536 void manualViewCircle::MoveContour(int x, int y, int z) // virtual
2537 {
2538         manualPoint *mp;
2539         double XX=x;
2540         double YY=y;
2541         double ZZ=z;
2542         TransfromeCoordViewWorld(XX,YY,ZZ);
2543
2544         mp = _manContModel->GetManualPoint(0);
2545         mp->SetPoint(_dp0[0]+XX,_dp0[1]+YY,_dp0[2]);
2546
2547         mp = _manContModel->GetManualPoint(1);
2548         mp->SetPoint(_dp1[0]+XX,_dp1[1]+YY,_dp0[2]);
2549
2550 //      mp = _manContModel->GetManualPoint(2);
2551 //      mp->SetPoint(_dp2[0]+XX,_dp2[1]+YY,_dp0[2]);
2552
2553 //      mp = _manContModel->GetManualPoint(3);
2554 //      mp->SetPoint(_dp3[0]+XX,_dp3[1]+YY,_dp0[2]);
2555
2556         UpdateViewPoint(0);
2557         UpdateViewPoint(1);
2558 //      UpdateViewPoint(2);
2559 //      UpdateViewPoint(3);
2560
2561 }
2562
2563
2564
2565 // ----------------------------------------------------------------------------
2566 // ----------------------------------------------------------------------------
2567 // ----------------------------------------------------------------------------
2568
2569 // AD:02-09
2570
2571 manualViewLine::manualViewLine()
2572 {
2573 }
2574 // ----------------------------------------------------------------------------
2575 manualViewLine::~manualViewLine()
2576 {
2577 }
2578
2579
2580 // ----------------------------------------------------------------------------
2581 manualViewLine * manualViewLine :: Clone()
2582 {
2583         manualViewLine * clone = new manualViewLine();
2584         CopyAttributesTo(clone);
2585         return clone;
2586 }
2587
2588 // ---------------------------------------------------------------------------
2589
2590 void manualViewLine::CopyAttributesTo( manualViewLine * cloneObject)
2591 {
2592         // Fathers object
2593         manualViewBaseContour::CopyAttributesTo(cloneObject);
2594 }
2595
2596 // ----------------------------------------------------------------------------
2597 int manualViewLine::GetType() // virtual
2598 {
2599         return 6;
2600 }
2601
2602
2603 // ----------------------------------------------------------------------------
2604
2605 void manualViewLine::InitMove(int x, int y, int z)  // virtual
2606 {
2607         manualPoint *mp;
2608         double XX=x;
2609         double YY=y;
2610         double ZZ=z;
2611         TransfromeCoordViewWorld(XX,YY,ZZ);
2612
2613         if (_manContModel->GetSizeLstPoints()==2)
2614         {
2615                 mp = _manContModel->GetManualPoint(0);
2616                 _dp0[0]= mp->GetX() - XX;
2617                 _dp0[1]= mp->GetY() - YY;
2618                 _dp0[2]= mp->GetZ();
2619
2620                 mp = _manContModel->GetManualPoint(1);
2621                 _dp1[0]= mp->GetX() - XX;
2622                 _dp1[1]= mp->GetY() - YY;
2623                 _dp1[2]= mp->GetZ();
2624
2625         }
2626 }
2627
2628
2629 // ----------------------------------------------------------------------------
2630 void manualViewLine::MoveContour(int x, int y, int z) // virtual
2631 {
2632         manualPoint *mp;
2633         double XX=x;
2634         double YY=y;
2635         double ZZ=z;
2636         TransfromeCoordViewWorld(XX,YY,ZZ);
2637
2638         mp = _manContModel->GetManualPoint(0);
2639         mp->SetPoint(_dp0[0]+XX,_dp0[1]+YY,_dp0[2]);
2640
2641         mp = _manContModel->GetManualPoint(1);
2642         mp->SetPoint(_dp1[0]+XX,_dp1[1]+YY,_dp0[2]);
2643
2644
2645         UpdateViewPoint(0);
2646         UpdateViewPoint(1);
2647 }
2648
2649
2650 // ----------------------------------------------------------------------------
2651 // ----------------------------------------------------------------------------
2652 // ----------------------------------------------------------------------------
2653
2654
2655 manualViewBaseContour::manualViewBaseContour()
2656 {
2657         _show_text                      = true;
2658         _textActor                      = NULL;
2659         _manContModel           = NULL;
2660         _wxvtkbaseview          = NULL;
2661         _selected                       = false;
2662         _posibleSelected        = false;
2663         _viewControlPoints      = false;
2664         _pts                            = NULL;
2665         _pd                                     = NULL;
2666         _contourVtkActor        = NULL;
2667         _bboxMapper                     = NULL;
2668         _range                          = 1;
2669         _sizePointsContour      = 100;
2670         _spc[0]                         = 1;
2671         _spc[1]                         = 1;
2672         _spc[2]                         = 1;
2673
2674         _coulorEdit_r           = 1;
2675         _coulorEdit_g           = 1;
2676         _coulorEdit_b           = 0;
2677
2678         _coulorNormal_r         = 1;
2679         _coulorNormal_g         = 0;
2680         _coulorNormal_b         = 1;
2681
2682         _coulorSelection_r      = 0;
2683         _coulorSelection_g      = 1;
2684         _coulorSelection_b      = 0;
2685
2686         _widthline                      = 1;
2687
2688 }
2689 // ----------------------------------------------------------------------------
2690 manualViewBaseContour::~manualViewBaseContour()
2691 {
2692         int i,size=_lstViewPoints.size();
2693         for (i=0;i<size; i++){
2694                 delete _lstViewPoints[i];
2695         }
2696         _lstViewPoints.clear();
2697 }
2698 // ----------------------------------------------------------------------------
2699
2700
2701 int manualViewBaseContour::GetType() // virtual
2702 {
2703 // Information...
2704 //int manualViewBaseContour::GetType()          0;
2705 //int manualViewContour::GetType()                      1;
2706 //int manualViewRoi::GetType()                          2;
2707 //int manualViewCircle::GetType()                       3;
2708 //int manualViewStar::GetType()                         4;
2709 //int manualViewLine::GetType()                         6;
2710
2711
2712         return 0;
2713 }
2714 // ----------------------------------------------------------------------------
2715
2716 void manualViewBaseContour::Save(FILE *pFile)
2717 {
2718         fprintf(pFile,"TypeView %d\n", GetType() );
2719 }
2720
2721 // ----------------------------------------------------------------------------
2722 void manualViewBaseContour::Open(FILE *pFile)
2723 {
2724 }
2725
2726 // ----------------------------------------------------------------------------
2727 void manualViewBaseContour :: AddCompleteContourActor(  bool ifControlPoints )
2728 {
2729         _viewControlPoints = ifControlPoints;
2730          /*vtkRenderer * theRenderer = */  _wxvtkbaseview->GetRenderer();  // JPRx ??
2731          //Adding the spline
2732          AddSplineActor();
2733
2734          AddTextActor();
2735          //Adding each control point
2736          if( ifControlPoints )
2737                 AddControlPoints();
2738          RefreshContour();
2739          Refresh();
2740 }
2741 // ---------------------------------------------------------------------------
2742
2743 void manualViewBaseContour :: RemoveCompleteContourActor()
2744 {
2745         /*vtkRenderer * theRenderer =*/  _wxvtkbaseview->GetRenderer(); // JPRx ??
2746          //Removing the spline
2747         RemoveSplineActor();
2748         RemoveTextActor();
2749
2750         //Removing each point
2751         RemoveControlPoints();
2752         RefreshContour();
2753         Refresh();
2754 }
2755 // ---------------------------------------------------------------------------
2756 manualViewBaseContour *  manualViewBaseContour :: Clone( )//virtual
2757 {
2758         manualViewBaseContour * clone = new manualViewBaseContour();
2759         CopyAttributesTo(clone);
2760         return clone;
2761
2762 }
2763
2764 // ---------------------------------------------------------------------------
2765
2766 void manualViewBaseContour::CopyAttributesTo( manualViewBaseContour * cloneObject)
2767 {
2768         // Fathers object
2769         //XXXX::CopyAttributesTo(cloneObject);
2770
2771         cloneObject-> SetWxVtkBaseView( this->_wxvtkbaseview );
2772         cloneObject-> SetSelected( this->GetSelected() );
2773         cloneObject-> SetPosibleSelected( this->GetPosibleSelected() );
2774         cloneObject-> SetIfViewControlPoints( this->GetIfViewControlPoints() );
2775         cloneObject-> SetRange( this->GetRange() );
2776         cloneObject-> SetZ( this->GetZ() );
2777         cloneObject-> SetSpacing( _spc );
2778         cloneObject-> SetColorNormalContour( _coulorNormal_r, _coulorNormal_g, _coulorNormal_b );
2779         cloneObject-> SetColorEditContour( _coulorEdit_r, _coulorEdit_g, _coulorEdit_b );
2780         cloneObject-> SetColorSelectContour( _coulorSelection_r, _coulorSelection_g, _coulorSelection_b );
2781
2782         int i, size = _lstViewPoints.size();
2783         for ( i=0; i<size; i++ )
2784         {
2785                 cloneObject->AddPoint(  );
2786         }
2787 }
2788
2789 // ----------------------------------------------------------------------------
2790 void manualViewBaseContour :: AddSplineActor()
2791 {
2792         vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
2793         if (_contourVtkActor!=NULL)
2794                 theRenderer->AddActor( _contourVtkActor  );
2795 }
2796 // ----------------------------------------------------------------------------
2797 void manualViewBaseContour :: RemoveSplineActor() // virtual
2798 {
2799         vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
2800         if (_contourVtkActor!=NULL)
2801                 theRenderer->RemoveActor( _contourVtkActor );
2802 }
2803 // ----------------------------------------------------------------------------
2804 void manualViewBaseContour :: RemoveControlPoints()
2805 {
2806         if (_wxvtkbaseview!=NULL){
2807                 vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
2808                 int i,size=_lstViewPoints.size();
2809                 for (i=0;i<size; i++)
2810                 {
2811                         vtkActor * pointActor = _lstViewPoints[i]->GetVtkActor();
2812                         theRenderer->RemoveActor( pointActor );
2813                 } // for
2814         } // if
2815         SetIfViewControlPoints( false );
2816 }
2817 // ----------------------------------------------------------------------------
2818 void manualViewBaseContour :: AddControlPoints()
2819 {
2820         vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
2821         SetIfViewControlPoints( true );
2822          if( _viewControlPoints )
2823          {
2824                 int i,size=_lstViewPoints.size();
2825                 for (i=0;i<size; i++)
2826                 {
2827                         vtkActor * pointActor = _lstViewPoints[i]->GetVtkActor();
2828                         theRenderer->AddActor( pointActor );
2829                 }
2830          }
2831 }
2832 // ----------------------------------------------------------------------------
2833 void manualViewBaseContour::AddTextActor()
2834 {
2835         _wxvtkbaseview->GetRenderer()->AddActor2D( _textActor );
2836 }
2837 // ----------------------------------------------------------------------------
2838 void manualViewBaseContour::RemoveTextActor()
2839 {
2840         _wxvtkbaseview->GetRenderer()->RemoveActor2D( _textActor );
2841 }
2842 // ----------------------------------------------------------------------------
2843 void manualViewBaseContour::DeleteVtkObjects()
2844 {
2845         if ( _contourVtkActor   != NULL )       { _contourVtkActor  -> Delete(); }
2846         if ( _bboxMapper                != NULL )       { _bboxMapper           -> Delete(); }
2847         if ( _pts                               != NULL )       { _pts                          -> Delete(); }
2848         if ( _pd                                != NULL )       { _pd                           -> Delete(); }
2849         _contourVtkActor        = NULL;
2850         _bboxMapper                     = NULL;
2851         _pts                            = NULL;
2852         _pd                                     = NULL;
2853 }
2854
2855
2856 // ----------------------------------------------------------------------------
2857 void manualViewBaseContour::SetWidthLine(double width)
2858 {
2859         _widthline = width;
2860         this->UpdateColorActor();
2861
2862         // for the control points
2863         int id, size = _lstViewPoints.size();
2864         for( id=0; id<size; id++)
2865         {
2866                 this->_lstViewPoints[id]->SetWidthLine(_widthline);
2867         }
2868
2869 }
2870
2871 // ----------------------------------------------------------------------------
2872 double manualViewBaseContour::GetWidthLine()
2873 {
2874         return _widthline;
2875 }
2876
2877 // ----------------------------------------------------------------------------
2878 void manualViewBaseContour::ConstructVTKObjects()
2879 {
2880 //JSTG 29-02-08 -----------------------------------------------
2881         //int i , nps = _sizePointsContour;
2882         int i;
2883         int nps = _manContModel->GetNumberOfPointsSpline();
2884 printf("EED01 manualViewBaseContour::ConstructVTKObjects nps %d\n ",nps);
2885 //-------------------------------------------------------------
2886         DeleteVtkObjects();
2887         _pts = vtkPoints::New();
2888         _pts->SetNumberOfPoints(nps);
2889
2890         for (i=0 ; i<nps ; i++){
2891                 _pts->SetPoint(i,       0       , 0     , 0 );
2892         }
2893         // This is for the boundaring inicialisation
2894 //EED 29Mars2009
2895         _pts->SetPoint(0,       0       , 0     , -1000 );
2896         _pts->SetPoint(1,       0       , 0     ,  1000 );
2897 //      _pts->SetPoint(0, -1000 , -1000 , -1000 );
2898 //      _pts->SetPoint(1, 1000  , 1000  , 1000  );
2899
2900         vtkCellArray *lines = vtkCellArray::New();
2901         lines->InsertNextCell( nps /* +1 */ );
2902         for ( i=0 ; i<nps+1 ; i++ ){
2903                 lines->InsertCellPoint(i % nps );
2904         }
2905
2906         _pd = vtkPolyData::New();
2907         _pd->SetPoints( _pts );
2908         _pd->SetLines( lines );
2909         lines->Delete();  //do not delete lines ??
2910
2911         _contourVtkActor        =       vtkActor::New();
2912     _bboxMapper                 =       vtkPolyDataMapper::New();
2913     _bboxMapper->ScalarVisibilityOff( );
2914
2915         _bboxMapper->SetInput(_pd);
2916         _bboxMapper->ImmediateModeRenderingOn();
2917         _contourVtkActor->SetMapper(_bboxMapper);
2918         _contourVtkActor->GetProperty()->BackfaceCullingOff();
2919
2920         UpdateColorActor();
2921
2922         _pd->ComputeBounds();
2923
2924         //      Text
2925         _textActor = vtkTextActor::New();
2926 //      _textActor->SetDisplayPosition(200, 200);
2927         _textActor->SetInput("");
2928         // Set coordinates to match the old vtkScaledTextActor default value
2929 //      _textActor->GetPosition2Coordinate()->SetCoordinateSystemToNormalizedViewport();
2930 //      _textActor->GetPosition2Coordinate()->SetValue( 0.2 , 0.2 );
2931         _textActor->GetPositionCoordinate()->SetCoordinateSystemToWorld ();
2932 //      _textActor->GetPositionCoordinate()->SetValue( 0.8 , 0.8 );
2933
2934         vtkTextProperty *tprop = _textActor->GetTextProperty();
2935         tprop->SetFontSize(14);
2936         tprop->SetFontFamilyToArial();
2937         tprop->SetColor(0, 0, 1);
2938 }
2939 // ----------------------------------------------------------------------------
2940 void manualViewBaseContour::CreateNewContour()
2941 {
2942         ConstructVTKObjects();
2943         /*
2944         _wxvtkbaseview->GetRenderer()->AddActor( _contourVtkActor );
2945         _wxvtkbaseview->GetRenderer()->AddActor2D(_textActor);*/
2946         AddCompleteContourActor();
2947 }
2948 // ----------------------------------------------------------------------------
2949 void manualViewBaseContour::UpdateViewPoint(int id) // virtual
2950 {
2951         manualPoint             *mp             = _manContModel->GetManualPoint(id);
2952
2953 //EEDx6
2954                         double XX=mp->GetX(),YY=mp->GetY(),ZZ=mp->GetZ();
2955 //                      wxVtk2DBaseView *wxvtk2Dbasevie = (wxVtk2DBaseView*)this->GetWxVtkBaseView();
2956 //                      wxvtk2Dbasevie->TransformCoordinate_spacing_ModelToView(XX,YY,ZZ);
2957
2958         _lstViewPoints[id]->SetPositionXY( XX , YY ,_range, ZZ );
2959 }
2960
2961 // ----------------------------------------------------------------------------
2962 void manualViewBaseContour :: UpdateViewPoints()
2963 {
2964         int id, size = _lstViewPoints.size();
2965         for( id=0; id<size; id++)
2966         {
2967                 UpdateViewPoint( id );
2968         }
2969 }
2970
2971 // ----------------------------------------------------------------------------
2972 void manualViewBaseContour::AddPoint()
2973 {
2974         manualViewPoint *mvp    = new manualViewPoint( this->GetWxVtkBaseView() );
2975         AddPoint( mvp );
2976 }
2977 // ----------------------------------------------------------------------------
2978 void manualViewBaseContour::AddPoint( manualViewPoint * manualViewPoint )
2979 {
2980         _lstViewPoints.push_back( manualViewPoint );
2981
2982         // EED 3 oct 2006
2983         manualViewPoint->SetSpacing(_spc);
2984
2985         vtkActor *actor = manualViewPoint->CreateVtkPointActor();
2986         _wxvtkbaseview->GetRenderer()->AddActor( actor );
2987 }
2988
2989 // ----------------------------------------------------------------------------
2990 void manualViewBaseContour::InsertPoint(int id)
2991 {
2992         manualViewPoint         *mvp    = new manualViewPoint( this->GetWxVtkBaseView() );
2993
2994 // EED 3 oct 2006
2995         mvp->SetSpacing(_spc);
2996
2997         std::vector<manualViewPoint*>::iterator itNum = _lstViewPoints.begin() + id;
2998         _lstViewPoints.insert(itNum,mvp);
2999         _wxvtkbaseview->GetRenderer()->AddActor( mvp->CreateVtkPointActor() );
3000 }
3001 // ----------------------------------------------------------------------------
3002 void manualViewBaseContour::DeleteContour()
3003 {
3004         RemoveCompleteContourActor();
3005         /*if (_contourVtkActor!=NULL){
3006                 _wxvtkbaseview->GetRenderer()->RemoveActor( _contourVtkActor );
3007         }*/
3008         DeleteVtkObjects();
3009         int i,size=_lstViewPoints.size();
3010         for (i=0;i<size;i++){
3011                 manualViewBaseContour::DeletePoint(0);
3012         }
3013         Refresh();
3014 }
3015 // ----------------------------------------------------------------------------
3016 void manualViewBaseContour::DeletePoint(int id) // virtual
3017 {
3018         int size=_lstViewPoints.size();
3019         if ( (id>=0) && (id<size) ){
3020                 manualViewPoint         *mvp    =_lstViewPoints[id];
3021 //EED ups1
3022 //              _handlePicker->DeletePickList(mvp->GetVtkActor());
3023                 _wxvtkbaseview->GetRenderer()->RemoveActor( mvp->GetVtkActor() );
3024                 std::vector<manualViewPoint*>::iterator itNum = _lstViewPoints.begin() + id;
3025                 _lstViewPoints.erase(itNum);
3026                 delete mvp;
3027                 Refresh();
3028         }
3029 }
3030 // ----------------------------------------------------------------------------
3031 void manualViewBaseContour::DeletePoint(int x, int y, int z)
3032 {
3033         int id=GetIdPoint(x,y,z);
3034         if (id!=-1){
3035                 DeletePoint(id);
3036         }
3037 }
3038 // ----------------------------------------------------------------------------
3039 void manualViewBaseContour::SetSelected(bool selected)
3040 {
3041         _selected=selected;
3042 }
3043 // ----------------------------------------------------------------------------
3044 void manualViewBaseContour::SetPosibleSelected(bool posibleSelected)
3045 {
3046         _posibleSelected=posibleSelected;
3047 }
3048 // ----------------------------------------------------------------------------
3049 bool manualViewBaseContour::GetEditable()
3050 {
3051         return *_editable;
3052 }
3053 // ----------------------------------------------------------------------------
3054 void manualViewBaseContour::SetEditable( bool * condition )
3055 {
3056         _editable = condition;
3057 }
3058 // ----------------------------------------------------------------------------
3059 bool manualViewBaseContour::GetSelected()
3060 {
3061         return _selected;
3062 }
3063 // ----------------------------------------------------------------------------
3064 bool manualViewBaseContour::GetPosibleSelected()
3065 {
3066         return _posibleSelected;
3067 }
3068 // ----------------------------------------------------------------------------
3069 void manualViewBaseContour::DeleteSelectedPoints()
3070 {
3071         int i,size=_lstViewPoints.size();
3072         for (i=size-1;i>=0;i--){
3073                 if (_lstViewPoints[i]->GetSelected()==true){
3074                         DeletePoint(i);
3075                 }
3076         }
3077         Refresh();
3078 }
3079 // ----------------------------------------------------------------------------
3080 void manualViewBaseContour::SelectPoint(int i, bool select)
3081 {
3082         _lstViewPoints[i]->SetSelected(select);
3083 }
3084 // ----------------------------------------------------------------------------
3085 void manualViewBaseContour::SelectLstPoints()
3086 {
3087         // ToDo
3088 }
3089 // ----------------------------------------------------------------------------
3090 void manualViewBaseContour::SelectAllPoints(bool select)
3091 {
3092         int i,size=_lstViewPoints.size();
3093         for (i=0;i<size;i++){
3094                 SelectPoint(i,select);
3095         }
3096 }
3097 //-----------------------------------------------------------------------------
3098 void manualViewBaseContour:: SetIfViewControlPoints(bool ifShow)
3099 {
3100         _viewControlPoints = ifShow;
3101 }
3102 // ----------------------------------------------------------------------------
3103 bool manualViewBaseContour:: GetIfViewControlPoints()
3104 {
3105         return _viewControlPoints;
3106 }
3107
3108 // ----------------------------------------------------------------------------
3109 void manualViewBaseContour::SetPointPosibleSelected(int id,bool select)
3110 {
3111         _lstViewPoints[id]->SetPosibleSelected(select);
3112 }
3113 // ----------------------------------------------------------------------------
3114 void manualViewBaseContour::SetPointSelected(int id,bool select)
3115 {
3116         _lstViewPoints[id]->SetSelected(select);
3117 }
3118 // ----------------------------------------------------------------------------
3119 void manualViewBaseContour::SelectAllPossibleSelected(bool select)
3120 {
3121         int i,size=_lstViewPoints.size();
3122         for (i=0;i<size;i++){
3123                 SetPointPosibleSelected(i,select);
3124         }
3125 }
3126 // ----------------------------------------------------------------------------
3127 int manualViewBaseContour::SelectPosiblePoint(int x, int y, int z)  // virtual
3128 {
3129         SelectAllPossibleSelected(false);
3130
3131     int id = GetIdPoint(x,y,z);
3132         if (id!=-1)
3133         {
3134                 SetPointPosibleSelected(id,true);
3135         }
3136         return id;
3137 }
3138 // ----------------------------------------------------------------------------
3139 bool manualViewBaseContour::SelectPosibleContour(int x, int y, int z)
3140 {
3141         bool result=false;
3142         SetPosibleSelected(result);
3143     int id = GetIdPoint(x,y,z);
3144         if( !GetEditable() && !_selected && id!= -1)
3145         {
3146                 result=true;
3147                 SetPosibleSelected(result);
3148         }
3149         else
3150         {
3151                 if ( (GetEditable()==true) && (id==-1 ) && (this->_lstViewPoints.size()>=2) )
3152                 {
3153                         if (ifTouchContour(x,y,z)==true)
3154                         {
3155                                 result=true;
3156                                 SetPosibleSelected(result);
3157                         }
3158                 }
3159
3160                 if (GetEditable()==false)
3161                 {
3162                         if (ifTouchContour(x,y,z)==true)
3163                         {
3164                                 result=true;
3165                                 SetPosibleSelected(result);
3166                         }
3167                 }
3168
3169
3170         }
3171         return result;
3172 }
3173 // ----------------------------------------------------------------------------
3174 bool manualViewBaseContour::ifTouchContour(int x,int y, int z) // virtual
3175 {
3176         return false;
3177 }
3178 // ----------------------------------------------------------------------------
3179 void manualViewBaseContour::UnSelectPoint(int i){
3180         _lstViewPoints[i]->SetSelected(false);
3181         Refresh();
3182 }
3183 // ----------------------------------------------------------------------------
3184 void manualViewBaseContour::UnSelectLstPoints(){
3185         // ToDo
3186 }
3187 // ----------------------------------------------------------------------------
3188 void manualViewBaseContour::UnSelectAllPoints(){
3189         int i,size=_lstViewPoints.size();
3190         for (i=0;i<size;i++){
3191                 UnSelectPoint(i);
3192         }
3193         Refresh();
3194 }
3195 // ----------------------------------------------------------------------------
3196 void manualViewBaseContour::SetModel(manualContourModel *manContModel){
3197         _manContModel=manContModel;
3198 }
3199 // ----------------------------------------------------------------------------
3200 void manualViewBaseContour::SetWxVtkBaseView(wxVtkBaseView *wxvtkbaseview){
3201         _wxvtkbaseview = wxvtkbaseview;
3202 }
3203 // ----------------------------------------------------------------------------
3204 void manualViewBaseContour::RefreshContour()  // Virtual
3205 {
3206 }
3207 // ----------------------------------------------------------------------------
3208 double* manualViewBaseContour::GetVectorPointsXManualContour(){
3209         double pp[3];
3210         int i,size = _sizePointsContour;
3211         double *vx = (double*)malloc(sizeof(double)*size);
3212         for (i=0;i<size;i++){
3213                 _pts->GetPoint(i,pp);
3214                 vx[i]=pp[0];
3215         }
3216         return vx;
3217 }
3218 // ----------------------------------------------------------------------------
3219 double* manualViewBaseContour::GetVectorPointsYManualContour()
3220 {
3221         double pp[3];
3222         int i,size = _sizePointsContour;
3223         double *vy = (double*)malloc(sizeof(double)*size);
3224         for (i=0;i<size;i++){
3225                 _pts->GetPoint(i,pp);
3226                 vy[i]=pp[1];
3227         }
3228         return vy;
3229 }
3230 // ----------------------------------------------------------------------------
3231 double* manualViewBaseContour::GetVectorPointsZManualContour()
3232 {
3233         double pp[3];
3234         int i,size = _sizePointsContour;
3235         double *vz = (double*)malloc(sizeof(double)*size);
3236         for (i=0;i<size;i++){
3237                 _pts->GetPoint(i,pp);
3238                 vz[i]=pp[2];
3239         }
3240         return vz;
3241 }
3242 // ----------------------------------------------------------------------------
3243 void manualViewBaseContour::Refresh() // virtual
3244 {
3245         if (_contourVtkActor!=NULL){
3246                 RefreshContour();
3247         }
3248         int i,size=_lstViewPoints.size();
3249         for (i=0;i<size;i++){
3250                 UpdateViewPoint(i);
3251                 _lstViewPoints[i]->UpdateColorActor();
3252         }
3253         UpdateColorActor();
3254
3255         if (_show_text==true)
3256         {
3257                 RefreshText();
3258         }
3259
3260         vtkRenderWindowInteractor *vri = _wxvtkbaseview->GetWxVTKRenderWindowInteractor ();
3261         if (vri==NULL)
3262         {
3263                 _wxvtkbaseview->GetRenWin()->Render();
3264         }
3265
3266 }
3267 // ----------------------------------------------------------------------------
3268 void manualViewBaseContour::RefreshText()  // virtual
3269 {
3270         if( _textActor!=NULL)
3271                 _textActor -> SetInput(" ");
3272 }
3273 // ----------------------------------------------------------------------------
3274 void manualViewBaseContour::SetColorNormalContour(double r, double g, double b)
3275 {
3276         _coulorNormal_r = r;
3277         _coulorNormal_g = g;
3278         _coulorNormal_b = b;
3279 }
3280 // ----------------------------------------------------------------------------
3281 void manualViewBaseContour::GetColorNormalContour(double &r, double &g, double &b)
3282 {
3283         r = _coulorNormal_r;
3284         g = _coulorNormal_g;
3285         b = _coulorNormal_b;
3286 }
3287 // ----------------------------------------------------------------------------
3288 void manualViewBaseContour::SetColorEditContour(double r, double g, double b)
3289 {
3290         _coulorEdit_r = r;
3291         _coulorEdit_g = g;
3292         _coulorEdit_b = b;
3293 }
3294 // ----------------------------------------------------------------------------
3295 void manualViewBaseContour::GetColorEditContour(double &r, double &g, double &b)
3296 {
3297         r = _coulorEdit_r;
3298         g = _coulorEdit_g;
3299         b = _coulorEdit_b;
3300 }
3301 // ----------------------------------------------------------------------------
3302 void manualViewBaseContour::SetColorSelectContour(double r, double g, double b)
3303 {
3304         _coulorSelection_r = r;
3305         _coulorSelection_g = g;
3306         _coulorSelection_b = b;
3307 }
3308 // ----------------------------------------------------------------------------
3309 void manualViewBaseContour::GetColorSelectContour(double &r, double &g, double &b)
3310 {
3311         r = _coulorSelection_r;
3312         g = _coulorSelection_g;
3313         b = _coulorSelection_b;
3314 }
3315 // ----------------------------------------------------------------------------
3316 void manualViewBaseContour::UpdateColorActor()
3317 {
3318         if (_contourVtkActor!=NULL)
3319         {
3320                 _contourVtkActor->GetProperty()->SetLineWidth( _widthline );
3321                 _contourVtkActor->GetProperty()->SetDiffuseColor( _coulorNormal_r , _coulorNormal_g , _coulorNormal_b );
3322                 if (_posibleSelected || (_posibleSelected && GetEditable() ) )
3323                 {
3324                         _contourVtkActor->GetProperty()->SetDiffuseColor( _coulorEdit_r , _coulorEdit_g , _coulorEdit_b );
3325                 }
3326                 if( _selected )
3327                 {
3328                         _contourVtkActor->GetProperty()->SetDiffuseColor( _coulorSelection_r , _coulorSelection_g , _coulorSelection_b );
3329                 }
3330         }
3331 }
3332 // ----------------------------------------------------------------------------
3333 int     manualViewBaseContour::GetIdPoint(int x, int y, int z) // virtual
3334 {
3335         int ii = -1;
3336         if (_manContModel!=NULL){
3337                 double xx = x;
3338                 double yy = y;
3339                 double zz = z;
3340                 TransfromeCoordViewWorld(xx,yy,zz);
3341                 ii=_manContModel->GetIdPoint(xx,yy,zz,_range,-1);
3342         }
3343         return ii;
3344 }
3345
3346 // ----------------------------------------------------------------------------
3347
3348
3349 int manualViewBaseContour::GetNumberOfPoints()
3350 {
3351         return _lstViewPoints.size();
3352 }
3353
3354 // ----------------------------------------------------------------------------
3355
3356 //JSTG 25-02-08 ---------------------------------------------------------------
3357 /*int manualViewBaseContour::GetNumberOfPointsSpline()
3358 {
3359         return _sizePointsContour;
3360 }*/
3361 //----------------------------------------------------------------------------
3362
3363 //JSTG 25-02-08 ---------------------------------------------------------------
3364 /*void manualViewBaseContour::SetNumberOfPointsSpline(int size)
3365 {
3366         _sizePointsContour = size;
3367 }*/
3368 //----------------------------------------------------------------------------
3369 // virtual
3370 void manualViewBaseContour::TransfromeCoordViewWorld(double &X, double &Y, double &Z, int type)  // Virtual
3371 {
3372         _wxvtkbaseview->TransfromeCoordScreenToWorld(X, Y, Z, type);
3373
3374
3375 //EED 27 sep 2007
3376 //   //EEDx6
3377 //      wxVtk2DBaseView *wxvtk2Dbaseview = (wxVtk2DBaseView*)_wxvtkbaseview;
3378 //      wxvtk2Dbaseview->TransformCoordinate_spacing_ModelToView(X,Y,Z);
3379
3380 }
3381 // ----------------------------------------------------------------------------
3382 void manualViewBaseContour::SetRange(int range)
3383 {
3384         _range=range;
3385 }
3386 // ----------------------------------------------------------------------------
3387 int     manualViewBaseContour::GetRange()
3388 {
3389         return _range;
3390 }
3391 // ----------------------------------------------------------------------------
3392 void manualViewBaseContour::SetZ(int z)
3393 {
3394 //      _Z=z;
3395 }
3396 // ----------------------------------------------------------------------------
3397 int     manualViewBaseContour::GetZ()
3398 {
3399 //      return _Z;
3400         return 0;
3401 }
3402 // ----------------------------------------------------------------------------
3403 void manualViewBaseContour::InitMove(int x, int y, int z) // virtual
3404 {
3405
3406 }
3407 // ----------------------------------------------------------------------------
3408 void manualViewBaseContour::MoveContour(int x, int y, int z) // virtual
3409 {
3410 }
3411 // ----------------------------------------------------------------------------
3412 void manualViewBaseContour::MoveContour(int horizontalUnits, int verticalUnits )// virtual
3413 {
3414
3415 }
3416 // ----------------------------------------------------------------------------
3417 void manualViewBaseContour::GetMinMax( double &minX,double &minY, double &minZ, double &maxX, double &maxY, double &maxZ )// virtual
3418 {
3419         double  pp[3];
3420         manualPoint *mp;
3421         int i;
3422         int size=_manContModel->GetSizeLstPoints();
3423         minX=99999;
3424         minY=99999;
3425         maxX=-99999;
3426         maxY=-99999;
3427         bool ifFindZ = minZ!=-1.0 && maxZ!=-1.0;
3428         if ( ifFindZ )
3429         {
3430                 minZ=99999;
3431                 maxZ=-99999;
3432         }
3433         for( i = 0; i < size; i++ )
3434         {
3435                 mp=_manContModel->GetManualPoint(i);
3436                 pp[0]=mp->GetX();
3437                 pp[1]=mp->GetY();
3438                 if ( ifFindZ )
3439                         pp[2]=mp->GetZ();
3440
3441                 // min X
3442                 if (pp[0]<minX)
3443                 {
3444                         minX=pp[0];
3445                 }
3446                 //min Y
3447                 if (pp[1]<minY)
3448                 {
3449                         minY=pp[1];
3450                 }
3451                 //max X
3452                 if (pp[0]>maxX)
3453                 {
3454                         maxX=pp[0];
3455                 }
3456                 // max Y
3457                 if (pp[1]>maxY)
3458                 {
3459                         maxY=pp[1];
3460                 }
3461                 if ( ifFindZ )
3462                 {
3463                         // min Z
3464                         if (pp[2]<minZ)
3465                         {
3466                                 minZ=pp[2];
3467                         }
3468                         // max Z
3469                         if (pp[2]>maxZ)
3470                         {
3471                                 maxZ=pp[2];
3472                         }
3473                 }
3474         }
3475         if ( size<1 )
3476         {
3477                 minX = 0;
3478                 maxX = 0;
3479
3480                 minY = 0;
3481                 maxY = 0;
3482
3483                 minZ = 0;
3484                 maxZ = 0;
3485         }
3486 }
3487 // ----------------------------------------------------------------------------
3488 void manualViewBaseContour::ClearContour()
3489 {
3490         if (_contourVtkActor!=NULL){
3491                 _wxvtkbaseview->GetRenderer()->RemoveActor( _contourVtkActor );
3492         }
3493         DeleteVtkObjects();
3494         int i,size=_lstViewPoints.size();
3495         for (i=0;i<size;i++){
3496                 ClearPoint(0);
3497         }
3498         Refresh();
3499 }
3500 // ----------------------------------------------------------------------------
3501 void manualViewBaseContour::ClearPoint(int id)
3502 {
3503         DeletePoint(id);
3504 }
3505 // ----------------------------------------------------------------------------
3506 void manualViewBaseContour::SetVisible(bool ok)
3507 {
3508         double opacity;
3509         if (ok==true)
3510         {
3511                 opacity=1;
3512         } else {
3513                 opacity=0;
3514         }
3515
3516         vtkActor *actor;
3517         int i,size=_lstViewPoints.size();
3518         for (i=0;i<size;i++){
3519                 actor = _lstViewPoints[i]->GetVtkActor();
3520                 actor->GetProperty()->SetOpacity( opacity );
3521         }
3522         _contourVtkActor->GetProperty()->SetOpacity( opacity );
3523         _textActor->GetProperty()->SetOpacity( opacity );
3524         _textActor->SetInput(" ");
3525
3526 }
3527 // ----------------------------------------------------------------------------
3528 void manualViewBaseContour::SetShowText(bool ok)
3529 {
3530         _show_text = ok;
3531         if (_show_text==false)
3532         {
3533                 _textActor->SetInput(" ");
3534         }
3535 }
3536 // ----------------------------------------------------------------------------
3537 wxVtkBaseView *manualViewBaseContour::GetWxVtkBaseView()
3538 {
3539         return this->_wxvtkbaseview;
3540 }
3541 // ----------------------------------------------------------------------------
3542 void manualViewBaseContour::GetSpacing(double spc[3])
3543 {
3544         spc[0] = _spc[0];
3545         spc[1] = _spc[1];
3546         spc[2] = _spc[2];
3547 }
3548 // ----------------------------------------------------------------------------
3549 void manualViewBaseContour::SetSpacing(double spc[3])
3550 {
3551         _spc[0] = spc[0];
3552         _spc[1] = spc[1];
3553         _spc[2] = spc[2];
3554 }
3555
3556
3557 // ----------------------------------------------------------------------------
3558 // ----------------------------------------------------------------------------
3559 // ----------------------------------------------------------------------------
3560
3561 // _type = 0  Sagital
3562 // _type = 1  Coronal
3563 // _type = 2  Axial
3564 // _type = -1 View 3D
3565
3566 manualContour3VControler::manualContour3VControler(int type)
3567 {
3568         _type=type;
3569
3570 //EEDhh
3571 //      _manViewBaseCont1 = NULL;
3572 //      _manViewBaseCont2 = NULL;
3573 //      _manViewBaseCont3 = NULL;
3574 }
3575 //----------------------------------------------------------------------------
3576 manualContour3VControler::~manualContour3VControler()
3577 {
3578 }
3579
3580 // ----------------------------------------------------------------------------
3581 manualContour3VControler * manualContour3VControler :: Clone()  // virtual
3582 {
3583         manualContour3VControler * clone = new manualContour3VControler( this->GetType() );
3584         CopyAttributesTo(clone);
3585         return clone;
3586 }
3587
3588 // ---------------------------------------------------------------------------
3589 void manualContour3VControler::CopyAttributesTo( manualContour3VControler * cloneObject)
3590 {
3591         // Fathers object
3592         manualContourControler::CopyAttributesTo(cloneObject);
3593
3594         cloneObject->SetVtkMPRBaseData( this->GetVtkMPRBaseData() );
3595
3596         // Remember to add ManualViewBaseContour with "AddManualViewBaseContour"
3597
3598 }
3599 // ----------------------------------------------------------------------------
3600 int manualContour3VControler::GetType()
3601 {
3602         return _type;
3603 }
3604
3605 // ----------------------------------------------------------------------------
3606 void manualContour3VControler::AddPoint_Others()
3607 {
3608         manualViewBaseContour *mvbc;
3609         int i,size=this->_lstManualViewBaseContour.size();
3610         for ( i = 0 ; i < size ; i++ )
3611         {
3612                 mvbc = _lstManualViewBaseContour[i];
3613                 mvbc->AddPoint();
3614         }
3615
3616 // EEDhh
3617 //      if (_manViewBaseCont1!=NULL){
3618 //              _manViewBaseCont1->AddPoint();
3619 //              _manViewBaseCont2->AddPoint();
3620 //              _manViewBaseCont3->AddPoint();
3621 //              this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3622 //      }
3623
3624         this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3625 }
3626 // ----------------------------------------------------------------------------
3627 void manualContour3VControler::AddPoint( int x, int y, int z ) // virtual
3628 {
3629
3630         z=(int)_vtkmprbasedata->GetZ();
3631         if (GetManualContourModel()!=NULL){
3632                 double  xx      = x;
3633                 double  yy      = y;
3634                 double  zz      = z;
3635                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz,_type);
3636
3637                 if (_type==0)
3638                 {
3639                         xx=_vtkmprbasedata->GetX();
3640                 }
3641
3642                 if (_type==1)
3643                 {
3644                         yy=_vtkmprbasedata->GetY();
3645                 }
3646
3647
3648                 /*int   id              = */ GetManualContourModel()->AddPoint(xx,yy,zz);  // JPRx
3649                 GetManualViewBaseContour()->AddPoint();
3650                 AddPoint_Others();
3651
3652         }
3653 }
3654
3655 // ----------------------------------------------------------------------------
3656 void manualContour3VControler::InsertPoint_Others(int id)
3657 {
3658
3659         manualViewBaseContour *mvbc;
3660         int i,size=this->_lstManualViewBaseContour.size();
3661         for ( i = 0 ; i < size ; i++ )
3662         {
3663                 mvbc = _lstManualViewBaseContour[i];
3664                 mvbc->InsertPoint(id);
3665         }
3666
3667 /*EEDhh
3668         if (_manViewBaseCont1!=NULL){
3669                 _manViewBaseCont1->InsertPoint(id);
3670                 _manViewBaseCont2->InsertPoint(id);
3671                 _manViewBaseCont3->InsertPoint(id);
3672                 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3673         }
3674 */
3675
3676         this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3677
3678 }
3679 // ----------------------------------------------------------------------------
3680 void manualContour3VControler::InsertPoint(int x, int y, int z)
3681 {
3682         int id=-1;
3683         if (GetManualContourModel()!=NULL){
3684                 if (GetManualContourModel()->GetSizeLstPoints()>1){
3685                         z=(int)_vtkmprbasedata->GetZ();
3686                         double                          xx              = x;
3687                         double                          yy              = y;
3688                         double                          zz              = z;
3689                         GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz,_type);
3690                         if (_type==0)
3691                         {
3692                                 xx=_vtkmprbasedata->GetX();
3693                         }
3694
3695                         if (_type==1)
3696                         {
3697                                 yy=_vtkmprbasedata->GetY();
3698                         }
3699
3700                         id      = GetManualContourModel()->InsertPoint(xx,yy,zz);
3701
3702                         GetManualViewBaseContour()->InsertPoint(id);
3703                         InsertPoint_Others(0);
3704
3705                 } else {
3706                         AddPoint(x,y,z);
3707                 }
3708         }
3709 }
3710 // ----------------------------------------------------------------------------
3711
3712 // EEDhh
3713 /*
3714 void manualContour3VControler::SetModelView (   manualContourModel *manContModel,
3715                                                                                                 manualViewBaseContour *manViewBaseCont0,
3716                                                                                                 manualViewBaseContour *manViewBaseCont1,
3717                                                                                                 manualViewBaseContour *manViewBaseCont2,
3718                                                                                                 manualViewBaseContour *manViewBaseCont3)
3719 {
3720         manualContourControler::SetModelView(manContModel,manViewBaseCont0);
3721         _manViewBaseCont1 = manViewBaseCont1;
3722         _manViewBaseCont2 = manViewBaseCont2;
3723         _manViewBaseCont3 = manViewBaseCont3;
3724 }
3725 */
3726
3727 // ----------------------------------------------------------------------------
3728 void manualContour3VControler::AddManualViewBaseContour( manualViewBaseContour *manViewBaseCont )
3729 {
3730         _lstManualViewBaseContour.push_back( manViewBaseCont );
3731 }
3732
3733 // ----------------------------------------------------------------------------
3734 void manualContour3VControler::SetVtkMPRBaseData (vtkMPRBaseData *vtkmprbasedata )
3735 {
3736         _vtkmprbasedata=vtkmprbasedata;
3737 }
3738 // ----------------------------------------------------------------------------
3739 vtkMPRBaseData *manualContour3VControler::GetVtkMPRBaseData()
3740 {
3741         return _vtkmprbasedata;
3742 }
3743 // ----------------------------------------------------------------------------
3744 void manualContour3VControler::SetPoint( int id ,int x ,int y ,int z ) // virtual
3745 {
3746         z=(int)_vtkmprbasedata->GetZ();
3747         if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
3748                 double xx = x;
3749                 double yy = y;
3750                 double zz = z;
3751                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz,_type);
3752
3753                 if (_type==0)
3754                 {
3755                         xx=_vtkmprbasedata->GetX();
3756                 }
3757                 if (_type==1)
3758                 {
3759                         yy=_vtkmprbasedata->GetY();
3760                 }
3761
3762                 manualPoint     *mp     = GetManualContourModel()->GetManualPoint(id);
3763                 mp->SetPoint(xx,yy,zz);
3764
3765         }
3766 }
3767 // ----------------------------------------------------------------------------
3768 void manualContour3VControler::DeleteActualMousePoint_Others(int id)
3769 {
3770         manualViewBaseContour *mvbc;
3771         int i,size=this->_lstManualViewBaseContour.size();
3772         for ( i = 0 ; i < size ; i++ )
3773         {
3774                 mvbc = _lstManualViewBaseContour[i];
3775                 mvbc->DeletePoint(id);
3776                 mvbc->Refresh();
3777         }
3778
3779 /*
3780         if (_manViewBaseCont1!=NULL){
3781                 _manViewBaseCont1->DeletePoint(id);
3782                 _manViewBaseCont2->DeletePoint(id);
3783                 _manViewBaseCont3->DeletePoint(id);
3784
3785                 _manViewBaseCont1->Refresh();
3786                 _manViewBaseCont2->Refresh();
3787                 _manViewBaseCont3->Refresh();
3788
3789                 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3790         }
3791 */
3792         this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3793 }
3794 // ----------------------------------------------------------------------------
3795 void manualContour3VControler::DeleteActualMousePoint(int x, int y)// virtual
3796 {
3797         int id=GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
3798         if (id!=-1){
3799                 manualContourBaseControler::DeleteActualMousePoint( x , y );
3800                 DeleteActualMousePoint_Others( id );
3801         }
3802 }
3803 // ----------------------------------------------------------------------------
3804 void manualContour3VControler::MouseMove_Others(int id) // virtual
3805 {
3806         manualViewBaseContour *mvbc;
3807         int i,size=this->_lstManualViewBaseContour.size();
3808         for ( i = 0 ; i < size ; i++ )
3809         {
3810                 mvbc = _lstManualViewBaseContour[i];
3811                 mvbc->SelectAllPossibleSelected(false);
3812                 if (id!=-1)
3813                 {
3814                         mvbc->SetPointPosibleSelected(id,true);
3815                 }
3816                 mvbc->SetPosibleSelected  (  GetManualViewBaseContour()->GetPosibleSelected()  );
3817                 mvbc->Refresh();
3818         }
3819
3820 // EEDhh
3821 /*
3822         if (_manViewBaseCont1!=NULL){
3823                 _manViewBaseCont1->SelectAllPossibleSelected(false);
3824                 _manViewBaseCont2->SelectAllPossibleSelected(false);
3825                 _manViewBaseCont3->SelectAllPossibleSelected(false);
3826                 if (id!=-1){
3827                         _manViewBaseCont1->SetPointPosibleSelected(id,true);
3828                         _manViewBaseCont2->SetPointPosibleSelected(id,true);
3829                         _manViewBaseCont3->SetPointPosibleSelected(id,true);
3830                 }
3831                 _manViewBaseCont1->SetPosibleSelected  (  GetManualViewBaseContour()->GetPosibleSelected()  );
3832                 _manViewBaseCont2->SetPosibleSelected  (  GetManualViewBaseContour()->GetPosibleSelected()  );
3833                 _manViewBaseCont3->SetPosibleSelected  (  GetManualViewBaseContour()->GetPosibleSelected()  );
3834
3835                 _manViewBaseCont1->Refresh();
3836                 _manViewBaseCont2->Refresh();
3837                 _manViewBaseCont3->Refresh();
3838
3839                 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3840         }
3841 */
3842         this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3843
3844 }
3845
3846 // ----------------------------------------------------------------------------
3847 void manualContour3VControler::MouseMove(int x, int y) // virtual
3848 {
3849         manualContourControler::MouseMove( x , y );
3850         int id=GetManualViewBaseContour()->GetIdPoint(x,y,GetZ());
3851         MouseMove_Others( id );
3852 }
3853
3854 // ----------------------------------------------------------------------------
3855 void manualContour3VControler::OnChar_Others()
3856 {
3857         manualViewBaseContour *mvbc;
3858         int i,size=this->_lstManualViewBaseContour.size();
3859         for ( i = 0 ; i < size ; i++ )
3860         {
3861                 mvbc = _lstManualViewBaseContour[i];
3862                 mvbc->Refresh();
3863         }
3864 // EEDhh
3865 /*
3866                 _manViewBaseCont1->Refresh();
3867                 _manViewBaseCont2->Refresh();
3868                 _manViewBaseCont3->Refresh();
3869 */
3870         this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3871 }
3872 // ----------------------------------------------------------------------------
3873 bool manualContour3VControler::OnChar()
3874 {
3875         manualContourControler::OnChar();
3876         OnChar_Others();
3877         return true;
3878 }
3879 // ----------------------------------------------------------------------------
3880 void manualContour3VControler::ResetContour() // virtual
3881 {
3882         manualContourControler::ResetContour();
3883         ResetContour_Others();
3884 }
3885
3886 // ----------------------------------------------------------------------------
3887 void manualContour3VControler::ResetContour_Others()
3888 {
3889         manualViewBaseContour *mvbc;
3890         int i,size=this->_lstManualViewBaseContour.size();
3891         for ( i = 0 ; i < size ; i++ )
3892         {
3893                 mvbc = _lstManualViewBaseContour[i];
3894                 mvbc->DeleteContour();
3895                 mvbc->CreateNewContour();
3896         }
3897
3898 // EEDhh
3899 /*
3900         _manViewBaseCont1->DeleteContour();
3901         _manViewBaseCont2->DeleteContour();
3902         _manViewBaseCont3->DeleteContour();
3903         _manViewBaseCont1->CreateNewContour();
3904         _manViewBaseCont2->CreateNewContour();
3905         _manViewBaseCont3->CreateNewContour();
3906 */
3907 }
3908
3909 // ----------------------------------------------------------------------------
3910 // ----------------------------------------------------------------------------
3911 // ----------------------------------------------------------------------------
3912 manualContour3DControler::manualContour3DControler()
3913 {
3914 }
3915 // ----------------------------------------------------------------------------
3916 manualContour3DControler::~manualContour3DControler()
3917 {
3918 }
3919 // ----------------------------------------------------------------------------
3920 manualContour3DControler * manualContour3DControler :: Clone()  // virtual
3921 {
3922         manualContour3DControler * clone = new manualContour3DControler();
3923         CopyAttributesTo(clone);
3924         return clone;
3925 }
3926
3927 // ---------------------------------------------------------------------------
3928 void manualContour3DControler::CopyAttributesTo( manualContour3DControler * cloneObject)
3929 {
3930         // Fathers object
3931         manualContourControler::CopyAttributesTo(cloneObject);
3932
3933         cloneObject->SetVtkMPRBaseData( this->GetVtkMPRBaseData() );
3934 }
3935
3936 // ----------------------------------------------------------------------------
3937 bool  manualContour3DControler::OnLeftButtonDown()
3938 {
3939         int X,Y;
3940         wxVTKRenderWindowInteractor *wxVTKiren;
3941         wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
3942         wxVTKiren->GetEventPosition(X,Y);
3943         MouseClickLeft(X,Y);
3944         return true;
3945 }
3946 // ----------------------------------------------------------------------------
3947 void manualContour3DControler::ResetOrientationPlane()
3948 {
3949         double p[3],rp[3],rn[3];
3950         p[0] = this->GetVtkMPRBaseData()->GetX(  );
3951         p[1] = this->GetVtkMPRBaseData()->GetY(  );
3952         p[2] = this->GetVtkMPRBaseData()->GetZ(  );
3953         this->GetManualContourModel()->GetNearestPointAndNormal(p,rp,rn);
3954         this->GetVtkMPRBaseData()->SetNormal(rn[0],rn[1],rn[2]);
3955 }
3956 // ----------------------------------------------------------------------------
3957 void manualContour3DControler::MouseClickLeft(int x, int y) // virtual
3958 {
3959         manualView3DContour *manualview3Dcontour=(manualView3DContour*)GetManualViewBaseContour();
3960         int id=manualview3Dcontour->GetIdPoint2(x,y);
3961         if ( (GetState()==0) && (id!=-1) )
3962         {
3963                 manualPoint *mp = this->GetManualContourModel()->GetManualPoint(id);
3964
3965                 this->GetVtkMPRBaseData()->SetX( mp->GetX() );
3966                 this->GetVtkMPRBaseData()->SetY( mp->GetY() );
3967                 this->GetVtkMPRBaseData()->SetZ( mp->GetZ() );
3968                 ResetOrientationPlane();
3969                 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3970         }
3971
3972
3973         manualContourControler::MouseClickLeft(x,y);
3974
3975 }
3976 // ----------------------------------------------------------------------------
3977 bool manualContour3DControler::OnChar()
3978 {
3979         bool ok=true;
3980         manualContourControler::OnChar();
3981         char keyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
3982         if (keyCode==32){
3983                 ok=false;
3984                 ResetOrientationPlane();
3985                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
3986         }
3987         return ok;
3988 }
3989
3990 // ----------------------------------------------------------------------------
3991 void manualContour3DControler::SetVtkMPRBaseData (vtkMPRBaseData *vtkmprbasedata )
3992 {
3993         _vtkmprbasedata=vtkmprbasedata;
3994 }
3995 // ----------------------------------------------------------------------------
3996 vtkMPRBaseData *manualContour3DControler::GetVtkMPRBaseData()
3997 {
3998         return _vtkmprbasedata;
3999 }
4000
4001 // ----------------------------------------------------------------------------
4002 void manualContour3DControler::InsertPoint(int x, int y, int z ) // virtual
4003 {
4004         manualContourControler::InsertPoint(  x,  y,  z );
4005         ResetOrientationPlane();
4006 }
4007
4008
4009
4010 // ----------------------------------------------------------------------------
4011 // ----------------------------------------------------------------------------
4012 // ----------------------------------------------------------------------------
4013
4014 manualContour3V3DControler::manualContour3V3DControler()
4015 {
4016 }
4017 // ----------------------------------------------------------------------------
4018 manualContour3V3DControler::~manualContour3V3DControler()
4019 {
4020 }
4021
4022 // ----------------------------------------------------------------------------
4023 manualContour3V3DControler * manualContour3V3DControler :: Clone()  // virtual
4024 {
4025         manualContour3V3DControler * clone = new manualContour3V3DControler();
4026         CopyAttributesTo(clone);
4027         return clone;
4028 }
4029
4030 // ---------------------------------------------------------------------------
4031 void manualContour3V3DControler::CopyAttributesTo( manualContour3V3DControler * cloneObject)
4032 {
4033         // Fathers object
4034         manualContour3DControler::CopyAttributesTo(cloneObject);
4035
4036         cloneObject->SetManualContour3VControler( this->GetManualContour3VControler() );
4037 }
4038 // ----------------------------------------------------------------------------
4039 void manualContour3V3DControler::InsertPoint(int x, int y, int z ) // virtual
4040 {
4041         manualContour3DControler::InsertPoint(  x,  y,  z );
4042         _manualcontour3Vcontroler->InsertPoint_Others(0);
4043 }
4044 // ----------------------------------------------------------------------------
4045 void manualContour3V3DControler::AddPoint( int x, int y, int z )
4046 {
4047         manualContour3DControler::AddPoint(  x,  y,  z );
4048         _manualcontour3Vcontroler->AddPoint_Others();
4049 }
4050 // ----------------------------------------------------------------------------
4051 void manualContour3V3DControler::DeleteActualMousePoint(int x, int y)
4052 {
4053         int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
4054         manualContour3DControler::DeleteActualMousePoint( x , y );
4055         _manualcontour3Vcontroler->DeleteActualMousePoint_Others(id);
4056 }
4057 // ----------------------------------------------------------------------------
4058 void manualContour3V3DControler::MouseMove( int x, int y )
4059 {
4060         int ss =this->_vtkInteractorStyleBaseView->vtkInteractorStyle::GetState();
4061         if ((this->GetState()!=7) && (ss!=1)){
4062                 manualContour3DControler::MouseMove( x , y );
4063                 int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
4064                 _manualcontour3Vcontroler->MouseMove_Others(id);
4065         }
4066 }
4067 // ----------------------------------------------------------------------------
4068 void manualContour3V3DControler::SetManualContour3VControler(manualContour3VControler *manualcontour3Vcontroler)
4069 {
4070         _manualcontour3Vcontroler = manualcontour3Vcontroler;
4071 }
4072 // ----------------------------------------------------------------------------
4073 manualContour3VControler *manualContour3V3DControler::GetManualContour3VControler()
4074 {
4075         return _manualcontour3Vcontroler;
4076 }
4077 // ----------------------------------------------------------------------------
4078 bool manualContour3V3DControler::OnChar() // virtual
4079 {
4080         if (manualContour3DControler::OnChar()==false )
4081         {
4082                 _manualcontour3Vcontroler->OnChar_Others();
4083         }
4084         return true;
4085 }
4086
4087 // ----------------------------------------------------------------------------
4088 void manualContour3V3DControler::ResetContour() // virtual
4089 {
4090         manualContourControler::ResetContour();
4091         _manualcontour3Vcontroler->ResetContour_Others();
4092 }
4093
4094
4095 // ----------------------------------------------------------------------------
4096 // ----------------------------------------------------------------------------
4097 // ----------------------------------------------------------------------------
4098
4099 // _state = 0  // ..nothing..
4100 // _state = 1  // move with add point
4101 // _state = 5  // move
4102 // _state = 6  // move with insert point
4103 // _state = 7  // move with non selection
4104
4105 manualContourControler::manualContourControler()
4106 {
4107         _easyCreation = true;
4108
4109 }
4110 // ----------------------------------------------------------------------------
4111 manualContourControler::~manualContourControler()
4112 {
4113 }
4114 // ----------------------------------------------------------------------------
4115 manualContourControler * manualContourControler :: Clone()  // virtual
4116 {
4117         manualContourControler * clone = new manualContourControler();
4118         CopyAttributesTo(clone);
4119         return clone;
4120 }
4121 // ---------------------------------------------------------------------------
4122 void manualContourControler::CopyAttributesTo( manualContourControler * cloneObject)
4123 {
4124         // Fathers object
4125         manualContourBaseControler::CopyAttributesTo(cloneObject);
4126         cloneObject->SetEasyCreation( this->GetEasyCreation() );
4127 }
4128
4129 // ----------------------------------------------------------------------------
4130 void manualContourControler::Configure() //virtual
4131 {
4132  //     this->_manContModel->SetNumberOfPointsSpline(100);
4133 }
4134
4135 // ----------------------------------------------------------------------------
4136 void manualContourControler::MouseClickLeft(int x, int y){
4137
4138
4139         bool ok = false;
4140         int z   = GetZ();
4141         int size= GetManualViewBaseContour()->GetNumberOfPoints();
4142
4143         // Insert a Control Point with shift+ClickLeft
4144         // int tt = GetState();  // JPRx
4145         vtkRenderWindowInteractor *vtkrenderwindowinteractor = _vtkInteractorStyleBaseView->GetInteractor();
4146 //EED3131
4147         if( IsEditable() )
4148         {
4149                 if ( (_vtkInteractorStyleBaseView!=NULL) && (GetState()==0) && ( (vtkrenderwindowinteractor!=NULL) && (vtkrenderwindowinteractor->GetShiftKey()==1) ) )
4150                 {
4151                         ok=true;
4152                         InsertPoint(x,y,z);
4153                         size++;
4154                 }
4155                 // Start to Insert Control Points with ClickLeft (Empty contour)
4156                 if ((GetState()==0) && (size==0) && (_easyCreation==true) )
4157                 {
4158                         ok=true;
4159                         SetState(1);
4160                         AddPoint(x,y,z);
4161                 }
4162                 // Continuie to Insert Control Points with ClickLeft (After being empty the contour)
4163                 if ((GetState()==1) && (_easyCreation==true) )
4164                 {
4165                         ok=true;
4166                         AddPoint(x,y,z);
4167                         _bakIdPoint=GetNumberOfPointsManualContour() - 1;
4168                 }
4169                 // Insert Control Points IF Contour si Selected
4170                 if ((GetState()==0) && GetManualViewBaseContour()->GetPosibleSelected() )
4171                 {
4172                         ok=true;
4173                         InsertPoint(x,y,z);
4174                         _bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4175                         SetState(6);
4176                 }
4177                 // Chose id of Control Point to be move
4178                 if ( (GetState()==0 || GetState()==6) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) )
4179                 {
4180                         ok=true;
4181                         _bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4182                         SetState(5);
4183                 }
4184                 // If nothing selected _state=7
4185                 if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)==-1 ) )
4186                 {
4187                         //ok=true;
4188                         _bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4189                         SetState(7);
4190                 }
4191         }
4192         else
4193         {
4194                 SetPosibleToMove( true );
4195                 GetManualViewBaseContour()->SetSelected( GetManualViewBaseContour()->GetPosibleSelected() );
4196         }
4197         if ( GetState() == 0 && GetManualViewBaseContour()->GetPosibleSelected() )
4198         {
4199                 SetMoving( true );
4200                 ok=true;
4201                 GetManualViewBaseContour()->InitMove(x,y,z);
4202                 SetState(6);
4203         }
4204         if (ok==true)
4205         {
4206                 GetManualViewBaseContour()->Refresh();
4207         }
4208 }
4209 // ----------------------------------------------------------------------------
4210 void manualContourControler::MouseMove(int x, int y) // virtual
4211 {
4212         int z=GetZ();
4213         GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
4214         GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
4215         if (GetState()==1){     SetPoint( _bakIdPoint , x , y ,z); }
4216         if (GetState()==5){     SetPoint( _bakIdPoint , x , y ,z); }
4217         if ( GetState()==6 && !IsEditable() && GetPosibleToMove() &&IsMoving() )
4218         {
4219                 GetManualViewBaseContour()->MoveContour(x,y,z);
4220         }
4221         if (GetState()!=7 || GetManualViewBaseContour()->GetPosibleSelected() ){
4222                 GetManualViewBaseContour()->Refresh();
4223                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4224         }
4225         if (!IsEditable())
4226         {
4227                 GetManualViewBaseContour()->RemoveControlPoints();
4228                 GetManualViewBaseContour()->RemoveTextActor();
4229                 GetManualViewBaseContour()->Refresh();
4230                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4231         }
4232
4233 }
4234
4235 // ----------------------------------------------------------------------------
4236 void manualContourControler::MouseDLeft( int x, int y)//virtual
4237 {
4238         manualContourBaseControler::MouseDLeft( x, y);
4239         if ( IsEditable() )
4240         {
4241                 GetManualViewBaseContour()->AddControlPoints();
4242                 GetManualViewBaseContour()->AddTextActor();
4243                 GetManualViewBaseContour()->Refresh();
4244                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4245         }
4246 }
4247 // ----------------------------------------------------------------------------
4248 void manualContourControler::SetEasyCreation(bool easyCreation)
4249 {
4250         _easyCreation=easyCreation;
4251 }
4252 // ----------------------------------------------------------------------------
4253 bool manualContourControler::GetEasyCreation()
4254 {
4255         return _easyCreation;
4256 }
4257
4258
4259 // ----------------------------------------------------------------------------
4260 // ----------------------------------------------------------------------------
4261 // ----------------------------------------------------------------------------
4262 manualContourPerpPlaneControler::manualContourPerpPlaneControler()
4263 {
4264         _flagMouseMove = true;
4265 }
4266 // ----------------------------------------------------------------------------
4267 manualContourPerpPlaneControler::~manualContourPerpPlaneControler()
4268 {
4269 }
4270 // ----------------------------------------------------------------------------
4271 manualContourPerpPlaneControler * manualContourPerpPlaneControler :: Clone()  // virtual
4272 {
4273         manualContourPerpPlaneControler * clone = new manualContourPerpPlaneControler();
4274         CopyAttributesTo(clone);
4275         return clone;
4276 }
4277
4278 // ---------------------------------------------------------------------------
4279 void manualContourPerpPlaneControler::CopyAttributesTo( manualContourPerpPlaneControler * cloneObject)
4280 {
4281         // Fathers object
4282         manualContourControler::CopyAttributesTo(cloneObject);
4283
4284         cloneObject->SetVtkMPRBaseData( this->GetVtkMPRBaseData() );
4285         cloneObject->SetManualContour3VControler( this->GetManualContour3VControler() );
4286         cloneObject->SetVtkInteractorStylePlane2D( this->GetVtkInteractorStylePlane2D() );
4287 }
4288
4289 // ----------------------------------------------------------------------------
4290 void manualContourPerpPlaneControler::SetVtkMPRBaseData(vtkMPRBaseData *vtkmprbasedata)
4291 {
4292         _vtkmprbasedata = vtkmprbasedata;
4293 }
4294
4295 // ----------------------------------------------------------------------------
4296 vtkMPRBaseData *manualContourPerpPlaneControler::GetVtkMPRBaseData()
4297 {
4298         return _vtkmprbasedata;
4299 }
4300
4301
4302 // ----------------------------------------------------------------------------
4303 void manualContourPerpPlaneControler::InsertPoint(int x, int y, int z ) // virtual
4304 {
4305         manualContourControler::InsertPoint(  x,  y,  z );
4306         _manualcontour3Vcontroler->InsertPoint_Others(0);
4307 }
4308 // ----------------------------------------------------------------------------
4309 void manualContourPerpPlaneControler::AddPoint( int x, int y, int z )
4310 {
4311         manualContourControler::AddPoint(  x,  y,  z );
4312         _manualcontour3Vcontroler->AddPoint_Others();
4313 }
4314 // ----------------------------------------------------------------------------
4315 void manualContourPerpPlaneControler::DeleteActualMousePoint(int x, int y)
4316 {
4317         int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
4318         manualContourControler::DeleteActualMousePoint( x , y );
4319         _manualcontour3Vcontroler->DeleteActualMousePoint_Others(id);
4320 }
4321 // ----------------------------------------------------------------------------
4322 void manualContourPerpPlaneControler::MouseMove( int x, int y )
4323 {
4324         _flagMouseMove = true;
4325         int ss =this->_vtkInteractorStyleBaseView->vtkInteractorStyle::GetState();
4326         if ((this->GetState()!=7) && (ss!=1)){
4327                 manualContourControler::MouseMove( x , y );
4328                 int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
4329                 if (id!=-1)
4330                 {
4331                         _manualcontour3Vcontroler->MouseMove_Others(id);
4332                         _flagMouseMove = false;
4333                 }
4334         }
4335 }
4336 // ----------------------------------------------------------------------------
4337 void manualContourPerpPlaneControler::SetManualContour3VControler(manualContour3VControler *manualcontour3Vcontroler)
4338 {
4339         _manualcontour3Vcontroler = manualcontour3Vcontroler;
4340 }
4341 // ----------------------------------------------------------------------------
4342 manualContour3VControler * manualContourPerpPlaneControler::GetManualContour3VControler()
4343 {
4344         return _manualcontour3Vcontroler;
4345 }
4346 // ----------------------------------------------------------------------------
4347 bool manualContourPerpPlaneControler::OnChar() // virtual
4348 {
4349         if (manualContourControler::OnChar()==false )
4350         {
4351                 _manualcontour3Vcontroler->OnChar_Others();
4352         }
4353         return true;
4354 }
4355 // ----------------------------------------------------------------------------
4356 bool manualContourPerpPlaneControler::OnMouseMove() //  virtual
4357 {
4358         manualContourControler::OnMouseMove();
4359         return _flagMouseMove;
4360 }
4361 // ----------------------------------------------------------------------------
4362 bool manualContourPerpPlaneControler::OnLeftDClick() //         virtual
4363 {
4364         manualContourControler::OnLeftDClick();
4365         return _flagMouseDClick;
4366 }
4367 // ----------------------------------------------------------------------------
4368 void manualContourPerpPlaneControler::ResetContour() // virtual
4369 {
4370         manualContourControler::ResetContour();
4371         _manualcontour3Vcontroler->ResetContour_Others();
4372 }
4373
4374 // ----------------------------------------------------------------------------
4375 void manualContourPerpPlaneControler::MouseDLeft( int x, int y) // virtual
4376 {
4377         _flagMouseDClick=true;
4378         manualContourControler::MouseDLeft(x,y);
4379
4380         if (GetManualViewBaseContour()->ifTouchContour(x,y,0)==true)
4381         {
4382                 _flagMouseDClick = false;
4383                 _vtkinteractorstyleplane2D->OnLeftDClick();
4384                 ResetOrientationPlane();
4385                 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
4386         }
4387
4388 //      int id=GetManualViewBaseContour()->GetIdPoint(x,y,GetZ());
4389 //              if ( (GetState()==0) && (id!=-1) )
4390 //      {
4391 //              manualPoint *mp = this->GetManualContourModel()->GetManualPoint(id);
4392 //              _vtkmprbasedata->SetX( mp->GetX() );
4393 //              _vtkmprbasedata->SetY( mp->GetY() );
4394 //              _vtkmprbasedata->SetZ( mp->GetZ() );
4395 //              ResetOrientationPlane();
4396 //              this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
4397 //      }
4398 }
4399
4400
4401
4402 // ----------------------------------------------------------------------------
4403 void manualContourPerpPlaneControler::ResetOrientationPlane()
4404 {
4405         double p[3],rp[3],rn[3];
4406         p[0] = _vtkmprbasedata->GetX(  );
4407         p[1] = _vtkmprbasedata->GetY(  );
4408         p[2] = _vtkmprbasedata->GetZ(  );
4409         this->GetManualContourModel()->GetNearestPointAndNormal(p,rp,rn);
4410
4411         _vtkmprbasedata->SetNormal(rn[0],rn[1],rn[2]);
4412 }
4413
4414 // ----------------------------------------------------------------------------
4415 void manualContourPerpPlaneControler::SetVtkInteractorStylePlane2D(InteractorStyleMaracas *vtkinteractorstyleplane2D)
4416 {
4417         _vtkinteractorstyleplane2D = vtkinteractorstyleplane2D;
4418 }
4419 // ----------------------------------------------------------------------------
4420 InteractorStyleMaracas * manualContourPerpPlaneControler::GetVtkInteractorStylePlane2D()
4421 {
4422         return _vtkinteractorstyleplane2D;
4423 }
4424
4425 // ----------------------------------------------------------------------------
4426 // ----------------------------------------------------------------------------
4427 // ----------------------------------------------------------------------------
4428
4429 // _state = 0  // ..nothing..
4430 // _state = 5  // move point
4431 // _state = 6  // move all
4432 // _state = 7  // Empty mouse drag
4433
4434 manualRoiControler::manualRoiControler()
4435 {
4436 }
4437 // ----------------------------------------------------------------------------
4438 manualRoiControler::~manualRoiControler()
4439 {
4440 }
4441 // ----------------------------------------------------------------------------
4442 manualRoiControler * manualRoiControler :: Clone()  // virtual
4443 {
4444         manualRoiControler * clone = new manualRoiControler();
4445         CopyAttributesTo(clone);
4446         return clone;
4447 }
4448
4449 // ---------------------------------------------------------------------------
4450 void manualRoiControler::CopyAttributesTo( manualRoiControler * cloneObject)
4451 {
4452         // Fathers object
4453         manualContourBaseControler::CopyAttributesTo(cloneObject);
4454 }
4455
4456 // ----------------------------------------------------------------------------
4457 void manualRoiControler::Configure() //virtual
4458 {
4459         this->GetManualContourModel()->SetNumberOfPointsSpline(5);
4460 }
4461
4462 // ----------------------------------------------------------------------------
4463 void manualRoiControler::MouseClickLeft(int x, int y){
4464         int z = GetZ();
4465         if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) ){
4466                 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4467                 SetState(5);
4468         }
4469         if ((GetState()==0) && (GetManualViewBaseContour()->GetPosibleSelected()==true))        {
4470                 GetManualViewBaseContour()->InitMove(x,y,z);
4471                 SetState(6);
4472         }
4473         int size=GetManualViewBaseContour()->GetNumberOfPoints();
4474         if (GetState()==0) {
4475                 if (size==0){
4476                         AddPoint(x,y,z);
4477                         AddPoint(x,y,z);
4478                         AddPoint(x,y,z);
4479                         AddPoint(x,y,z);
4480                 } else {
4481                         SetPoint(0,x,y,z);
4482                         SetPoint(1,x,y,z);
4483                         SetPoint(2,x,y,z);
4484                         SetPoint(3,x,y,z);
4485                 }
4486                 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4487                 SetState(5);
4488         }
4489         GetManualViewBaseContour()->Refresh();
4490 }
4491 // ----------------------------------------------------------------------------
4492 void manualRoiControler::MouseMove(int x, int y) // virtual
4493 {
4494         int z=GetZ();
4495
4496 //      this->_vtkInteractorStyleBaseView->
4497
4498         GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
4499         GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
4500
4501         if (GetState()==5){
4502                 SetPoint( bakIdPoint , x , y ,z);
4503                 if (bakIdPoint==0)
4504                 {
4505                         SetPointX( 1 , x );
4506                         SetPointY( 3 , y );
4507                 }
4508                 if (bakIdPoint==1)
4509                 {
4510                         SetPointX( 0 , x );
4511                         SetPointY( 2 , y );
4512                 }
4513                 if (bakIdPoint==2)
4514                 {
4515                         SetPointX( 3 , x );
4516                         SetPointY( 1 , y );
4517                 }
4518                 if (bakIdPoint==3)
4519                 {
4520                         SetPointX( 2 , x );
4521                         SetPointY( 0 , y );
4522                 }
4523         }
4524         if (GetState()==6){
4525                 GetManualViewBaseContour()->MoveContour(x,y,z);
4526         }
4527         GetManualViewBaseContour()->Refresh();
4528 }
4529 // ----------------------------------------------------------------------------
4530 void manualRoiControler::DeleteActualMousePoint(int x, int y)  // virtual
4531 {
4532 }
4533 // ----------------------------------------------------------------------------
4534 void manualRoiControler::InitRoi(int ww, int hh, double porcentage)
4535 {
4536         int zz;
4537         manualPoint *mp;
4538
4539         if (GetManualContourModel()->GetSizeLstPoints() ==0)
4540         {
4541                 zz = GetZ();
4542                 AddPoint(0,0,zz);
4543                 AddPoint(0,0,zz);
4544                 AddPoint(0,0,zz);
4545                 AddPoint(0,0,zz);
4546         }
4547
4548         double pp1=porcentage;
4549         double pp2=1-porcentage;
4550
4551         mp = GetManualContourModel()->GetManualPoint(2);
4552         zz=(int)mp->GetZ();
4553         mp->SetPoint(ww*pp1,hh*pp1,zz);
4554
4555         mp = GetManualContourModel()->GetManualPoint(1);
4556         zz=(int)mp->GetZ();
4557         mp->SetPoint(ww*pp2,hh*pp1,zz);
4558
4559         mp = GetManualContourModel()->GetManualPoint(0);
4560         zz=(int)mp->GetZ();
4561         mp->SetPoint(ww*pp2,hh*pp2,zz);
4562
4563         mp = GetManualContourModel()->GetManualPoint(3);
4564         zz=(int)mp->GetZ();
4565         mp->SetPoint(ww*pp1,hh*pp2,zz);
4566
4567         GetManualViewBaseContour() ->UpdateViewPoint(0);
4568         GetManualViewBaseContour() ->UpdateViewPoint(1);
4569         GetManualViewBaseContour() ->UpdateViewPoint(2);
4570         GetManualViewBaseContour() ->UpdateViewPoint(3);
4571
4572         SetState(0);
4573         GetManualViewBaseContour()->Refresh();
4574 }
4575
4576 // ----------------------------------------------------------------------------
4577 void manualRoiControler::SetRoi(int x1, int y1,int x2, int y2)
4578 {
4579         manualPoint *mp;
4580         InitRoi( 0 , 0 , 0.2 );
4581         mp = GetManualContourModel()->GetManualPoint(2);
4582         mp->SetPointX(x1);
4583         mp->SetPointY(y1);
4584
4585         mp = GetManualContourModel()->GetManualPoint(1);
4586         mp->SetPointX(x2);
4587         mp->SetPointY(y1);
4588
4589         mp = GetManualContourModel()->GetManualPoint(0);
4590         mp->SetPointX(x2);
4591         mp->SetPointY(y2);
4592
4593         mp = GetManualContourModel()->GetManualPoint(3);
4594         mp->SetPointX(x1);
4595         mp->SetPointY(y2);
4596
4597         GetManualViewBaseContour() ->UpdateViewPoint(0);
4598         GetManualViewBaseContour() ->UpdateViewPoint(1);
4599         GetManualViewBaseContour() ->UpdateViewPoint(2);
4600         GetManualViewBaseContour() ->UpdateViewPoint(3);
4601 }
4602
4603
4604 // ----------------------------------------------------------------------------
4605 // ----------------------------------------------------------------------------
4606 // ----------------------------------------------------------------------------
4607
4608 // EED08
4609
4610 // _state = 0  // ..nothing..
4611 // _state = 5  // move point
4612 // _state = 6  // move all
4613 // _state = 7  // Empty mouse drag
4614
4615 manualCircleControler::manualCircleControler()
4616 {
4617 }
4618 // ----------------------------------------------------------------------------
4619 manualCircleControler::~manualCircleControler()
4620 {
4621 }
4622 // ----------------------------------------------------------------------------
4623 manualCircleControler * manualCircleControler :: Clone()  // virtual
4624 {
4625         manualCircleControler * clone = new manualCircleControler();
4626         CopyAttributesTo(clone);
4627         return clone;
4628 }
4629
4630 // ---------------------------------------------------------------------------
4631 void manualCircleControler::CopyAttributesTo( manualCircleControler * cloneObject)
4632 {
4633         // Fathers object
4634         manualContourBaseControler::CopyAttributesTo(cloneObject);
4635 }
4636
4637 // ----------------------------------------------------------------------------
4638 void manualCircleControler::Configure() //virtual
4639 {
4640 //      this->GetManualContourModel()->SetNumberOfPointsSpline(5);
4641 }
4642
4643 // ----------------------------------------------------------------------------
4644 void manualCircleControler::MouseClickLeft(int x, int y){
4645         int z = GetZ();
4646         if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) ){
4647                 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4648                 SetState(5);
4649         }
4650         if ((GetState()==0) && (GetManualViewBaseContour()->GetPosibleSelected()==true))        {
4651                 GetManualViewBaseContour()->InitMove(x,y,z);
4652                 SetState(6);
4653         }
4654         int size=GetManualViewBaseContour()->GetNumberOfPoints();
4655         if (GetState()==0) {
4656                 if (size==0){
4657                         AddPoint(x,y,z);
4658                         AddPoint(x,y,z);
4659 //                      AddPoint(x,y,z);
4660 //                      AddPoint(x,y,z);
4661                 } else {
4662                         SetPoint(0,x,y,z);
4663                         SetPoint(1,x,y,z);
4664 //                      SetPoint(2,x,y,z);
4665 //                      SetPoint(3,x,y,z);
4666                 }
4667                 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4668                 SetState(5);
4669         }
4670         GetManualViewBaseContour()->Refresh();
4671 }
4672 // ----------------------------------------------------------------------------
4673
4674 void manualCircleControler::MouseMove(int x, int y) // virtual
4675 {
4676         int z=GetZ();
4677
4678 //      this->_vtkInteractorStyleBaseView->
4679
4680         GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
4681         GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
4682
4683         if (GetState()==5){
4684                 SetPoint( bakIdPoint , x , y ,z);
4685 /*
4686                 if (bakIdPoint==0)
4687                 {
4688                         SetPointX( 1 , x );
4689                         SetPointY( 3 , y );
4690                 }
4691                 if (bakIdPoint==1)
4692                 {
4693                         SetPointX( 0 , x );
4694                         SetPointY( 2 , y );
4695                 }
4696
4697                 if (bakIdPoint==2)
4698                 {
4699                         SetPointX( 3 , x );
4700                         SetPointY( 1 , y );
4701                 }
4702                 if (bakIdPoint==3)
4703                 {
4704                         SetPointX( 2 , x );
4705                         SetPointY( 0 , y );
4706                 }
4707 */
4708         }
4709         if (GetState()==6){
4710                 GetManualViewBaseContour()->MoveContour(x,y,z);
4711         }
4712         GetManualViewBaseContour()->Refresh();
4713 }
4714
4715
4716 // ----------------------------------------------------------------------------
4717 void manualCircleControler::DeleteActualMousePoint(int x, int y)  // virtual
4718 {
4719 }
4720 // ----------------------------------------------------------------------------
4721
4722 void manualCircleControler::InitRoi(int ww, int hh, double porcentage)
4723 {
4724         int zz;
4725         manualPoint *mp;
4726
4727         if (GetManualContourModel()->GetSizeLstPoints() ==0)
4728         {
4729                 zz = GetZ();
4730                 AddPoint(0,0,zz);
4731                 AddPoint(0,0,zz);
4732 //              AddPoint(0,0,zz);
4733 //              AddPoint(0,0,zz);
4734         }
4735
4736         double pp1=porcentage;
4737         double pp2=1-porcentage;
4738
4739 //      mp = GetManualContourModel()->GetManualPoint(2);
4740 //      zz=(int)mp->GetZ();
4741 //      mp->SetPoint(ww*pp1,hh*pp1,zz);
4742
4743         mp = GetManualContourModel()->GetManualPoint(1);
4744         zz=(int)mp->GetZ();
4745         mp->SetPoint(ww*pp2,hh*pp1,zz);
4746
4747         mp = GetManualContourModel()->GetManualPoint(0);
4748         zz=(int)mp->GetZ();
4749         mp->SetPoint(ww*pp2,hh*pp2,zz);
4750
4751 //      mp = GetManualContourModel()->GetManualPoint(3);
4752 //      zz=(int)mp->GetZ();
4753 //      mp->SetPoint(ww*pp1,hh*pp2,zz);
4754
4755         GetManualViewBaseContour() ->UpdateViewPoint(0);
4756         GetManualViewBaseContour() ->UpdateViewPoint(1);
4757 //      GetManualViewBaseContour() ->UpdateViewPoint(2);
4758 //      GetManualViewBaseContour() ->UpdateViewPoint(3);
4759
4760         SetState(0);
4761         GetManualViewBaseContour()->Refresh();
4762 }
4763
4764 // ----------------------------------------------------------------------------
4765 /*
4766 void manualCircleControler::SetRoi(int x1, int y1,int x2, int y2)
4767 {
4768         manualPoint *mp;
4769         InitRoi( 0 , 0 , 0.2 );
4770         mp = GetManualContourModel()->GetManualPoint(2);
4771         mp->SetPointX(x1);
4772         mp->SetPointY(y1);
4773
4774         mp = GetManualContourModel()->GetManualPoint(1);
4775         mp->SetPointX(x2);
4776         mp->SetPointY(y1);
4777
4778         mp = GetManualContourModel()->GetManualPoint(0);
4779         mp->SetPointX(x2);
4780         mp->SetPointY(y2);
4781
4782         mp = GetManualContourModel()->GetManualPoint(3);
4783         mp->SetPointX(x1);
4784         mp->SetPointY(y2);
4785
4786         GetManualViewBaseContour() ->UpdateViewPoint(0);
4787         GetManualViewBaseContour() ->UpdateViewPoint(1);
4788         GetManualViewBaseContour() ->UpdateViewPoint(2);
4789         GetManualViewBaseContour() ->UpdateViewPoint(3);
4790 }
4791 */
4792
4793
4794 // ----------------------------------------------------------------------------
4795 // ----------------------------------------------------------------------------
4796 // ----------------------------------------------------------------------------
4797
4798 // AD:02-09
4799
4800 // _state = 0  // ..nothing..
4801 // _state = 5  // move point
4802 // _state = 6  // move all
4803 // _state = 7  // Empty mouse drag
4804
4805 manualLineControler::manualLineControler()
4806 {
4807 }
4808 // ----------------------------------------------------------------------------
4809 manualLineControler::~manualLineControler()
4810 {
4811 }
4812 // ----------------------------------------------------------------------------
4813 manualLineControler * manualLineControler :: Clone()  // virtual
4814 {
4815         manualLineControler * clone = new manualLineControler();
4816         CopyAttributesTo(clone);
4817         return clone;
4818 }
4819
4820 // ---------------------------------------------------------------------------
4821 void manualLineControler::CopyAttributesTo( manualLineControler * cloneObject)
4822 {
4823         // Fathers object
4824         manualContourBaseControler::CopyAttributesTo(cloneObject);
4825 }
4826
4827 // ----------------------------------------------------------------------------
4828 void manualLineControler::MouseClickLeft(int x, int y){
4829         int z = GetZ();
4830         if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) ){
4831                 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4832                 SetState(5);
4833         }
4834         if ((GetState()==0) && (GetManualViewBaseContour()->GetPosibleSelected()==true))        {
4835                 GetManualViewBaseContour()->InitMove(x,y,z);
4836                 SetState(6);
4837         }
4838         int size=GetManualViewBaseContour()->GetNumberOfPoints();
4839         if (GetState()==0) {
4840                 if (size==0){
4841                         AddPoint(x,y,z);
4842                         AddPoint(x,y,z);
4843                 } else {
4844                         SetPoint(0,x,y,z);
4845                         SetPoint(1,x,y,z);
4846                 }
4847                 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4848                 SetState(5);
4849         }
4850         GetManualViewBaseContour()->Refresh();
4851 }
4852 // ----------------------------------------------------------------------------
4853
4854 void manualLineControler::MouseMove(int x, int y) // virtual
4855 {
4856         int z=GetZ();
4857
4858         GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
4859         GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
4860
4861         if (GetState()==5)
4862         {
4863                 SetPoint( bakIdPoint , x , y ,z);
4864         }
4865         if (GetState()==6)
4866         {
4867                 GetManualViewBaseContour()->MoveContour(x,y,z);
4868         }
4869         GetManualViewBaseContour()->Refresh();
4870 }
4871
4872
4873 // ----------------------------------------------------------------------------
4874 void manualLineControler::DeleteActualMousePoint(int x, int y)  // virtual
4875 {
4876 }
4877 // ----------------------------------------------------------------------------
4878
4879 void manualLineControler::InitRoi(int ww, int hh, double porcentage)
4880 {
4881         int zz;
4882         manualPoint *mp;
4883
4884         if (GetManualContourModel()->GetSizeLstPoints() ==0)
4885         {
4886                 zz = GetZ();
4887                 AddPoint(0,0,zz);
4888                 AddPoint(0,0,zz);
4889         }
4890
4891         double pp1=porcentage;
4892         double pp2=1-porcentage;
4893
4894         mp = GetManualContourModel()->GetManualPoint(0);
4895         zz=(int)mp->GetZ();
4896         mp->SetPoint(ww*pp2,hh*pp2,zz);
4897
4898         mp = GetManualContourModel()->GetManualPoint(1);
4899         zz=(int)mp->GetZ();
4900         mp->SetPoint(ww*pp2,hh*pp1,zz);
4901
4902         GetManualViewBaseContour() ->UpdateViewPoint(0);
4903         GetManualViewBaseContour() ->UpdateViewPoint(1);
4904
4905         SetState(0);
4906         GetManualViewBaseContour()->Refresh();
4907 }
4908
4909 // ----------------------------------------------------------------------------
4910 // ----------------------------------------------------------------------------
4911 // ----------------------------------------------------------------------------
4912
4913
4914 manualContourBaseControler::manualContourBaseControler()
4915 {
4916         _manViewBaseCont        = NULL;
4917         _manContModel           = NULL;
4918         _state                          = 0;
4919         _z                                      = -900;
4920         _editable                       = true;
4921         _posibleToMove          = true;
4922         _moving                         = false;
4923         _created                        = false;
4924         _keyBoardMoving         = false;
4925 }
4926 // ----------------------------------------------------------------------------
4927 manualContourBaseControler::~manualContourBaseControler()
4928 {
4929 }
4930
4931 // ----------------------------------------------------------------------------
4932 manualContourBaseControler * manualContourBaseControler :: Clone()  // virtual
4933 {
4934         manualContourBaseControler * clone = new manualContourBaseControler();
4935         CopyAttributesTo(clone);
4936         return clone;
4937 }
4938
4939 // ---------------------------------------------------------------------------
4940
4941 void manualContourBaseControler::CopyAttributesTo( manualContourBaseControler * cloneObject)
4942 {
4943         // Fathers object
4944         InteractorStyleMaracas::CopyAttributesTo(cloneObject);
4945         cloneObject->SetZ( this->GetZ() );
4946         cloneObject->SetState( this->GetState() );
4947         cloneObject->SetEditable( this->IsEditable() );
4948         cloneObject->SetPosibleToMove( this->GetPosibleToMove() );
4949         cloneObject->SetMoving( this->IsMoving() );
4950         cloneObject->SetCompleteCreation( this->GetIfCompleteCreation() );
4951         cloneObject->SetKeyBoardMoving( this->GetKeyBoardMoving() );
4952 }
4953
4954 // ----------------------------------------------------------------------------
4955 void manualContourBaseControler::Configure() //virtual
4956 {
4957 }
4958
4959 // ----------------------------------------------------------------------------
4960 bool manualContourBaseControler::OnChar()
4961 {
4962         if ( _vtkInteractorStyleBaseView!=NULL )
4963         {
4964                 char keyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
4965
4966                 int X,Y;
4967                 wxVTKRenderWindowInteractor *_wxVTKiren;
4968                 _wxVTKiren= _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
4969                 _wxVTKiren->GetEventPosition(X, Y);
4970                 //int Z = GetZ(); // JPRx
4971                 // Delete Point
4972                 if ((keyCode==8) || (keyCode==127))
4973                 {
4974
4975                         if (!GetManualViewBaseContour()->GetPosibleSelected()==true)
4976                         {
4977                                 DeleteActualMousePoint(X,Y);
4978                         }
4979                         GetManualViewBaseContour()->Refresh();
4980                         this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4981                 }
4982                 else
4983                 {
4984                         // Magnet
4985                         if (keyCode==32)
4986                         {
4987                                 Magnet(X,Y);
4988                                 GetManualViewBaseContour()->Refresh();
4989                                 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4990                         }
4991                         else if( !IsEditable() )
4992                         {
4993                                 if ( keyCode == 'L' )
4994                                 {
4995                                         GetManualViewBaseContour()->MoveContour( -1, 0 );
4996                                         SetKeyBoardMoving( true );
4997                                 }
4998                                 else if ( keyCode == 'R' )
4999                                 {
5000                                         GetManualViewBaseContour()->MoveContour( 1, 0 );
5001                                         SetKeyBoardMoving( true );
5002                                 }
5003                                 else if ( keyCode == 'U' )
5004                                 {
5005                                         GetManualViewBaseContour()->MoveContour( 0, -1 );
5006                                         SetKeyBoardMoving( true );
5007                                 }
5008                                 else if ( keyCode == 'D' )
5009                                 {
5010                                         GetManualViewBaseContour()->MoveContour( 0, 1 );
5011                                         SetKeyBoardMoving( true );
5012                                 }
5013                                 else if ( keyCode == 'W' )//Diagonal left down
5014                                 {
5015                                         GetManualViewBaseContour()->MoveContour( -1, 1 );
5016                                         SetKeyBoardMoving( true );
5017                                 }
5018                                 else if ( keyCode == 'Q' )//Diagonal left up
5019                                 {
5020                                         GetManualViewBaseContour()->MoveContour( -1, -1 );
5021                                         SetKeyBoardMoving( true );
5022                                 }
5023                                 else if( keyCode == 'P' )//Diagonal right up
5024                                 {
5025                                         GetManualViewBaseContour()->MoveContour( 1, -1 );
5026                                         SetKeyBoardMoving( true );
5027                                 }
5028                                 else if( keyCode == 'M' )//Diagonal right down
5029                                 {
5030                                         GetManualViewBaseContour()->MoveContour( 1, 1 );
5031                                         SetKeyBoardMoving( true );
5032                                 }
5033                                 if( GetKeyBoardMoving() )
5034                                 {
5035                                         GetManualViewBaseContour()->Refresh();
5036                                         this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
5037                                 }
5038                         }
5039                 }
5040         }
5041         return true;
5042 }
5043 // ----------------------------------------------------------------------------
5044 bool manualContourBaseControler::OnMouseMove()
5045 {
5046         if ( _vtkInteractorStyleBaseView!=NULL)
5047         {
5048                 int X,Y;
5049                 wxVTKRenderWindowInteractor *_wxVTKiren;
5050                 _wxVTKiren= _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5051                 _wxVTKiren->GetEventPosition( X , Y );
5052
5053
5054                 if ( (_vtkInteractorStyleBaseView->GetInteractor()->GetControlKey()==0) &&
5055                         (_vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey()==0) ) {
5056                         MouseMove(X,Y);
5057                 }
5058         }
5059         return true;
5060 }
5061 // ----------------------------------------------------------------------------
5062 bool manualContourBaseControler::OnLeftButtonDown()
5063 {
5064         SetKeyBoardMoving( false );
5065         if ( _vtkInteractorStyleBaseView!=NULL )
5066         {
5067                 int X,Y;
5068                 wxVTKRenderWindowInteractor *wxVTKiren;
5069                 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5070                 wxVTKiren->GetEventPosition(X,Y);
5071
5072                 MouseClickLeft(X,Y);
5073         }
5074         return true;
5075 }
5076 // ----------------------------------------------------------------------------
5077 bool manualContourBaseControler::OnLeftButtonUp()
5078 {
5079         if ( _vtkInteractorStyleBaseView!=NULL )
5080         {
5081                 int X,Y;
5082                 wxVTKRenderWindowInteractor *wxVTKiren;
5083                 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5084                 wxVTKiren->GetEventPosition(X,Y);
5085                 MouseReleaseLeft(X,Y);
5086         }
5087         return true;
5088 }
5089 // ----------------------------------------------------------------------------
5090 bool manualContourBaseControler::OnLeftDClick()
5091 {
5092         if ( _vtkInteractorStyleBaseView!=NULL )
5093         {
5094                 int X,Y;
5095                 wxVTKRenderWindowInteractor *wxVTKiren;
5096                 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5097                 wxVTKiren->GetEventPosition(X,Y);
5098
5099                 this->MouseDLeft(X,Y);
5100         }
5101         return true;
5102 }
5103 // ----------------------------------------------------------------------------
5104 bool manualContourBaseControler::OnMiddleButtonDown()
5105 {
5106 //      SetKeyBoardMoving( false );
5107         if ( _vtkInteractorStyleBaseView!=NULL )
5108         {
5109                 int X,Y;
5110                 wxVTKRenderWindowInteractor *wxVTKiren;
5111                 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5112                 wxVTKiren->GetEventPosition(X,Y);
5113                 GetManualViewBaseContour()->InitMove( X, Y,GetZ());
5114         }
5115         return true;
5116 }
5117 // ----------------------------------------------------------------------------
5118 bool manualContourBaseControler::OnMiddleButtonUp()
5119 {
5120         return true;
5121 }
5122 // ----------------------------------------------------------------------------
5123 bool manualContourBaseControler::OnRightButtonDown()
5124 {
5125         if( _vtkInteractorStyleBaseView!= NULL )
5126         {
5127                 int X,Y;
5128                 wxVTKRenderWindowInteractor *wxVTKiren;
5129                 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5130                 wxVTKiren->GetEventPosition(X, Y);
5131
5132                 SetCompleteCreation( true );
5133                 SetKeyBoardMoving( false );
5134                 MouseClickRight(X,Y);
5135         }
5136         return true;
5137 }
5138 // ----------------------------------------------------------------------------
5139 bool manualContourBaseControler::OnRightButtonUp()
5140 {
5141         return true;
5142 }
5143 // ----------------------------------------------------------------------------
5144 void manualContourBaseControler::SetModelView(manualContourModel *manContModel, manualViewBaseContour *manViewBaseCont){
5145         _manContModel           =       manContModel;
5146         _manViewBaseCont        =       manViewBaseCont;
5147         _manViewBaseCont->SetEditable( &_editable );
5148 }
5149 // ----------------------------------------------------------------------------
5150 manualContourModel* manualContourBaseControler::GetManualContourModel()
5151 {
5152         return _manContModel;
5153 }
5154 // ----------------------------------------------------------------------------
5155 manualViewBaseContour* manualContourBaseControler::GetManualViewBaseContour()
5156 {
5157         return _manViewBaseCont;
5158 }
5159 // ----------------------------------------------------------------------------
5160 void manualContourBaseControler::MouseClickLeft(int x, int y) // virtual
5161 {
5162
5163 }
5164 // ----------------------------------------------------------------------------
5165 void manualContourBaseControler::MouseClickRight(int x, int y)
5166 {
5167         if (_state==1)
5168         {
5169                 _state=0;
5170         }
5171         SetEditable( false );
5172         SetPosibleToMove( false );
5173         //_state = 0;
5174         _state=7;
5175 }
5176 // ----------------------------------------------------------------------------
5177 void manualContourBaseControler::MouseReleaseLeft(int x, int y)
5178 {
5179         if (_state==5){ _state = 0; }
5180         if (_state==6){ _state = 0; }
5181         if (_state==7){ _state = 0; }
5182         SetMoving( false );
5183         GetManualViewBaseContour()->SelectPosibleContour(x,y,GetZ());
5184         if( GetIfCompleteCreation() && IsEditable() && !GetManualViewBaseContour()->GetPosibleSelected() && (GetManualViewBaseContour()->GetIdPoint(x,y,GetZ())==-1)  )
5185         {
5186                 SetEditable( false );
5187                 SetPosibleToMove( false );
5188         }
5189 }
5190 // ----------------------------------------------------------------------------
5191 void manualContourBaseControler::MouseDLeft(int x, int y )
5192 {
5193         if (_state==0)
5194         {
5195                 int z=GetZ();
5196                 GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
5197                 GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
5198                 if ( GetManualViewBaseContour()->GetPosibleSelected() )
5199                 {
5200                         _editable = true;
5201                 }
5202         }
5203 }
5204 // ----------------------------------------------------------------------------
5205 void manualContourBaseControler::MouseMove(int x, int y) // virtual
5206 {
5207 }
5208 // ----------------------------------------------------------------------------
5209 void manualContourBaseControler::SetState(int state)
5210 {
5211         _state=state;
5212 }
5213 // ----------------------------------------------------------------------------
5214 int manualContourBaseControler::GetState()
5215 {
5216         return _state;
5217 }
5218 // ----------------------------------------------------------------------------
5219 bool manualContourBaseControler::IsEditable( )
5220 {
5221         return _editable;
5222 }
5223 // ----------------------------------------------------------------------------
5224 void manualContourBaseControler::SetEditable(  bool condition  )
5225 {
5226         if (GetManualViewBaseContour()!=NULL) {
5227                 if( !condition )
5228                 {
5229                         GetManualViewBaseContour()->RemoveControlPoints();
5230                 }
5231                 GetManualViewBaseContour()->SetSelected( condition );
5232         }
5233         _editable = condition;
5234 }
5235
5236 // ----------------------------------------------------------------------------
5237 bool manualContourBaseControler::GetPosibleToMove()
5238 {
5239         return _posibleToMove;
5240 }
5241 // ----------------------------------------------------------------------------
5242 void manualContourBaseControler::SetPosibleToMove( bool condition )
5243 {
5244         _posibleToMove = condition;
5245 }
5246 // ----------------------------------------------------------------------------
5247 bool manualContourBaseControler::IsMoving()
5248 {
5249         return _moving;
5250 }
5251 // ----------------------------------------------------------------------------
5252 void manualContourBaseControler::SetMoving( bool condition )
5253 {
5254         _moving = condition;
5255 }
5256 // ----------------------------------------------------------------------------
5257 void manualContourBaseControler::SetCompleteCreation( bool condition )
5258 {
5259         _created = condition;
5260 }
5261 // ----------------------------------------------------------------------------
5262 bool manualContourBaseControler::GetIfCompleteCreation ( )
5263 {
5264         return _created;
5265 }
5266 // ----------------------------------------------------------------------------
5267 void manualContourBaseControler::SetKeyBoardMoving( bool condition )
5268 {
5269         _keyBoardMoving = condition;
5270 }
5271 // ----------------------------------------------------------------------------
5272 bool manualContourBaseControler::GetKeyBoardMoving(  )
5273 {
5274         return _keyBoardMoving;
5275 }
5276 // ----------------------------------------------------------------------------
5277 void manualContourBaseControler::CreateNewManualContour(){
5278         _manViewBaseCont->CreateNewContour();
5279 }
5280 // ----------------------------------------------------------------------------
5281 int     manualContourBaseControler::GetNumberOfPointsManualContour(){
5282         return _manViewBaseCont->GetNumberOfPoints();
5283 }
5284 // ----------------------------------------------------------------------------
5285
5286 //JSTG - 25-02-08 -------------------------------------------------------------
5287 int     manualContourBaseControler::GetNumberOfPointsSplineManualContour(){
5288         //return _manViewBaseCont->GetNumberOfPointsSpline();
5289         return _manContModel->GetNumberOfPointsSpline();
5290 }
5291 // ----------------------------------------------------------------------------
5292
5293 double* manualContourBaseControler::GetVectorPointsXManualContour(){
5294         return _manViewBaseCont->GetVectorPointsXManualContour();
5295 }
5296 // ----------------------------------------------------------------------------
5297 double* manualContourBaseControler::GetVectorPointsYManualContour(){
5298         return _manViewBaseCont->GetVectorPointsYManualContour();
5299 }
5300 // ----------------------------------------------------------------------------
5301 void manualContourBaseControler::DeleteContour(){
5302         _manViewBaseCont->DeleteContour();
5303         _manContModel->DeleteAllPoints();
5304 }
5305 // ----------------------------------------------------------------------------
5306 void manualContourBaseControler::DeleteActualMousePoint(int x, int y)// virtual
5307 {
5308         if ((_manContModel!=NULL) && (_manViewBaseCont!=NULL) )
5309         {
5310                 int id=_manViewBaseCont->GetIdPoint(x,y,GetZ());
5311                 if ((id!=-1) && (_manContModel->GetSizeLstPoints()>2) ){
5312                         _manContModel->DeletePoint(id);
5313                         _manViewBaseCont->DeletePoint(id);
5314                 }
5315         }
5316         _state = 0;
5317 }
5318
5319 // ----------------------------------------------------------------------------
5320 void manualContourBaseControler::Magnet(int x, int y)
5321 {
5322         if( IsEditable())
5323         {
5324                 /*int id= */ _manViewBaseCont->GetIdPoint(x,y,GetZ()); // JPRx
5325                 if (GetManualContourModel()!=NULL){
5326                         double  xx      = x;
5327                         double  yy      = y;
5328                         double  zz      = GetZ();
5329                         GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5330                         int                     id      = GetManualContourModel()->GetIdPoint(xx,yy,zz,32000,-1);
5331                         if (id!=-1)
5332                         {
5333                                 manualPoint     *mp     = GetManualContourModel()->GetManualPoint(id);
5334                                 mp->SetPoint(xx,yy,zz);
5335                         }
5336         //              GetManualViewBaseContour()->UpdateViewPoint(id);
5337                 }
5338                 _state = 0;
5339         }
5340 }
5341
5342 // ----------------------------------------------------------------------------
5343 void manualContourBaseControler::SetZ(int z)
5344 {
5345         _z=z;
5346 }
5347 // ----------------------------------------------------------------------------
5348 int manualContourBaseControler::GetZ()
5349 {
5350         return _z;
5351 }
5352 // ----------------------------------------------------------------------------
5353 void manualContourBaseControler::AddPoint(int x, int y, int z) // virtual
5354 {
5355         if (GetManualContourModel()!=NULL){
5356                 double  xx      = x;
5357                 double  yy      = y;
5358                 double  zz      = z;
5359                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5360                 /*int   id              =*/  GetManualContourModel()->AddPoint(xx,yy,zz);  // JPRx
5361                 GetManualViewBaseContour()->AddPoint();
5362 //              GetManualViewBaseContour()->UpdateViewPoint(id);
5363         }
5364 }
5365 // ----------------------------------------------------------------------------
5366 void manualContourBaseControler::InsertPoint(int x,int y,int z)  // virtual
5367 {
5368 //EEDzz
5369         int id=-1;
5370         if (GetManualContourModel()!=NULL){
5371                 double                          xx              = x;
5372                 double                          yy              = y;
5373                 double                          zz              = z;
5374                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5375                 if (GetManualContourModel()->GetSizeLstPoints()>1){
5376                         id = GetManualContourModel()->InsertPoint(xx,yy,zz);
5377                         GetManualViewBaseContour()->InsertPoint(id);
5378 //                      GetManualViewBaseContour()->UpdateViewPoint(id);
5379                 } else {
5380                         GetManualContourModel()->AddPoint(xx,yy,zz);
5381                         GetManualViewBaseContour()->AddPoint();
5382 //                      AddPoint(x,y,z);
5383 //                      GetManualViewBaseContour()->UpdateViewPoint(id);
5384                 }
5385         }
5386 }
5387
5388 // ----------------------------------------------------------------------------
5389 void manualContourBaseControler::SetPoint( int id ,int x , int y , int z){ // virtual
5390         if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
5391                 double xx = x;
5392                 double yy = y;
5393                 double zz = z;
5394                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5395                 manualPoint             *mp             = _manContModel->GetManualPoint(id);
5396                 mp->SetPoint(xx,yy,zz);
5397                 GetManualViewBaseContour()->UpdateViewPoint(id);
5398         }
5399 }
5400 // ----------------------------------------------------------------------------
5401 void manualContourBaseControler::SetPointX( int id ,int x  ){
5402         if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
5403                 double xx = x;
5404                 double yy = 0;
5405                 double zz = 0;
5406                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5407                 manualPoint             *mp             = _manContModel->GetManualPoint(id);
5408                 mp->SetPointX(xx);
5409                 GetManualViewBaseContour()->UpdateViewPoint(id);
5410         }
5411 }
5412 // ----------------------------------------------------------------------------
5413 void manualContourBaseControler::SetPointY( int id ,int y  ){
5414         if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
5415                 double xx = 0;
5416                 double yy = y;
5417                 double zz = 0;
5418                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5419                 manualPoint             *mp             = _manContModel->GetManualPoint(id);
5420                 mp->SetPointY(yy);
5421                 GetManualViewBaseContour()->UpdateViewPoint(id);
5422         }
5423 }
5424 // ----------------------------------------------------------------------------
5425 void manualContourBaseControler::SetPointZ( int id ,int z  ){
5426         if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
5427                 double xx = 0;
5428                 double yy = 0;
5429                 double zz = z;
5430                 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5431                 manualPoint             *mp             = _manContModel->GetManualPoint(id);
5432                 mp->SetPointZ(zz);
5433                 GetManualViewBaseContour()->UpdateViewPoint(id);
5434         }
5435 }
5436 // ----------------------------------------------------------------------------
5437 void manualContourBaseControler::ResetContour() // virtual
5438 {
5439         this->DeleteContour();
5440         GetManualViewBaseContour()->CreateNewContour();
5441         this->SetState(0);
5442 }
5443