lib/maracasVisuLib/src/interface/wxWindows/widgets/wxMPRWidget.cxx

   1 /*=========================================================================
   2
   3   Program:   wxMaracas
   4   Module:    $RCSfile: wxMPRWidget.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2009/04/20 09:03:30 $
   7   Version:   $Revision: 1.9 $
   8
   9   Copyright: (c) 2002, 2003
  10   License:
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notice for more information.
  15
  16 =========================================================================*/
  17
  18
  19 #include <vtkObjectFactory.h>
  20 #include <vtkInteractorStyleSwitch.h>
  21 #include <vtkCamera.h>
  22 #include <vtkImageActor.h>
  23 #include <vtkRenderer.h>
  24 #include <vtkRenderWindowInteractor.h>
  25 #include <vtkRenderWindow.h>
  26
  27 #include <vtkRenderer.h>
  28 #include <vtkImageViewer2.h>
  29 #include <vtkInteractorStyleImage.h>
  30
  31 #include <vtkProperty.h>
  32 #include <vtkPolyData.h>
  33 #include <vtkDataSet.h>
  34 #include <vtkStripper.h>
  35 #include <vtkCellArray.h>
  36 #include <vtkPointData.h>
  37 #include <vtkInteractorStyleTrackballCamera.h>
  38
  39 #include <vtkPlanes.h>
  40 #include <vtkProbeFilter.h>
  41 #include <vtkPlane.h>
  42 #include <vtkPointPicker.h>
  43
  44
  45 #include "vtkClosePolyData.h"
  46 #include <vtkTriangleFilter.h>
  47 #include <vtkSTLWriter.h>
  48 #include <vtkPolyDataConnectivityFilter.h>
  49
  50 // EED 25 Janvier 2007  -  TestLoic
  51 #include <vtkCutter.h>
  52 #include <vtkWindowLevelLookupTable.h>
  53 #include <vtkLookupTable.h>
  54 #include <vtkMetaImageWriter.h>
  55
  56
  57
  58 #include "wxMPRWidget.h"
  59 #include "wxVTKRenderWindowInteractor.h"
  60 #include "UtilVtk3DGeometriSelection.h"
  61 #include "../kernel/marDicomBase.h"
  62
  63
  64 #include <wx/wx.h>
  65 #include <wx/notebook.h>
  66 #include <wx/colordlg.h>
  67
  68 #include "matrix.h"
  69 #include <string>
  70
  71
  72 #include "pPlotter/HistogramDialog.h"
  73
  74 //-------------------------------------------------------------------
  75 //-------------------------------------------------------------------
  76 //-------------------------------------------------------------------
  77
  78 idAlBeRa::idAlBeRa(int id, double radio,int deltavoxel)
  79 {
  80         _id                     = id;
  81         _radio          = radio;
  82         _deltavoxel = deltavoxel;
  83 }
  84
  85
  86 //-------------------------------------------------------------------
  87 //-------------------------------------------------------------------
  88 //-------------------------------------------------------------------
  89
  90 vtkInteractorStyleSphere::vtkInteractorStyleSphere()
  91 {
  92         _stateRadio  = false;
  93         _stateRotate = false;
  94 }
  95
  96 //---------------------------------------------------------------------------
  97
  98 vtkInteractorStyleSphere::~vtkInteractorStyleSphere()
  99 {
 100 }
 101
 102
 103 //---------------------------------------------------------------------------
 104
 105 bool  vtkInteractorStyleSphere::OnRightButtonDown()
 106 {
 107         if ((_vtkInteractorStyleBaseView->GetInteractor()->GetControlKey()==0) && (_vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey()==0) )
 108         {
 109                 _stateRadio     = true;
 110                 //_fordwareX    = this->Interactor->GetEventPosition()[0];
 111                 _fordwareY      = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
 112
 113                 wxSphereView *wxsphereview = (wxSphereView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
 114
 115                 _radio = wxsphereview->GetRadio();
 116         }
 117
 118         return true;
 119 }
 120
 121 //---------------------------------------------------------------------------
 122
 123 bool  vtkInteractorStyleSphere::OnRightButtonUp()
 124 {
 125         if (_stateRadio==true)
 126         {
 127                 wxSphereView *wxsphereview = (wxSphereView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
 128                 wxsphereview->SetDeltaVoxel(1);
 129                 double radio=wxsphereview->GetRadio();
 130                 wxsphereview->GetIdOfImage(radio+0.1);
 131                 wxsphereview->GetIdOfImage(radio+0.2);
 132                 wxsphereview->GetIdOfImage(radio-0.1);
 133                 wxsphereview->GetIdOfImage(radio-0.2);
 134
 135                 wxsphereview->RefreshView();
 136                 _stateRadio = false;
 137         }
 138
 139         return true;
 140 }
 141 //---------------------------------------------------------------------------
 142
 143 bool vtkInteractorStyleSphere::OnLeftButtonDown()
 144 {
 145         _stateRotate    = true;
 146         _fordwareX              = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
 147         _fordwareY              = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
 148         return true;
 149 }
 150
 151
 152 //---------------------------------------------------------------------------
 153
 154 bool  vtkInteractorStyleSphere::OnLeftButtonUp()
 155 {
 156         wxSphereView *wxsphereview = (wxSphereView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
 157         if (_stateRotate==true){
 158                 int fx  = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
 159                 int fy  = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
 160
 161                 if ((_fordwareX==fx)&&(_fordwareY==fy)){
 162                         double x=fx,y=fy,z=1;
 163                         _vtkInteractorStyleBaseView->TransformCoordinate(x,y,z);
 164                         wxsphereview->SetXYZtoParent(x,y);
 165                         wxCommandEvent newevent(wxEVT_COMMAND_MENU_SELECTED,12121);
 166                         wxsphereview->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent);
 167                 } else {
 168                         wxsphereview->RotationEnd();
 169                 }
 170                 wxsphereview->RefreshView();
 171                 _stateRotate = false;
 172         }
 173
 174         return true;
 175 }
 176
 177
 178 //---------------------------------------------------------------------------
 179
 180 bool  vtkInteractorStyleSphere::OnMouseMove ()
 181 {
 182         wxSphereView *wxsphereview = (wxSphereView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
 183         if (_stateRotate==true)
 184         {
 185                 bool ok_v, ok_ang;
 186                 ok_v=false;
 187                 ok_ang=false;
 188                 if (_vtkInteractorStyleBaseView->GetInteractor()->GetControlKey()==1)
 189                 {
 190                         ok_v = true;
 191                 }
 192                 if (_vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey()==1)
 193                 {
 194                         ok_ang = true;
 195                 }
 196             int fx = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
 197         int fy = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
 198                 wxsphereview->RotationStart( fx - _fordwareX , -(fy - _fordwareY) , ok_v, ok_ang);
 199                 wxsphereview->RefreshView();
 200         }
 201         if (_stateRadio==true)
 202         {
 203                 //int fx = this->Interactor->GetEventPosition()[0];
 204         int fy = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
 205                 double dif=(fy-_fordwareY) / 10.0;
 206                 wxsphereview->SetRadio( _radio + dif );
 207                 wxsphereview->SetDeltaVoxel(3);
 208                 wxsphereview->RefreshView();
 209         }
 210
 211         return true;
 212 }
 213
 214
 215
 216 //-------------------------------------------------------------------
 217 //-------------------------------------------------------------------
 218 //-------------------------------------------------------------------
 219
 220 wxSphereView::wxSphereView( wxWindow *parent, vtkMPRBaseData *vtkmprbasedata, vtkImageData *imageData )
 221 : wxVtk2DBaseView(parent)
 222 {
 223         _delta                          =       1;
 224         _vtkmprbasedata         =       vtkmprbasedata;
 225         _imageDataOriginal      =       imageData;
 226
 227         _imageSphere            =       vtkImageData::New();
 228         _imageSphere->SetDimensions (150,150,500);
 229         _imageSphere->SetScalarTypeToUnsignedShort();
 230         _imageSphere->AllocateScalars();
 231         _imageSphere->Update();
 232
 233
 234         vtkBaseData *vtkbasedata = new vtkBaseData();
 235         vtkbasedata->SetMarImageData( new marImageData(_imageSphere) );
 236         this->SetVtkBaseData(vtkbasedata);
 237
 238     _transform                  =       vtkTransform::New();
 239     _transform1                 =       vtkTransform::New();
 240     _transform2                 =       vtkTransform::New();
 241         _transform ->Identity();
 242         _transform1->Identity();
 243         _transform2->Identity();
 244
 245         _radio=25;
 246 }
 247
 248 //-------------------------------------------------------------------
 249
 250 wxSphereView::~wxSphereView()
 251 {
 252         _transform  -> Delete();
 253         _transform1 -> Delete();
 254         _transform2 -> Delete();
 255         ResetlstId();
 256 }
 257
 258 //----------------------------------------------------------------------------
 259
 260 double wxSphereView::GetRadio()
 261 {
 262         return _radio;
 263 }
 264
 265 //----------------------------------------------------------------------------
 266
 267 void wxSphereView::SetRadio(double radio)
 268 {
 269         if (radio<0)
 270         {
 271                 radio=0;
 272         }
 273         _radio=radio;
 274 }
 275
 276 //----------------------------------------------------------------------------
 277
 278 void wxSphereView::Configure()
 279 {
 280         wxVtk2DBaseView::Configure();
 281
 282         _vtkinteractorstylesphere = new vtkInteractorStyleSphere();
 283         GetInteractorStyleBaseView()->AddInteractorStyleMaracas( _vtkinteractorstylesphere );
 284         double points[4][3];
 285
 286 // EED purify 12/sep/2006
 287         int i,j;
 288         for (i=0;i<4;i++)
 289         {
 290                 for (j=0;j<3;j++)
 291                 {
 292                         points[i][j]=0;
 293                 }
 294         }
 295
 296         InitSphere(points);
 297         DefineImageSphere();
 298 }
 299
 300 //----------------------------------------------------------------------------
 301
 302 void wxSphereView::RefreshPoint()
 303 {
 304         double x        = _vtkmprbasedata->GetX() - _centerX;
 305         double y        = _vtkmprbasedata->GetY() - _centerY;
 306         double z        = _vtkmprbasedata->GetZ() - _centerZ;
 307         double alpha= atan2(x,z);
 308         double beta = atan2( y , sqrt(z*z+x*x) );
 309
 310         alpha           = alpha*180/3.1416;
 311         beta            = beta*180/3.1416;
 312
 313         _transform1->Identity();
 314         _transform1->RotateY(alpha);
 315         _transform1->RotateX(-beta);
 316
 317         _radio= sqrt(x*x + y*y +z*z);
 318
 319         RefreshView();
 320 }
 321
 322 //----------------------------------------------------------------------------
 323
 324 void wxSphereView::RefreshView()
 325 {
 326         DefineImageSphere();
 327         wxVtk2DBaseView::Refresh();
 328 }
 329
 330 //----------------------------------------------------------------------------
 331
 332 void wxSphereView::RotationEnd()
 333 {
 334         _transform1->RotateWXYZ(_ang,_vxb,_vyb,0);
 335         _transform2->Identity();
 336         SetDeltaVoxel(1);
 337         ResetlstId();
 338 }
 339
 340 //----------------------------------------------------------------------------
 341
 342 void wxSphereView::RotationStart(double vx, double vy, bool ok_v, bool ok_ang)
 343 {
 344         if (ok_ang==false)
 345         {
 346                 _ang = -sqrt( vx*vx + vy*vy ) / 1.0;
 347         }
 348
 349         if (ok_v==false){
 350                 _vxb=-vy;
 351                 _vyb=vx;
 352         }
 353
 354         _transform2->Identity();
 355         _transform2->RotateWXYZ(_ang,_vxb,_vyb,0);
 356         SetDeltaVoxel(3);
 357         ResetlstId();
 358 }
 359
 360 //----------------------------------------------------------------------------
 361
 362 void wxSphereView::GetPointSphere(double p[3],double r1,double angA,double angB)
 363 {
 364         double in[3],out[3];
 365         in[0]=0;
 366         in[1]=r1;
 367         in[2]=0;
 368         vtkTransform *transform = vtkTransform::New();
 369         transform->Identity();
 370         transform->RotateX(angB);
 371         transform->RotateZ(angA);
 372         transform->TransformPoint(in,out);
 373         p[0]=out[0];
 374         p[1]=out[1];
 375         p[2]=out[2];
 376         transform->Delete();
 377 }
 378
 379 //----------------------------------------------------------------------------
 380
 381 void wxSphereView::RotatePointOverTheSphere( double pp[3], double p[3],double cc[3])
 382 {
 383
 384         double out[3];
 385         _transform->TransformPoint(p,out);
 386         pp[0] = out[0] + cc[0];
 387         pp[1] = out[1] + cc[1];
 388         pp[2] = out[2] + cc[2];
 389
 390 }
 391
 392 //----------------------------------------------------------------------------
 393
 394 void wxSphereView::TransferePoints(double pp1[3],double pp2[3],double AngX,double AngY,vtkImageData *image)
 395 {
 396         double t;
 397         double difX = pp2[0]-pp1[0];
 398         double difY = pp2[1]-pp1[1];
 399         double difZ = pp2[2]-pp1[2];
 400
 401         double  max             = 200;
 402
 403         int dimOrg[3];
 404         int dimRes[3];
 405         int z;
 406         _imageDataOriginal->GetDimensions(dimOrg);
 407         image->GetDimensions(dimRes);
 408
 409         int i;
 410         double x1=pp1[0];
 411         double y1=pp1[1];
 412         double z1=pp1[2];
 413         int xx=-1,yy=-1,zz=-1;
 414
 415         for (i=0;i<max;i++)
 416         {
 417                 t  = i/max;
 418                 xx = (int) (x1+t*difX);
 419                 yy = (int) (y1+t*difY);
 420                 zz = (int) (z1+t*difZ);
 421
 422                 z=i;
 423                 if ((xx>=0) && (xx<dimOrg[0]) && (yy>=0) && (yy<dimOrg[1]) && (zz>=0) && (zz<dimOrg[2]) &&
 424                         (AngX>=0) && (AngX<dimRes[0]) && (AngY>=0) && (AngY<dimRes[1]) && (z>=0) && (z<dimRes[2]) )
 425                 {
 426                         unsigned short *pOrg=(unsigned short*)_imageDataOriginal->GetScalarPointer (xx,yy,zz);
 427                         unsigned short *pRes=(unsigned short*)image->GetScalarPointer( (int)AngX , (int)AngY , z );
 428                         *pRes=*pOrg;
 429                 }
 430         }
 431 }
 432
 433 //----------------------------------------------------------------------------
 434
 435 void wxSphereView::ResetlstId()
 436 {
 437         int i,size=_lstId.size();
 438         for (i=size-1;i>=0;i--)
 439         {
 440                 delete _lstId[i];
 441         }
 442         _lstId.clear();
 443 }
 444
 445 //----------------------------------------------------------------------------
 446
 447 int wxSphereView::GetIdOfImage(double radio)
 448 {
 449         int id=0;
 450         int dim[3];
 451         _imageSphere->GetDimensions(dim);
 452         int sizeMaxList = dim[2];
 453         // Search in list >> alpha beta radio
 454         int i,size=_lstId.size();
 455         for (i=0; i<size;i++)
 456         {
 457                 //idAlBeRa *tmp=_lstId[i]; // JPRx
 458                 if ((_lstId[i]->_radio==radio) && (_lstId[i]->_deltavoxel==_delta))
 459                 {
 460                         return _lstId[i]->_id;
 461                 }
 462         }
 463         if (size>sizeMaxList)
 464         {
 465                 delete _lstId[size-1];
 466                 _lstId.pop_back();
 467         }
 468         if (size!=0){
 469                 id=_lstId[0]->_id+1;
 470                 id = id % sizeMaxList;
 471         } else {
 472                 id = 0;
 473         }
 474
 475         FiltreImage(id,radio);
 476         _lstId.insert(_lstId.begin(),1,new idAlBeRa(id,radio,_delta) );
 477
 478         return id;
 479 }
 480
 481 //----------------------------------------------------------------------------
 482
 483 void wxSphereView::DefineImageSphere()
 484 {
 485         int id;
 486         id=GetIdOfImage( _radio );
 487         GetVtkBaseData()->SetZ( id );
 488 }
 489
 490
 491 //----------------------------------------------------------------------------
 492 void wxSphereView::SetDeltaVoxel(int delta)
 493 {
 494         _delta=delta;
 495 }
 496
 497 //----------------------------------------------------------------------------
 498 void wxSphereView::SetVoxel(double i, double j, int delta,double id,  unsigned short gris)
 499 {
 500         int ii,jj,delta2;
 501         unsigned short *pRes;
 502         int dimRes[3];
 503         _imageSphere->GetDimensions(dimRes);
 504
 505         delta2=delta-1;
 506         for ( ii=(int)(i-delta2) ; ii<=(int)(i+delta2) ; ii++ )
 507         {
 508                 for ( jj=(int)(j-delta2) ; jj<=(int)(j+delta2) ; jj++ )
 509                 {
 510                         if ( (ii>=0)&&(ii<dimRes[0]) &&
 511                                  (jj>=0)&&(jj<dimRes[1]) )
 512                         {
 513                                 pRes = (unsigned short*)_imageSphere->GetScalarPointer( ii , jj , (int)id );
 514                                 *pRes=gris;
 515                         }
 516                 }
 517         }
 518
 519 }
 520
 521 //----------------------------------------------------------------------------
 522
 523 void wxSphereView::SetXYZtoParent(double i, double j)
 524 {
 525
 526         double factor = 0.75;
 527         double radio2   = _radio*_radio;
 528         double pxx,pyy,d2x,d2y;
 529         double cc[3],p[3],pp[3];
 530         cc[0]=_centerX;
 531         cc[1]=_centerY;
 532         cc[2]=_centerZ;
 533         double aa;
 534         int dimRes[3],dimOrig[3];
 535         _imageSphere->GetDimensions(dimRes);
 536         d2x=dimRes[0]/2;
 537         d2y=dimRes[1]/2;
 538         _imageDataOriginal->GetDimensions(dimOrig);
 539
 540         p[0]  = (i - d2x)*factor;
 541         pxx=p[0]*p[0];
 542         p[1]  = (j - d2y)*factor;
 543         pyy=p[1]*p[1];
 544         aa = pxx + pyy;
 545         if (radio2>aa){
 546                 aa=radio2-aa;
 547                 p[2]  = sqrt(aa);
 548                 RotatePointOverTheSphere( pp, p,cc);
 549                 if ( (pp[0]>=0) && (pp[0]<dimOrig[0]) &&
 550                          (pp[1]>=0) && (pp[1]<dimOrig[1]) &&
 551                          (pp[2]>=0) && (pp[2]<dimOrig[2]) )
 552                 {
 553                         if (_vtkmprbasedata){
 554                                 _vtkmprbasedata->SetX(pp[0]);
 555                                 _vtkmprbasedata->SetY(pp[1]);
 556                                 _vtkmprbasedata->SetZ(pp[2]);
 557                         }
 558                 }
 559         }
 560 }
 561
 562
 563 //----------------------------------------------------------------------------
 564
 565 void wxSphereView::FiltreImageB(int id, double radio, bool ok,int deltaTMP)
 566 {
 567         double factor = 0.75;
 568         double radioB   = radio/3;
 569         double radio2   = radio*radio;
 570         double pxx,pyy,d2x,d2y;
 571         double cc[3],p[3],pp[3];
 572         cc[0]=_centerX;
 573         cc[1]=_centerY;
 574         cc[2]=_centerZ;
 575         double aa;
 576         unsigned short *pOrig;
 577         int dimRes[3],dimOrig[3];
 578         double i,j;
 579         _imageSphere->GetDimensions(dimRes);
 580         _imageSphere->SetExtent(0,dimRes[0]-1,0,dimRes[1]-1,0,dimRes[2]-1);
 581         d2x=dimRes[0]/2;
 582         d2y=dimRes[1]/2;
 583 //      double deltaTMP=_delta;
 584         _imageDataOriginal->GetDimensions(dimOrig);
 585
 586         int start,end;
 587         int limitA,limitB;
 588         limitA  = (int) ( (-radioB/factor)+d2x );
 589         limitB  = (int) ( (radioB/factor)+d2x );
 590         if (ok==true){
 591                 start   = limitA;
 592                 end             = limitB;
 593         } else {
 594                 start=0;
 595                 end=dimRes[0];
 596         }
 597
 598         for ( i=start ; i<end ; i=i+deltaTMP )
 599         {
 600                 p[0]  = (i - d2x)*factor;
 601                 pxx=p[0]*p[0];
 602                 for (j=start;j<end;j=j+deltaTMP)
 603                 {
 604                         p[1]  = (j - d2y)*factor;
 605                         pyy=p[1]*p[1];
 606                         aa = pxx + pyy;
 607
 608                         if  (( ((ok==false) && (!((i>limitA) && (i<limitB) && (j>limitA) && (j<limitB)))) )
 609                                     ||
 610                                         (ok==true))
 611                         {
 612                                 if (radio2>aa){
 613                                         aa=radio2-aa;
 614                                         p[2]  = sqrt(aa);
 615                                         RotatePointOverTheSphere( pp, p,cc);
 616                                         if ( (pp[0]>=0) && (pp[0]<dimOrig[0]) &&
 617                                                  (pp[1]>=0) && (pp[1]<dimOrig[1]) &&
 618                                                  (pp[2]>=0) && (pp[2]<dimOrig[2]) )
 619                                         {
 620                                                 pOrig=(unsigned short*)_imageDataOriginal->GetScalarPointer( (int)(pp[0]) , (int)(pp[1]) , (int)(pp[2]) );
 621                                                 SetVoxel(i,j,deltaTMP,id,*pOrig);
 622                                         } else {
 623                                                 SetVoxel(i,j,deltaTMP,id,2000);
 624                                         }
 625                                 } else {
 626                                         SetVoxel(i,j,deltaTMP,id,0);
 627                                 }
 628                         }
 629                 }
 630         }
 631
 632         _imageSphere->Modified();
 633         _imageSphere->Update();
 634 }
 635
 636
 637
 638
 639 //----------------------------------------------------------------------------
 640
 641 void wxSphereView::FiltreImage(int id, double radio)
 642 {
 643
 644         _transform -> Identity();
 645         _transform -> Concatenate(_transform1);
 646         _transform -> Concatenate(_transform2);
 647
 648         FiltreImageB(id,radio,false, _delta);
 649         FiltreImageB(id,radio,true, 1);
 650 }
 651
 652
 653 //----------------------------------------------------------------------------
 654
 655 /*
 656 void wxSphereView::FiltreImage(int id, double radio)
 657 {
 658         double radio2   = radio*radio;
 659         double radio2TMP= (radio/2)*(radio/2);
 660         double pxx,pyy,d2x,d2y;
 661         double cc[3],p[3],pp[3];
 662         cc[0]=_centerX;
 663         cc[1]=_centerY;
 664         cc[2]=_centerZ;
 665         double aa;
 666         unsigned short *pOrig;
 667         int dimRes[3],dimOrig[3];
 668         double i,j;
 669         _imageSphere->GetDimensions(dimRes);
 670         _imageSphere->SetExtent(0,dimRes[0]-1,0,dimRes[1]-1,0,dimRes[2]-1);
 671         d2x=dimRes[0]/2;
 672         d2y=dimRes[1]/2;
 673         double deltaTMP=_delta;
 674         _imageDataOriginal->GetDimensions(dimOrig);
 675
 676         for ( i=0 ; i<dimRes[0] ; i=i+deltaTMP )
 677         {
 678                 p[0]  = (i - d2x)*0.75;
 679                 pxx=p[0]*p[0];
 680                 for (j=0;j<dimRes[1];j=j+deltaTMP)
 681                 {
 682                         p[1]  = (j - d2y)*0.75;
 683                         pyy=p[1]*p[1];
 684                         aa = pxx + pyy;
 685
 686                         if (aa>radio2TMP)
 687                         {
 688                                 if (radio2>aa){
 689                                         aa=radio2-aa;
 690                                         p[2]  = sqrt(aa);
 691                                         RotatePointOverTheSphere( pp, p,cc);
 692                                         if ( (pp[0]>=0) && (pp[0]<dimOrig[0]) &&
 693                                                  (pp[1]>=0) && (pp[1]<dimOrig[1]) &&
 694                                                  (pp[2]>=0) && (pp[2]<dimOrig[2]) )
 695                                         {
 696                                                 pOrig=(unsigned short*)_imageDataOriginal->GetScalarPointer( pp[0] , pp[1] , pp[2] );
 697                                                 SetVoxel(i,j,deltaTMP,id,*pOrig);
 698                                         } else {
 699                                                 SetVoxel(i,j,deltaTMP,id,2000);
 700                                         }
 701                                 } else {
 702                                         SetVoxel(i,j,deltaTMP,id,0);
 703                                 }
 704                         }
 705                 }
 706         }
 707
 708
 709         deltaTMP=1;
 710         for ( i=0 ; i<dimRes[0] ; i=i+deltaTMP )
 711         {
 712                 p[0]  = (i - d2x)*0.75;
 713                 pxx=p[0]*p[0];
 714                 for (j=0;j<dimRes[1];j=j+deltaTMP)
 715                 {
 716                         p[1]  = (j - d2y)*0.75;
 717                         pyy=p[1]*p[1];
 718                         aa = pxx + pyy;
 719                         if (aa<=radio2TMP)
 720                         {
 721                                 if (radio2>aa){
 722                                         aa=radio2-aa;
 723                                         p[2]  = sqrt(aa);
 724                                         RotatePointOverTheSphere( pp, p,cc);
 725                                         if ( (pp[0]>=0) && (pp[0]<dimOrig[0]) &&
 726                                                  (pp[1]>=0) && (pp[1]<dimOrig[1]) &&
 727                                                  (pp[2]>=0) && (pp[2]<dimOrig[2]) )
 728                                         {
 729                                                 pOrig=(unsigned short*)_imageDataOriginal->GetScalarPointer( pp[0] , pp[1] , pp[2] );
 730                                                 SetVoxel(i,j,deltaTMP,id,*pOrig);
 731                                         } else {
 732                                                 SetVoxel(i,j,deltaTMP,id,2000);
 733                                         }
 734                                 } else {
 735                                         SetVoxel(i,j,deltaTMP,id,0);
 736                                 }
 737                         }
 738                 }
 739         }
 740
 741         _imageSphere->Modified();
 742         _imageSphere->Update();
 743 }
 744 */
 745 /*
 746 void wxSphereView::FiltreImage(vtkImageData *imageSphere)
 747 {
 748         int dim[3],i,j,k;
 749         imageSphere->GetDimensions(dim);
 750         for (i=0;i<dim[0];i++)
 751         {
 752                 for (j=0;j<dim[1];j++)
 753                 {
 754                         for (k=0;k<dim[2];k++)
 755                         {
 756                                 unsigned short *pRes=(unsigned short*)imageSphere->GetScalarPointer (i,j,k);
 757                                 *pRes=0;
 758                         }
 759                 }
 760         }
 761
 762         double deltaA=90;
 763         double cc[3],p1[3],p2[3],pp1[3],pp2[3];
 764         cc[0]=_centerX;
 765         cc[1]=_centerY;
 766         cc[2]=_centerZ;
 767         double r1       = _sl_radio->GetValue() - _sl_thickness->GetValue()/2;
 768         double r2       = _sl_radio->GetValue() + _sl_thickness->GetValue()/2;
 769         if (r1<10)
 770         {
 771                 r1=10;
 772         }
 773         double alpha= _sl_alpha->GetValue();
 774         double beta     = _sl_beta->GetValue();
 775
 776         double angA,angB;
 777         for (angA=-deltaA;angA<deltaA;angA++)
 778         {
 779                 for (angB=-deltaA;angB<deltaA;angB++)
 780                 {
 781                         GetPointSphere(p1,r1,angA,angB);
 782                         GetPointSphere(p2,r2,angA,angB);
 783                         RotatePointOverTheSphere( pp1, alpha, beta, p1 ,cc );
 784                         RotatePointOverTheSphere( pp2, alpha, beta, p2 ,cc );
 785                         TransferePoints(pp1,pp2,angA+alpha+180,angB+beta+90,imageSphere);
 786                 }
 787         }
 788 }
 789 */
 790
 791
 792 //----------------------------------------------------------------------------
 793
 794 void wxSphereView::InitSphere(double points[4][3])
 795 {
 796         double cc[3];
 797     double r = SphereFindCenter(points,cc); // 4-points , center
 798     if (r > 0)
 799     {
 800         _centerX        = (int)(cc[0]);
 801         _centerY        = (int)(cc[1]);
 802         _centerZ        = (int)(cc[2]);
 803     } else {
 804                 int dim[3];
 805                 _imageDataOriginal->GetDimensions(dim);
 806         _centerX        = (int)(dim[0]/2);
 807         _centerY        = (int)(dim[1]/2);
 808         _centerZ        = (int)(dim[2]/2);
 809         }
 810 }
 811
 812 //----------------------------------------------------------------------------
 813
 814 // Calculate center and radius of sphere given four points
 815 // http://home.att.net/~srschmitt/script_sphere_solver.html
 816 // source code HTML <script language=JavaScript>
 817 double wxSphereView::SphereFindCenter(double P[4][3], double cc[3])
 818 {
 819     int i;
 820     double r, m11, m12, m13, m14, m15;
 821         double a[4][4];
 822
 823     for (i = 0; i < 4; i++)                    // find minor 11
 824     {
 825         a[i][0] = P[i][0];
 826         a[i][1] = P[i][1];
 827         a[i][2] = P[i][2];
 828         a[i][3] = 1;
 829     }
 830     m11 = determinant( a, 4 );
 831
 832     for (i = 0; i < 4; i++)                    // find minor 12
 833     {
 834         a[i][0] = P[i][0]*P[i][0] + P[i][1]*P[i][1] + P[i][2]*P[i][2];
 835         a[i][1] = P[i][1];
 836         a[i][2] = P[i][2];
 837         a[i][3] = 1;
 838     }
 839     m12 = determinant( a, 4 );
 840
 841     for (i = 0; i < 4; i++)                    // find minor 13
 842     {
 843         a[i][0] = P[i][0]*P[i][0] + P[i][1]*P[i][1] + P[i][2]*P[i][2];
 844         a[i][1] = P[i][0];
 845         a[i][2] = P[i][2];
 846         a[i][3] = 1;
 847     }
 848     m13 = determinant( a, 4 );
 849
 850     for (i = 0; i < 4; i++)                    // find minor 14
 851     {
 852         a[i][0] = P[i][0]*P[i][0] + P[i][1]*P[i][1] + P[i][2]*P[i][2];
 853         a[i][1] = P[i][0];
 854         a[i][2] = P[i][1];
 855         a[i][3] = 1;
 856     }
 857     m14 = determinant( a, 4 );
 858
 859
 860     for (i = 0; i < 4; i++)                    // find minor 15
 861     {
 862         a[i][0] = P[i][0]*P[i][0] + P[i][1]*P[i][1] + P[i][2]*P[i][2];
 863         a[i][1] = P[i][0];
 864         a[i][2] = P[i][1];
 865         a[i][3] = P[i][2];
 866     }
 867     m15 = determinant( a, 4 );
 868
 869     if (m11 == 0)
 870     {
 871         r = 0;
 872     }
 873     else
 874     {
 875                 // center of sphere
 876         cc[0] =  0.5*m12/m11;   //cx
 877         cc[1] = -0.5*m13/m11;   //cy
 878         cc[2] =  0.5*m14/m11;   //cz
 879                 // Sphere radio
 880         r  = sqrt( cc[0]*cc[0] + cc[1]*cc[1] + cc[2]*cc[2] - m15/m11 );
 881     }
 882
 883     return r;                                  // the radius
 884 }
 885 //----------------------------------------------------------------------------
 886
 887 //  Recursive definition of determinate using expansion by minors.
 888 double wxSphereView::determinant(double a[4][4], int n)
 889 {
 890     int i, j, j1, j2;
 891     double d;
 892         double m[4][4];
 893
 894         for (i=0;i<4;i++)
 895         {
 896                 for (j=0;j<4;j++)
 897                 {
 898                         m[i][j]=0;
 899                 }
 900         }
 901
 902     if (n == 2)                                // terminate recursion
 903     {
 904         d = a[0][0]*a[1][1] - a[1][0]*a[0][1];
 905     }
 906     else
 907     {
 908         d = 0;
 909         for (j1 = 0; j1 < n; j1++ )            // do each column
 910         {
 911             for (i = 1; i < n; i++)            // create minor
 912             {
 913                 j2 = 0;
 914                 for (j = 0; j < n; j++)
 915                 {
 916                     if (j == j1) continue;
 917                     m[i-1][j2] = a[i][j];
 918                     j2++;
 919                 }
 920             }
 921
 922             // sum (+/-)cofactor * minor
 923             d = d + pow(-1.0, j1)*a[0][j1]*determinant( m, n-1 );
 924         }
 925     }
 926
 927     return d;
 928 }
 929
 930
 931
 932
 933 //-------------------------------------------------------------------
 934 //-------------------------------------------------------------------
 935 //-------------------------------------------------------------------
 936
 937 vtkInteractorStylePlane2D::vtkInteractorStylePlane2D()
 938 {
 939         _stateRotate=false;
 940 }
 941 //---------------------------------------------------------------------------
 942 vtkInteractorStylePlane2D::~vtkInteractorStylePlane2D()
 943 {
 944 }
 945
 946 //---------------------------------------------------------------------------
 947 bool vtkInteractorStylePlane2D::GetStateRotate()
 948 {
 949         return _stateRotate;
 950 }
 951
 952 //---------------------------------------------------------------------------
 953 bool  vtkInteractorStylePlane2D::OnLeftButtonDown()  // vitual
 954 {
 955         _stateRotate = true;
 956         _fordwareX = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
 957         _fordwareY = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
 958         vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
 959         vtkplane2Dview->RotationStart();
 960
 961         return true;
 962 }
 963
 964 //---------------------------------------------------------------------------
 965 bool vtkInteractorStylePlane2D::OnLeftButtonUp() // virtual
 966 {
 967         if (_stateRotate==true)
 968         {
 969                 _stateRotate = false;
 970                 vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
 971                 vtkplane2Dview->ResetBack();
 972 //              this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
 973         }
 974
 975         return true;
 976 }
 977
 978 //---------------------------------------------------------------------------
 979 bool  vtkInteractorStylePlane2D::OnRightButtonUp()  // virtual
 980 {
 981         if (_stateRotate==true){
 982                 //vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView()); // JPRx
 983
 984 // EED Borrame
 985 //              vtkplane2Dview->RotationEnd();
 986
 987                 _stateRotate = false;
 988         }
 989
 990         return true;
 991 }
 992 //---------------------------------------------------------------------------
 993 bool  vtkInteractorStylePlane2D::OnMouseMove () // virtual
 994 {
 995         bool ok_v, ok_ang;
 996         if (_stateRotate==true){
 997                 ok_v=false;
 998                 ok_ang=false;
 999                 if (_vtkInteractorStyleBaseView->GetInteractor()->GetControlKey()==1)
1000                 {
1001                         ok_v=true;
1002                 }
1003                 if (_vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey()==1)
1004                 {
1005                         ok_ang=true;
1006                 }
1007             int fx = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
1008         int fy = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
1009                 vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
1010                 vtkplane2Dview->RotationDrag( fx - _fordwareX , fy - _fordwareY , ok_v , ok_ang);
1011                 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
1012         }
1013         return true;
1014 }
1015 //-------------------------------------------------------------------
1016 bool vtkInteractorStylePlane2D::OnLeftDClick() // virtual
1017 {
1018         int fx = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
1019         int fy = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
1020         double xx=fx;
1021         double yy=fy;
1022         double zz=0;
1023
1024         vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
1025         vtkMPRBaseData *vtkmprbasedata = vtkplane2Dview->GetVtkmprbasedata();
1026
1027         vtkplane2Dview->TransfromeCoordViewWorld2(xx,yy,zz);
1028
1029         vtkmprbasedata->SetX( xx );
1030         vtkmprbasedata->SetY( yy );
1031         vtkmprbasedata->SetZ( zz );
1032         this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
1033
1034         return true;
1035 }
1036 //-------------------------------------------------------------------
1037 //-------------------------------------------------------------------
1038 //-------------------------------------------------------------------
1039
1040 vtkPlane2DView::vtkPlane2DView( wxWindow *parent)
1041 : wxVtk2DBaseView(parent)
1042 {
1043
1044         _backX                                  =       -99999;
1045         _backY                                  =       -99999;
1046         _backZ                                  =       -99999;
1047
1048         _backOrient[0]                  =       -99999;
1049         _backOrient[1]                  =       -99999;
1050         _backOrient[2]                  =       -99999;
1051         _backOrient[3]                  =       -99999;
1052
1053         _active                                 =   true;
1054         _mip_visualization              =       true;
1055         _mip_width                              =       2;
1056
1057     _transform1                         =       vtkTransform::New();
1058     _transform2                         =       vtkTransform::New();
1059         _transform1->Identity();
1060         _transform2->Identity();
1061
1062         _sizeIma                                =       200;
1063
1064         _pSource                                =       NULL;
1065         _3Dslices                               =       NULL;
1066         _stPoints                               =       NULL;
1067         _change                                 =       NULL;
1068         _imageResult                    =       NULL;
1069
1070         // line horizontal
1071     _pts                        = NULL;
1072     _lineActor          = NULL;
1073         _lineMapper             = NULL;
1074         _pd                             = NULL;
1075
1076         _interactorstyleplane2D =       false;
1077 }
1078 //-------------------------------------------------------------------
1079 vtkPlane2DView::~vtkPlane2DView()
1080 {
1081         ResetPlane();
1082
1083         // Horizontal Line
1084     if (_pts            != NULL)        {       _pts                    -> Delete(); }
1085     if (_lineActor      != NULL)        {       _lineActor              -> Delete(); }
1086     if (_lineMapper     != NULL)        {       _lineMapper             -> Delete(); }
1087     if (_pd                     != NULL)        {       _pd                             -> Delete(); }
1088
1089         _transform1             -> Delete();
1090         _transform2             -> Delete();
1091 }
1092
1093 //-------------------------------------------------------------------
1094 void vtkPlane2DView::ResetBack()
1095 {
1096                 _backX=-1;
1097                 _backY=-1;
1098                 _backZ=-1;
1099                 _backOrient[0]=-1;
1100                 _backOrient[1]=-1;
1101                 _backOrient[2]=-1;
1102                 _backOrient[3]=-1;
1103 }
1104
1105 //-------------------------------------------------------------------
1106 void vtkPlane2DView::ResetPlane(){
1107         if (_pSource    !=NULL) { _pSource      -> Delete();    }
1108         if (_3Dslices   !=NULL) { _3Dslices     -> Delete();    }
1109         if (_stPoints   !=NULL) { _stPoints     -> Delete();    }
1110         if (_change             !=NULL) { _change       -> Delete();    }
1111 }
1112 //-------------------------------------------------------------------
1113 vtkMPRBaseData *vtkPlane2DView::GetVtkmprbasedata()
1114 {
1115         return (vtkMPRBaseData*)GetVtkBaseData();
1116 }
1117
1118 //-------------------------------------------------------------------
1119 void vtkPlane2DView::SetPSource(int sizeIma){
1120         int dimIma      = sizeIma;
1121
1122         double x = GetVtkmprbasedata()->GetX();
1123         double y = GetVtkmprbasedata()->GetY();
1124         double z = GetVtkmprbasedata()->GetZ();
1125
1126         double spc[3];
1127         vtkImageData *imagedata = GetVtkmprbasedata()->GetImageData();
1128         imagedata->GetSpacing(spc);
1129         x=x*spc[0];
1130         y=y*spc[1];
1131         z=z*spc[2];
1132
1133
1134         vtkMPRBaseData  *mprbasedata = (vtkMPRBaseData*)this->GetVtkBaseData();
1135         vtkTransform    *transform       = mprbasedata->GetTransformOrientation();
1136
1137         double in[3];  // temp
1138         double pA[3];
1139         double pB[3];
1140         in[0]=1;                in[1]=0;                        in[2]=0;
1141         transform->TransformPoint(in,_n);
1142
1143         in[0]=0;        in[1]=dimIma-1;         in[2] = 0;
1144         transform->TransformPoint(in,pA);
1145
1146         in[0]=0;        in[1]=0;                in[2]=dimIma-1;
1147         transform->TransformPoint(in,pB);
1148
1149     _pSource -> SetPoint1( pA   );
1150     _pSource -> SetPoint2( pB   );
1151
1152         _pSource -> SetOrigin( 0        , 0             , 0             );
1153     _pSource -> SetResolution( sizeIma-1 , sizeIma -1 );
1154         _pSource -> Update();
1155         _pSource -> SetCenter( x, y, z );
1156     _pSource -> SetNormal( _n );
1157     _pSource -> Update( );
1158
1159 // EED Borrame
1160 //      transform->Delete();
1161
1162 }
1163
1164 //-------------------------------------------------------------------
1165 void vtkPlane2DView::ExtractPlane()
1166 {
1167
1168         double x = GetVtkmprbasedata()->GetX();
1169         double y = GetVtkmprbasedata()->GetY();
1170         double z = GetVtkmprbasedata()->GetZ();
1171
1172         double spc[3];
1173         vtkImageData *imagedata = GetVtkmprbasedata()->GetImageData();
1174         imagedata->GetSpacing(spc);
1175         x=x*spc[0];
1176         y=y*spc[1];
1177         z=z*spc[2];
1178
1179         vtkTransform *transform = GetVtkmprbasedata()->GetTransformOrientation();
1180         double orientation[4];
1181         transform->GetOrientationWXYZ(orientation);
1182
1183         bool okOrientation=true;
1184         if ((orientation[0]!=_backOrient[0]) || (orientation[1]!=_backOrient[1]) ||
1185                 (orientation[2]!=_backOrient[2]) || (orientation[3]!=_backOrient[3]))
1186         {
1187                 okOrientation=false;
1188         }
1189
1190         bool okPosicion=true;
1191         if ( (x!=_backX) || (y!=_backY) || (z!=_backZ) )
1192         {
1193                 okPosicion=false;
1194         }
1195
1196         if ((okPosicion==false) || (okOrientation==false) ) {
1197                 if (_active==true){
1198
1199                         bool ok = false;
1200
1201                         if ( _mip_visualization==true )
1202                         {
1203                                 if (_interactorstyleplane2D!=NULL)
1204                                 {
1205                                         if (_interactorstyleplane2D->GetStateRotate()==false )
1206                                         {
1207                                                 ok=true;
1208                                         }
1209                                 }
1210                         }
1211 //                      ok=true;
1212
1213                         if (ok==true)
1214                         {
1215                                 Extract_MIP_PlaneVTK();
1216                         } else {
1217                                 Extract_One_PlaneVTK();
1218                         } // ok
1219
1220                 } // active
1221                 _backX=x;
1222                 _backY=y;
1223                 _backZ=z;
1224                 _backOrient[0]=orientation[0];
1225                 _backOrient[1]=orientation[1];
1226                 _backOrient[2]=orientation[2];
1227                 _backOrient[3]=orientation[3];
1228         } //okPosition okOrientation
1229 }
1230
1231 //-------------------------------------------------------------------
1232
1233 void vtkPlane2DView::Extract_One_PlaneVTK()
1234 {
1235         vtkImageData *imagedata = GetVtkmprbasedata()->GetImageData();
1236         SetPSource(_sizeIma);
1237         _3Dslices -> SetInput( ( vtkDataSet* )_pSource->GetOutput( ) );
1238         _3Dslices -> SetSource( imagedata );
1239         _3Dslices -> Update( );
1240         _stPoints -> GetPointData( )->SetScalars(  _3Dslices->GetOutput()->GetPointData()->GetScalars()  );
1241         _stPoints -> SetDimensions( _sizeIma, _sizeIma, 1 );
1242         _stPoints -> SetScalarType( imagedata->GetScalarType() );
1243         _stPoints -> SetScalarTypeToShort();
1244         _stPoints -> Update();
1245 //      _change   -> SetInput( _stPoints );
1246 //      _change   -> Update();    //important
1247         _imageViewer2XYZ->GetVtkImageViewer2()->SetInput ( _stPoints );
1248 //      _imageViewer2XYZ->GetVtkImageViewer2()->SetInput ( _change->GetOutput() );
1249         //      vtkImageActor *imageActor = _imageViewer2XYZ->GetVtkImageViewer2()->GetImageActor();
1250 }
1251
1252 //-------------------------------------------------------------------
1253
1254 void vtkPlane2DView::Extract_MIP_PlaneVTK( /*double heightDefinition*/ )
1255 {
1256
1257         int mipWidth;
1258         double sp;
1259         int sizeWidth = (_mip_width*2)+1 ;
1260         int deltaPixel;
1261         int iWidth,itmp,tmpSizeWith;
1262
1263         double spc[3];
1264         vtkImageData *imagedata = GetVtkmprbasedata()->GetImageData();
1265         SetPSource(_sizeIma);
1266         imagedata->GetSpacing(spc);
1267
1268         bool heightDefinition=false;
1269         if (_mip_width<3)
1270         {
1271                 heightDefinition=true;
1272         }
1273
1274         if (heightDefinition==true)
1275         {
1276                 mipWidth        =       _mip_width;
1277                 sp                      =       spc[0];
1278                 deltaPixel      =       1;
1279         } else {
1280                 mipWidth        =       2;
1281                 tmpSizeWith =   (mipWidth*2) + 1;
1282                 sp                      =       (spc[0]*sizeWidth)/tmpSizeWith;
1283                 sizeWidth       =       tmpSizeWith;
1284                 deltaPixel      =       4;
1285         }
1286
1287
1288
1289         std::vector< vtkProbeFilter* > slicesLST;
1290
1291         _pSource->Push( -mipWidth * sp );
1292         _pSource->Update();
1293
1294         for ( iWidth=0 ; iWidth<sizeWidth ; iWidth++ )
1295         {
1296                 vtkProbeFilter *slice = vtkProbeFilter::New();
1297                 slice -> SetInput( ( vtkDataSet* )_pSource->GetOutput( ) );
1298                 slice -> SetSource( imagedata );
1299                 slice -> Update( );
1300                 slicesLST.push_back( slice );
1301                 _pSource->Push( sp );
1302         }
1303
1304         if (_imageResult ==NULL)
1305         {
1306                 _imageResult = vtkImageData::New();
1307                 _imageResult -> SetDimensions(_sizeIma,_sizeIma,1);
1308                 _imageResult -> SetSpacing(1,1,1);
1309                 _imageResult -> SetScalarType( imagedata->GetScalarType() );
1310                 _imageResult -> SetExtent(0,_sizeIma-1,0,_sizeIma-1,0,0);
1311                 _imageResult -> SetWholeExtent(0,_sizeIma-1,0,_sizeIma-1,0,0);
1312                 _imageResult -> AllocateScalars();
1313                 _imageResult -> Update();
1314         }
1315
1316         unsigned short *pTemp;
1317         unsigned short *pResult;
1318         pResult = (unsigned short*)_imageResult->GetScalarPointer( 0 , 0 , 0 );
1319
1320         int iPixels , sizePixels = _sizeIma*_sizeIma;
1321         for(iPixels=0 ; iPixels<sizePixels ; iPixels=iPixels+deltaPixel)
1322         {
1323
1324                 pTemp = (unsigned short*)slicesLST[0]->GetOutput()->GetPointData()->GetScalars()->GetVoidPointer(0);
1325
1326                 pResult = (unsigned short*)_imageResult->GetScalarPointer( 0 , 0 , 0 );
1327                 pResult[iPixels] = pTemp[iPixels];
1328
1329                 for (iWidth=1;iWidth<sizeWidth;iWidth++)
1330                 {
1331                         pTemp = (unsigned short*)slicesLST[iWidth]->GetOutput()->GetPointData()->GetScalars()->GetVoidPointer(0);
1332
1333                         if (pResult[iPixels]< pTemp[iPixels])
1334                         {
1335                                 pResult[iPixels] = pTemp[iPixels];
1336                         }
1337                 }
1338
1339                 if (deltaPixel!=1)
1340                 {
1341                         for (itmp=1;itmp<deltaPixel;itmp++)
1342                         {
1343                                 pResult[iPixels+itmp] = pResult[iPixels];
1344                         }
1345                 }
1346
1347         }
1348
1349         for (iWidth=0;iWidth<sizeWidth;iWidth++)
1350         {
1351                 slicesLST[iWidth]->Delete();
1352         }
1353
1354         _imageResult->Modified();
1355         _imageViewer2XYZ->GetVtkImageViewer2()->SetInput ( _imageResult );
1356
1357 }
1358
1359 //-------------------------------------------------------------------
1360 void vtkPlane2DView::Configure( )
1361 {
1362         wxVtk2DBaseView::Configure(false);
1363
1364         HorizontalLine();
1365 // Borrame
1366 //      CircleLine();
1367
1368         _pSource         = vtkPlaneSource::New( );
1369     _3Dslices    = vtkProbeFilter::New( ) ;
1370         _stPoints        = vtkStructuredPoints::New( );
1371         _change          = vtkImageChangeInformation::New();
1372
1373         wxVTKRenderWindowInteractor *iren               = GetWxVTKRenderWindowInteractor();
1374         ExtractPlane();
1375 //      SetActive(false);
1376         _imageViewer2XYZ -> GetVtkImageViewer2()        -> SetupInteractor ( iren );
1377
1378         SetInteractorStyleImage( vtkInteractorStyleBaseView2D::New() );
1379
1380         _interactorstyleplane2D = new vtkInteractorStylePlane2D();
1381         GetInteractorStyleBaseView()->AddInteractorStyleMaracas( _interactorstyleplane2D );
1382
1383         vtkCamera *camera =_imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->GetActiveCamera();
1384
1385         camera->SetViewUp               (       0                       ,       1                               ,       0       );
1386         camera->SetPosition             ((0+_sizeIma)/2 , (0+_sizeIma)/2        , 10000 );
1387
1388         camera->SetFocalPoint   ((0+_sizeIma)/2 , (0+_sizeIma)/2        ,       0       );
1389         camera->SetClippingRange(0.01, 100000);
1390         camera->ComputeViewPlaneNormal();
1391         camera->SetParallelScale( _sizeIma/3.0 );
1392
1393         // text information over the graphic window
1394         _vtkInfoTextImage                                               = new vtkInfoTextImage();
1395         _vtkInfoTextImageInteractorPlane2D              = new vtkInfoTextImageInteractorPlane2D();
1396         _vtkInfoTextImage->SetWxVtk2DBaseView(this);
1397         _vtkInfoTextImage->SetMarImageData(  GetVtkmprbasedata()->GetMarImageData() );
1398         _vtkInfoTextImageInteractorPlane2D->SetModelVtkInfoTextImage(_vtkInfoTextImage);
1399         _vtkInfoTextImage->Configure();
1400         this->GetInteractorStyleBaseView()->AddInteractorStyleMaracas(_vtkInfoTextImageInteractorPlane2D);
1401
1402
1403 }
1404
1405 //-------------------------------------------------------------------
1406 void vtkPlane2DView::HorizontalLine()
1407 {
1408 // Axe Horizontal
1409         _pts = vtkPoints::New();
1410         _pts->SetNumberOfPoints(2);
1411         _pts->SetPoint(0, -1000 , -1000 , -1000 );
1412         _pts->SetPoint(1,  1000 ,  1000 ,  1000 );
1413         vtkCellArray *lines = vtkCellArray::New();
1414         lines->InsertNextCell(2);
1415         lines->InsertCellPoint(0);
1416         lines->InsertCellPoint(1);
1417         _pd = vtkPolyData::New();
1418     _pd->SetPoints( _pts );
1419     _pd->SetLines( lines );
1420         lines->Delete();  //do not delete lines ??
1421         _lineActor                                      =       vtkActor::New();
1422     _lineMapper                                 =       vtkPolyDataMapper::New();
1423         _lineMapper->SetInput(_pd);
1424         _lineMapper->ImmediateModeRenderingOn();
1425         _lineActor->SetMapper(_lineMapper);
1426         _lineActor->GetProperty()->BackfaceCullingOn();
1427         _lineActor->GetProperty()->SetDiffuseColor(0,0,1);
1428         _lineActor->GetProperty()->SetLineWidth(2);
1429         _lineActor->GetProperty()->SetOpacity(0);
1430     _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineActor );
1431 }
1432
1433 //-------------------------------------------------------------------
1434 void vtkPlane2DView::RotationStart()
1435 {
1436         vtkMPRBaseData  *mprbasedata = (vtkMPRBaseData*)this->GetVtkBaseData();
1437         vtkTransform    *transform       = mprbasedata->GetTransformOrientation();
1438         _transform1->SetMatrix( transform->GetMatrix() );
1439 }
1440 //-------------------------------------------------------------------
1441 void vtkPlane2DView::RotationDrag(double vx, double vy, bool ok_v, bool ok_ang)
1442 {
1443         if (ok_ang==false)
1444         {
1445                 _ang =sqrt( vx*vx + vy*vy ) / 1.5;
1446         }
1447
1448         if (ok_v==false){
1449                 _vxb=-vy;
1450                 _vyb=vx;
1451         }
1452         _transform2->Identity();
1453         _transform2->RotateWXYZ(_ang,0,_vxb,_vyb);
1454
1455         vtkMPRBaseData  *mprbasedata = (vtkMPRBaseData*)this->GetVtkBaseData();
1456         vtkTransform *transform          =      vtkTransform::New();
1457         transform->Identity();
1458         transform->Concatenate(_transform1);
1459         transform->Concatenate(_transform2);
1460         mprbasedata->InitTransformOrientation(transform);
1461         transform->Delete();
1462
1463         // Refresh Horizontal Line
1464         _pts->SetPoint( 0 , (_sizeIma/2) - _vxb*2       , (_sizeIma/2) - _vyb*2 , 1 );
1465         _pts->SetPoint( 1 , (_sizeIma/2) + _vxb*2       , (_sizeIma/2) + _vyb*2 , 1 );
1466 //      RefreshCircleLine();
1467 }
1468
1469 //-------------------------------------------------------------------
1470 void vtkPlane2DView::Refresh(  )
1471 {
1472         ExtractPlane();
1473         wxVtkBaseView::Refresh();
1474 }
1475 //-------------------------------------------------------------------
1476 void vtkPlane2DView::SetImgSize( int imgSize )
1477 {
1478         _sizeIma = imgSize;
1479 }
1480 //-------------------------------------------------------------------
1481 int vtkPlane2DView::GetImgSize()
1482 {
1483         return _sizeIma;
1484 }
1485 //-------------------------------------------------------------------
1486 int     vtkPlane2DView::GetActualSlice()  // virtual
1487 {
1488         _cx = GetVtkmprbasedata()->GetX();
1489         _cy = GetVtkmprbasedata()->GetY();
1490         _cz = GetVtkmprbasedata()->GetZ();
1491         return 0;
1492 }
1493
1494 //-------------------------------------------------------------------
1495
1496 bool vtkPlane2DView::GetMipVisualization()
1497 {
1498         return _mip_visualization;
1499 }
1500
1501 //-------------------------------------------------------------------
1502 int vtkPlane2DView::GetMipWidth()
1503 {
1504         return _mip_width;
1505 }
1506
1507 //-------------------------------------------------------------------
1508 void vtkPlane2DView::SetActualSlice(int slice)  // Virtual
1509 {
1510         double dir=(double)slice/3.0;
1511         GetVtkmprbasedata()->SetX( _cx + (_n[0]*dir) );
1512         GetVtkmprbasedata()->SetY( _cy + (_n[1]*dir) );
1513         GetVtkmprbasedata()->SetZ( _cz + (_n[2]*dir) );
1514 }
1515 //---------------------------------------------------------------------------
1516 vtkInteractorStylePlane2D       *vtkPlane2DView::GetInteractorstyleplane2D()
1517 {
1518         return this->_interactorstyleplane2D;
1519 }
1520 //---------------------------------------------------------------------------
1521 void vtkPlane2DView::SetActive(bool active)
1522 {
1523         _active = active;
1524 }
1525
1526 //---------------------------------------------------------------------------
1527
1528 void vtkPlane2DView::SetMipVisualization(bool ok)
1529 {
1530         _mip_visualization=ok;
1531 }
1532
1533 //---------------------------------------------------------------------------
1534
1535 void vtkPlane2DView::SetMipWidth(int value)
1536 {
1537         _mip_width=value;
1538 }
1539
1540 //---------------------------------------------------------------------------
1541 void vtkPlane2DView::SetVisibleLine(bool ok)
1542 {
1543         double opacity;
1544         if (ok==true)
1545         {
1546                 opacity=1;
1547         } else {
1548                 opacity=0;
1549         }
1550         _lineActor->GetProperty()->SetOpacity(opacity);
1551 }
1552 // ----------------------------------------------------------------------------
1553 void vtkPlane2DView::TransfromeCoordViewWorld2(double &X, double &Y, double &Z)
1554 {
1555         double spc[3];
1556         GetVtkmprbasedata()->GetImageData()->GetSpacing(spc);
1557
1558         double xx = X;
1559         double yy = Y;
1560         double zz = 0;
1561
1562         TransfromeCoordScreenToWorld(xx,yy,zz);
1563
1564
1565         vtkTransform *transf1 = vtkTransform::New();
1566         transf1->Identity();
1567         vtkTransform *transf2 = GetVtkmprbasedata()->GetTransformOrientation();
1568         transf1->Concatenate(transf2->GetMatrix());
1569         double in[4], out[4];
1570         double center = GetImgSize() / 2;
1571         in[0] = 0;
1572         in[1] = xx - center;
1573         in[2] = yy - center;
1574         in[3] = 0;
1575
1576         transf1->MultiplyPoint(in,out);
1577         transf1->Delete();
1578
1579         X = out[0] + GetVtkmprbasedata()->GetX() ;
1580         Y = out[1] + GetVtkmprbasedata()->GetY() ;
1581         Z = out[2] + GetVtkmprbasedata()->GetZ() ;
1582
1583 }
1584
1585 //-------------------------------------------------------------------
1586 //-------------------------------------------------------------------
1587 //-------------------------------------------------------------------
1588 vtkInfoTextImageInteractorPlane2D::vtkInfoTextImageInteractorPlane2D()
1589 {
1590 }
1591 //-------------------------------------------------------------------
1592 vtkInfoTextImageInteractorPlane2D::~vtkInfoTextImageInteractorPlane2D()
1593 {
1594 }
1595 //-------------------------------------------------------------------
1596 bool vtkInfoTextImageInteractorPlane2D::OnMouseMove()
1597 {
1598         int X,Y;
1599         wxVTKRenderWindowInteractor *wxVTKiren;
1600         wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
1601         wxVTKiren->GetEventPosition(X,Y);
1602
1603         int z = (int) (_vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetVtkBaseData()->GetZ());
1604         double xx=X,yy=Y,zz=z;
1605
1606 // --> dif
1607         vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)_vtkInteractorStyleBaseView->GetWxVtk2DBaseView();
1608         vtkplane2Dview->TransfromeCoordViewWorld2(xx,yy,zz);
1609
1610         GetVtkInfoTextImage()->PutWindowLevel();
1611         GetVtkInfoTextImage()->PutColorLevel();
1612         GetVtkInfoTextImage()->PutPosition( (int)xx , (int)yy , (int)zz );
1613         GetVtkInfoTextImage()->PutPixelIntensity( (int)xx , (int)yy , (int)zz );
1614
1615         this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
1616         return true;
1617 }
1618
1619 // ----------------------------------------------------------------------------
1620 // ----------------------------------------------------------------------------
1621 // ----------------------------------------------------------------------------
1622 manualViewPerpPlaneContour::manualViewPerpPlaneContour()
1623 {
1624 }
1625 // ----------------------------------------------------------------------------
1626 manualViewPerpPlaneContour::~manualViewPerpPlaneContour()
1627 {
1628 }
1629
1630
1631 // ----------------------------------------------------------------------------
1632 manualViewPerpPlaneContour * manualViewPerpPlaneContour :: Clone()
1633 {
1634         manualViewPerpPlaneContour * clone = new manualViewPerpPlaneContour();
1635         CopyAttributesTo(clone);
1636         return clone;
1637 }
1638
1639 // ---------------------------------------------------------------------------
1640
1641 void manualViewPerpPlaneContour::CopyAttributesTo( manualViewPerpPlaneContour * cloneObject)
1642 {
1643         // Fathers object
1644         manualViewContour::CopyAttributesTo(cloneObject);
1645 }
1646
1647
1648
1649
1650 // ----------------------------------------------------------------------------
1651 void manualViewPerpPlaneContour::UpdateViewPoint(int id)
1652 {  // virtual
1653         double x,y,z;
1654         manualPoint *mp = _manContModel->GetManualPoint(id);
1655         x = mp->GetX();
1656         y = mp->GetY();
1657         z = mp->GetZ();
1658         FilterCordinateXYZ(x,y,z);
1659
1660         _lstViewPoints[id]->SetPositionXY( x , y ,GetRange(), z );
1661         if ((z>=-1) && (z<=1))
1662         {
1663                 _lstViewPoints[id]->GetVtkActor()->VisibilityOn();
1664         } else {
1665                 _lstViewPoints[id]->GetVtkActor()->VisibilityOff();
1666         }
1667 }
1668 // ----------------------------------------------------------------------------
1669 void manualViewPerpPlaneContour::FilterCordinateXYZ (double &x, double &y, double &z)
1670 {
1671         vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)( this->GetWxVtkBaseView() );
1672         vtkMPRBaseData *vtkmprbasedata = vtkplane2Dview->GetVtkmprbasedata();
1673         vtkTransform *transf1 = vtkTransform::New();
1674         vtkTransform *transf2 = vtkmprbasedata->GetTransformOrientation();
1675         transf1->SetMatrix( transf2->GetMatrix() );
1676         transf1->Inverse();
1677
1678         double in[4], out[4];
1679         double center = vtkplane2Dview->GetImgSize() / 2;
1680
1681         in[0] = x - vtkmprbasedata->GetX();
1682         in[1] = y - vtkmprbasedata->GetY();
1683         in[2] = z - vtkmprbasedata->GetZ();
1684         in[3] = 0;
1685
1686         transf1->MultiplyPoint(in,out);
1687         z = out[0];
1688         x = out[1]+center;
1689         y = out[2]+center;
1690
1691         double spc[3];
1692         this->GetWxVtkBaseView()->GetSpacing(spc);
1693         x = x / spc[0];
1694         y = y / spc[1];
1695         z = z / spc[2];
1696
1697         transf1->Delete();
1698 }
1699
1700 // ----------------------------------------------------------------------------
1701 void manualViewPerpPlaneContour::TransfromeCoordViewWorld( double &X,double &Y,double &Z,int type )
1702 {
1703         Z = 0;
1704         vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)( this->GetWxVtkBaseView() );
1705         vtkplane2Dview->TransfromeCoordViewWorld2(X,Y,Z);
1706 }
1707
1708
1709 // ----------------------------------------------------------------------------
1710 void manualViewPerpPlaneContour::RefreshContour() // virtual
1711 {
1712 //      manualViewContour::RefreshContour();
1713
1714         double pp1[3];
1715         double pp2[3];
1716         double u;
1717
1718 // JSTG 25-02-08 ----------------------------------------------------------
1719 //              tt;
1720 //--------------------------------------------------------
1721
1722         double pp[3];
1723         double ppB[3];
1724         double ppC[3];
1725         ppB[0] = 999999;
1726         double dist,distMin = 99999999;
1727
1728         vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)( this->GetWxVtkBaseView() );
1729         double center = vtkplane2Dview->GetImgSize() / 2;
1730
1731         int i,np,nps;
1732         np              = GetNumberOfPoints( );
1733
1734 //JSTG 25-02-08 ------------------------------------------
1735         //double t,delta;
1736     //nps               = GetNumberOfPointsSpline();
1737         nps = _manContModel->GetNumberOfPointsSpline();
1738         //delta = ( double ) ( np  ) / ( double ) ( nps-1  );
1739         _manContModel->UpdateSpline();
1740 //--------------------------------------------------------
1741
1742         if ( np >= 2 )
1743         {
1744                 for( i = 0; i < nps; i++ )
1745                 {
1746 // JSTG 25-02-08 ----------------------------------------------------------
1747                         //t     = delta * (double)i ;
1748                         //tt    = delta * (double)(i+1) ;
1749                         //_manContModel->GetSplinePoint(t ,pp1[0],pp1[1],pp1[2]);
1750                         //_manContModel->GetSplinePoint(tt,pp2[0],pp2[1],pp2[2]);
1751                         _manContModel->GetSpline_i_Point(i ,&pp1[0],&pp1[1],&pp1[2]);
1752                         _manContModel->GetSpline_i_Point(i+1,&pp2[0],&pp2[1],&pp2[2]);
1753 //--------------------------------------------------------------------------
1754                         FilterCordinateXYZ(pp1[0],pp1[1],pp1[2]);
1755                         FilterCordinateXYZ(pp2[0],pp2[1],pp2[2]);
1756                         if (pp2[2]*pp1[2]<=0)
1757                         {
1758                                 if (pp1[2]-pp2[2]!=0) {
1759                                         u = -pp2[2] / (pp1[2]-pp2[2]);
1760                                 } else  {
1761                                         u=9999999;
1762                                 }
1763                                 pp[0]    = ( pp1[0]-pp2[0] )*u + pp2[0];
1764                                 pp[1]    = ( pp1[1]-pp2[1] )*u + pp2[1];
1765                                 pp[2]    = ( pp1[2]-pp2[2] )*u + pp2[2];
1766                                 ppC[0] = pp[0] - center;
1767                                 ppC[1] = pp[1] - center;
1768                                 ppC[2] = pp[2] ;
1769                                 dist = sqrt( ppC[0]*ppC[0] + ppC[1]*ppC[1] + ppC[2]*ppC[2] );
1770                                 if (dist<distMin)
1771                                 {
1772                                         distMin=dist;
1773                                         ppB[0] = pp[0];
1774                                         ppB[1] = pp[1];
1775                                         ppB[2] = pp[2];
1776                                 }
1777                         }
1778
1779                 }// for
1780         } else {
1781                         _pts->SetPoint(0, 0 , 0 , 0);
1782                         _pts->SetPoint(1, 0 , 0 , 0);
1783         } // if
1784
1785 //EED 27 sep 2006
1786         ppB[0]=ppB[0]*_spc[0];
1787         ppB[1]=ppB[1]*_spc[1];
1788
1789         _pts->SetPoint( 0, ppB[0]   , ppB[1]+1 , 1 );
1790         _pts->SetPoint( 1, ppB[0]   , ppB[1]-1 , 1 );
1791         _pts->SetPoint( 2, ppB[0]   , ppB[1]   , 1 );
1792         _pts->SetPoint( 3, ppB[0]-1 , ppB[1]   , 1 );
1793         _pts->SetPoint( 4, ppB[0]+1 , ppB[1]   , 1 );
1794
1795
1796         for( i = 5; i < nps; i++ )
1797         {
1798                 _pts->SetPoint( i, ppB[0] , ppB[1] , 1 );
1799         }
1800
1801 }
1802
1803 //---------------------------------------------------------------------------
1804 bool manualViewPerpPlaneContour::ifTouchContour( int x, int y, int z)
1805 {
1806         bool ok=false;
1807         vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)( this->GetWxVtkBaseView() );
1808         double X=x;
1809         double Y=y;
1810         double Z=z;
1811         vtkplane2Dview->TransfromeCoordScreenToWorld(X,Y,Z);
1812         double ppA[3];
1813         _pts->GetPoint(0, ppA);
1814         if (sqrt( (ppA[0]-X)*(ppA[0]-X) + (ppA[1]-Y)*(ppA[1]-Y) ) <=2)
1815         {
1816                 ok = true;
1817         }
1818         return ok;
1819 }
1820
1821
1822 //---------------------------------------------------------------------------
1823 //---------------------------------------------------------------------------
1824 //---------------------------------------------------------------------------
1825 vtkInteractorStyleMPRView::vtkInteractorStyleMPRView()
1826 {
1827         _stateMoveAxisX = false;
1828         _stateMoveAxisY = false;
1829         _stateMoveAxisZ = false;
1830 }
1831 //---------------------------------------------------------------------------
1832 vtkInteractorStyleMPRView::~vtkInteractorStyleMPRView()
1833 {
1834 }
1835
1836
1837 //---------------------------------------------------------------------------
1838 bool  vtkInteractorStyleMPRView::OnLeftDClick () // virtual
1839 {
1840         wxVtkMPR2DView *wxvtkmpr2Dview = (wxVtkMPR2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
1841         double x = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
1842         double y = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
1843         double z = 1;
1844         _vtkInteractorStyleBaseView->TransformCoordinate(x,y,z);
1845         wxvtkmpr2Dview->MoveX(x,y,z);
1846         wxvtkmpr2Dview->MoveY(x,y,z);
1847         wxvtkmpr2Dview->MoveZ(x,y,z);
1848         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
1849         wxvtkmpr2Dview->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
1850         wxCommandEvent newevent2(wxEVT_COMMAND_MENU_SELECTED,12122);  // Doble click
1851         wxvtkmpr2Dview->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent2);
1852
1853         return true;
1854 }
1855 //---------------------------------------------------------------------------
1856 bool  vtkInteractorStyleMPRView::OnLeftButtonDown ()
1857 {
1858         wxVtkMPR2DView *wxvtkmpr2Dview = (wxVtkMPR2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
1859         double x        = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
1860         double y        = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
1861         double z        = 1;
1862         //double xx     = x;  // JPRx
1863         //double yy     = y;  // JPRx
1864         _vtkInteractorStyleBaseView->TransformCoordinate(x,y,z);
1865
1866 /*EED Borrame
1867         if ((_xBack==xx) && (_yBack==yy))
1868         {
1869                 wxvtkmpr2Dview->MoveX(x,y,z);
1870                 wxvtkmpr2Dview->MoveY(x,y,z);
1871                 wxvtkmpr2Dview->MoveZ(x,y,z);
1872                 wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
1873                 wxvtkmpr2Dview->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
1874                 wxCommandEvent newevent2(wxEVT_COMMAND_MENU_SELECTED,12122);  // Doble click
1875                 wxvtkmpr2Dview->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent2);
1876         }
1877
1878         _xBack=xx;
1879         _yBack=yy;
1880 */
1881
1882         _stateMoveAxisX = wxvtkmpr2Dview->IfMouseTouchX(x,y,z);
1883         _stateMoveAxisY = wxvtkmpr2Dview->IfMouseTouchY(x,y,z);
1884         _stateMoveAxisZ = wxvtkmpr2Dview->IfMouseTouchZ(x,y,z);
1885
1886         return true;
1887 }
1888 //---------------------------------------------------------------------------
1889 bool  vtkInteractorStyleMPRView::OnLeftButtonUp ()
1890 {
1891         if (_stateMoveAxisX==true)
1892         {
1893                 _stateMoveAxisX=false;
1894         }
1895         if (_stateMoveAxisY==true)
1896         {
1897                 _stateMoveAxisY=false;
1898         }
1899         if (_stateMoveAxisZ==true)
1900         {
1901                 _stateMoveAxisZ=false;
1902         }
1903         return true;
1904 }
1905 //---------------------------------------------------------------------------
1906 bool  vtkInteractorStyleMPRView::OnMouseMove ()
1907 {
1908         double x = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
1909         double y = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
1910
1911         double z=1;
1912         _vtkInteractorStyleBaseView->TransformCoordinate(x,y,z);
1913         wxVtkMPR2DView *wxvtkmpr2Dview = (wxVtkMPR2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
1914 //      wxvtkmpr2Dview->TransfromeCoordViewWorld(x,y,z);
1915
1916         wxvtkmpr2Dview->ChangeAxisColor(x,y,z);
1917
1918         if ((_stateMoveAxisX==true) || (_stateMoveAxisY==true)  || (_stateMoveAxisZ==true) )
1919         {
1920                 if (_stateMoveAxisX==true)
1921                 {
1922                         wxvtkmpr2Dview-> MoveX(x,y,z);
1923                 }
1924                 if (_stateMoveAxisY==true)
1925                 {
1926                         wxvtkmpr2Dview->MoveY(x,y,z);
1927                 }
1928                 if (_stateMoveAxisZ==true)
1929                 {
1930                         wxvtkmpr2Dview->MoveZ(x,y,z);
1931                 }
1932
1933                 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
1934         }
1935         return true;
1936 }
1937 //-------------------------------------------------------------------
1938 //-------------------------------------------------------------------
1939 //-------------------------------------------------------------------
1940 wxVtkMPR2DView::wxVtkMPR2DView( wxWindow *parent, int direction)
1941  :wxVtk2DBaseView(parent)
1942 {
1943         _backX                  = -99999;
1944         _backY                  = -99999;
1945         _backZ                  = -99999;
1946         _direction              = direction;
1947         _ptsA                   = NULL;
1948         _lineAActor             = NULL;
1949         _lineAMapper    = NULL;
1950         _pdA                    = NULL;
1951         _ptsB                   = NULL;
1952         _lineBActor             = NULL;
1953         _lineBMapper    = NULL;
1954         _pdB                    = NULL;
1955 }
1956
1957 //-------------------------------------------------------------------
1958 wxVtkMPR2DView::~wxVtkMPR2DView()
1959 {
1960         if (_ptsA!=NULL)        { _ptsA         -> Delete(); }
1961         if (_lineAActor!=NULL)  { _lineAActor   -> Delete(); }
1962         if (_lineAMapper!=NULL) { _lineAMapper  -> Delete(); }
1963         if (_pdA!=NULL)         { _pdA          -> Delete(); }
1964         if (_ptsB!=NULL)        { _ptsB         -> Delete(); }
1965         if (_lineBActor!=NULL)  { _lineBActor   -> Delete(); }
1966         if (_lineBMapper!=NULL) { _lineBMapper  -> Delete(); }
1967         if (_pdB!=NULL)         { _pdB          -> Delete(); }
1968 }
1969 //-------------------------------------------------------------------
1970 vtkMPRBaseData *wxVtkMPR2DView::GetVtkmprbasedata()
1971 {
1972         return (vtkMPRBaseData*)GetVtkBaseData();
1973 }
1974 //-------------------------------------------------------------------
1975 void wxVtkMPR2DView::Configure(){
1976         wxVtk2DBaseView::Configure();
1977
1978         _interactorstylemprview = new vtkInteractorStyleMPRView();
1979         GetInteractorStyleBaseView()->AddInteractorStyleMaracas( _interactorstylemprview );
1980
1981         int x1,x2,y1,y2,z1,z2;
1982         GetVtkmprbasedata()     -> GetDimensionExtention(&x1,&x2,&y1,&y2,&z1,&z2);
1983
1984         double spc[3];
1985         vtkImageData* img =  GetVtkmprbasedata()->GetImageData();
1986         if(img!=NULL){
1987                 img->GetSpacing(spc);
1988                 x1 = (int)(x1*spc[0]);
1989                 y1 = (int)(y1*spc[1]);
1990                 z1 = (int)(z1*spc[2]);
1991
1992                 x2 = (int)(x2*spc[0]);
1993                 y2 = (int)(y2*spc[1]);
1994                 z2 = (int)(z2*spc[2]);
1995
1996                 _visibleAxis = true;
1997
1998         // Axe A
1999                 _ptsA = vtkPoints::New();
2000                 _ptsA->SetNumberOfPoints(2);
2001                 _ptsA->SetPoint(0, -1000        , -1000 , -1000 );
2002                 _ptsA->SetPoint(1,  1000        ,  1000 ,  1000 );
2003                 vtkCellArray *linesA;
2004                 linesA = vtkCellArray::New();
2005                 linesA->InsertNextCell(2);
2006                 linesA->InsertCellPoint(0);
2007                 linesA->InsertCellPoint(1);
2008                 _pdA = vtkPolyData::New();
2009                 _pdA->SetPoints( _ptsA );
2010                 _pdA->SetLines( linesA );
2011                 linesA->Delete();  //do not delete lines ??
2012                 _lineAActor                                             =       vtkActor::New();
2013                 _lineAMapper                                    =       vtkPolyDataMapper::New();
2014                 _lineAMapper->SetInput(_pdA);
2015                 _lineAMapper->ImmediateModeRenderingOn();
2016                 _lineAActor->SetMapper(_lineAMapper);
2017 //              _lineAActor->GetProperty()->BackfaceCullingOn();
2018                 _lineAActor->GetProperty()->SetDiffuseColor(1,0,0);
2019                 _lineAActor->GetProperty()->SetLineWidth(2);
2020                 _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineAActor );
2021
2022         // Axe B
2023                 _ptsB = vtkPoints::New();
2024                 _ptsB->SetNumberOfPoints(2);
2025                 _ptsB->SetPoint(0, -1000        , -1000 , -1000 );
2026                 _ptsB->SetPoint(1,  1000        ,  1000 ,  1000 );
2027                 vtkCellArray *linesB;
2028                 linesB = vtkCellArray::New();
2029                 linesB->InsertNextCell(2);
2030                 linesB->InsertCellPoint(0);
2031                 linesB->InsertCellPoint(1);
2032                 _pdB = vtkPolyData::New();
2033                 _pdB->SetPoints( _ptsB );
2034                 _pdB->SetLines( linesB );
2035                 linesB->Delete();  //do not delete lines ??
2036                 _lineBActor                                             =       vtkActor::New();
2037                 _lineBMapper                                    =       vtkPolyDataMapper::New();
2038                 _lineBMapper->SetInput(_pdB);
2039                 _lineBMapper->ImmediateModeRenderingOn();
2040                 _lineBActor->SetMapper(_lineBMapper);
2041 //              _lineBActor->GetProperty()->BackfaceCullingOn();
2042                 _lineBActor->GetProperty()->SetDiffuseColor(1,0,0);
2043                 _lineBActor->GetProperty()->SetLineWidth(2);
2044                 _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineBActor );
2045
2046
2047                 vtkCamera *camera =_imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->GetActiveCamera();
2048
2049 //EED 17Avril2009
2050 /*
2051                 if (_direction==0) {
2052                         camera->SetViewUp               (   0   ,    -1         ,     0         );
2053                         camera->SetPosition             ( -10000,(y1+y2)/2      , (z1+z2)/2     );
2054                         camera->SetFocalPoint   (   0   , (y1+y2)/2     , (z1+z2)/2     );
2055                         camera->SetParallelScale( (z2-z1)/3.0 );
2056                 }
2057
2058                 if (_direction==1) {
2059                         camera->SetViewUp               (       0               ,       0       ,       -1              );
2060                         camera->SetPosition             ((x1+x2)/2      , 10000 , (z1+z2)/2     );
2061                         camera->SetFocalPoint   ((x1+x2)/2      ,   0   , (z1+z2)/2     );
2062                         camera->SetParallelScale( (x2-x1)/3.0 );
2063                 }
2064
2065                 if (_direction==2) {
2066                         camera->SetViewUp               (       0               ,       -1              ,       0       );
2067                         camera->SetPosition             ((x1+x2)/2      , (y1+y2)/2     , -10000);
2068                         camera->SetFocalPoint   ((x1+x2)/2      , (y1+y2)/2     ,       0       );
2069                         camera->SetParallelScale( (x2-x1)/3.0 );
2070                 }
2071  */
2072
2073                 if (_direction==0) {
2074                         camera->SetViewUp               (   0   ,     1         ,     0         );
2075                         camera->SetPosition             (  10000,(y1+y2)/2      , (z1+z2)/2     );
2076                         camera->SetFocalPoint   (   0   , (y1+y2)/2     , (z1+z2)/2     );
2077                         camera->SetParallelScale( (z2-z1)/3.0 );
2078                 }
2079
2080                 if (_direction==1) {
2081                         camera->SetViewUp               (       0               ,       0       ,       -1              );
2082                         camera->SetPosition             ((x1+x2)/2      , 10000 , (z1+z2)/2     );
2083                         camera->SetFocalPoint   ((x1+x2)/2      ,   0   , (z1+z2)/2     );
2084                         camera->SetParallelScale( (x2-x1)/3.0 );
2085                 }
2086
2087                 if (_direction==2) {
2088                         camera->SetViewUp               (       0               ,       1               ,       0       );
2089                         camera->SetPosition             ((x1+x2)/2      , (y1+y2)/2     ,  10000);
2090                         camera->SetFocalPoint   ((x1+x2)/2      , (y1+y2)/2     ,       0       );
2091                         camera->SetParallelScale( (x2-x1)/3.0 );
2092                 }
2093
2094
2095
2096         }
2097
2098 //      _imageViewer2XYZ->GetVtkImageViewer2()->SetColorWindow (160);
2099 //      _imageViewer2XYZ->GetVtkImageViewer2()->SetColorLevel (800);
2100
2101 }
2102
2103 void wxVtkMPR2DView::SetVisibleAxis(bool ok)
2104 {
2105         if (ok!=_visibleAxis)
2106         {
2107                 _visibleAxis=ok;
2108                 if (_visibleAxis==true)
2109                 {
2110                         _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineAActor );
2111                         _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineBActor );
2112                 }
2113                 if (_visibleAxis==false)
2114                 {
2115                         _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->RemoveActor( _lineAActor );
2116                         _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->RemoveActor( _lineBActor );
2117                 }
2118
2119         }
2120 }
2121
2122 //-------------------------------------------------------------------
2123 void wxVtkMPR2DView::Refresh()
2124 {
2125         //wxVtk2DBaseView::Refresh();
2126
2127
2128         //vtkImageViewer2 *IV2=_imageViewer2XYZ->GetVtkImageViewer2(); // JPRx
2129         //vtkCamera *camera = IV2->GetRenderer()->GetActiveCamera(); // JPRx
2130
2131
2132
2133         int x1,x2,y1,y2,z1,z2;
2134         GetVtkmprbasedata()->GetDimensionExtention(&x1,&x2,&y1,&y2,&z1,&z2);
2135         double spc[3];
2136
2137         vtkImageData* img = GetVtkmprbasedata()->GetImageData();
2138         if(img!=NULL){
2139                 img->GetSpacing(spc);
2140                 x1 =  (int)(x1*spc[0]);
2141                 y1 =  (int)(y1*spc[1]);
2142                 z1 =  (int)(z1*spc[2]);
2143
2144                 x2 =  (int)(x2*spc[0]);
2145                 y2 =  (int)(y2*spc[1]);
2146                 z2 =  (int)(z2*spc[2]);
2147
2148                 int x = (int)(GetVtkmprbasedata()->GetX());
2149                 int y = (int)(GetVtkmprbasedata()->GetY());
2150                 int z = (int)(GetVtkmprbasedata()->GetZ());
2151
2152                 x =  (int)(x*spc[0]);
2153                 y =  (int)(y*spc[1]);
2154                 z =  (int)(z*spc[2]);
2155
2156
2157
2158                 if ((x!=_backX) || (y!=_backY) || (z!=_backZ)) {
2159
2160                         if (_direction==0) {
2161                                 _imageViewer2XYZ->SetXSlice( (int)(GetVtkmprbasedata()->GetX()) );
2162                                 _ptsA->SetPoint(0, -x2, y1  , z );
2163                                 _ptsA->SetPoint(1, -x2, y2  , z );
2164                                 _ptsB->SetPoint(0, -x2, y   , z1);
2165                                 _ptsB->SetPoint(1, -x2, y   , z2);
2166                         }
2167                         if (_direction==1) {
2168                                 _imageViewer2XYZ->SetYSlice( (int)(GetVtkmprbasedata()->GetY()) );
2169                                 _ptsA->SetPoint(0, x1 , y2 , z );
2170                                 _ptsA->SetPoint(1, x2 , y2 , z );
2171                                 _ptsB->SetPoint(0, x  , y2 , z1);
2172                                 _ptsB->SetPoint(1, x  , y2 , z2);
2173                         }
2174                         if (_direction==2) {
2175                                 _imageViewer2XYZ->SetZSlice( (int)(GetVtkmprbasedata()->GetZ()) );
2176                                 _imageViewer2XYZ->SetZSlice( (int)(GetVtkmprbasedata()->GetZ()) );
2177                         //      _ptsA->SetPoint(0, x1 , y , -z2 );
2178                         //      _ptsA->SetPoint(1, x2 , y , -z2 );
2179                         //      _ptsB->SetPoint(0, x  , y1, -z2 );
2180                         //      _ptsB->SetPoint(1, x  , y2, -z2 );
2181
2182                                 _ptsA->SetPoint(0, x1 , y , z2 );
2183                                 _ptsA->SetPoint(1, x2 , y , z2 );
2184                                 _ptsB->SetPoint(0, x  , y1, z2 );
2185                                 _ptsB->SetPoint(1, x  , y2, z2 );
2186                         }
2187                         _backX=x;
2188                         _backY=y;
2189                         _backZ=z;
2190                 }
2191                 wxVtkBaseView::Refresh();
2192         }
2193 }
2194 //-------------------------------------------------------------------
2195 int wxVtkMPR2DView::GetActualSlice()   // virtual
2196 {
2197         int result;
2198         if (_direction==0)
2199         {
2200                 result = (int)(GetVtkmprbasedata()->GetX());
2201         }
2202         if (_direction==1)
2203         {
2204                 result = (int)(GetVtkmprbasedata()->GetY());
2205         }
2206         if (_direction==2)
2207         {
2208                 result = (int)(GetVtkmprbasedata()->GetZ());
2209         }
2210         return result;
2211 }
2212 //-------------------------------------------------------------------
2213 void wxVtkMPR2DView::SetActualSlice(int slice)   // virtual
2214 {
2215         if (_direction==0)
2216         {
2217                 GetVtkmprbasedata()->SetX(slice);
2218         }
2219         if (_direction==1)
2220         {
2221                 GetVtkmprbasedata()->SetY(slice);
2222         }
2223         if (_direction==2)
2224         {
2225                 GetVtkmprbasedata()->SetZ(slice);
2226         }
2227 }
2228 //-------------------------------------------------------------------
2229 bool wxVtkMPR2DView::IfMouseTouchX(double x, double y, double z)
2230 {
2231         double delta=5;
2232         bool result=false;
2233         if (_direction==0)
2234         {
2235         }
2236         if (_direction==1)
2237         {
2238                 if (( x<GetVtkmprbasedata()->GetX()+delta ) && ( x>GetVtkmprbasedata()->GetX()-delta ))
2239                 {
2240                         result = true;
2241                 }
2242         }
2243         if (_direction==2)
2244         {
2245                 if (( x<GetVtkmprbasedata()->GetX()+delta ) && ( x>GetVtkmprbasedata()->GetX()-delta ))
2246                 {
2247                         result = true;
2248                 }
2249         }
2250         return result;
2251 }
2252 //-------------------------------------------------------------------
2253 bool wxVtkMPR2DView::IfMouseTouchY(double x, double y, double z)
2254 {
2255         double delta=5;
2256         bool result=false;
2257         if (_direction==0)
2258         {
2259                 if (( y<GetVtkmprbasedata()->GetY()+delta ) && ( y>GetVtkmprbasedata()->GetY()-delta ))
2260                 {
2261                         result = true;
2262                 }
2263         }
2264         if (_direction==1)
2265         {
2266         }
2267         if (_direction==2)
2268         {
2269                 if (( y<GetVtkmprbasedata()->GetY()+delta ) && ( y>GetVtkmprbasedata()->GetY()-delta ))
2270                 {
2271                         result = true;
2272                 }
2273         }
2274         return result;
2275 }
2276 //-------------------------------------------------------------------
2277 bool wxVtkMPR2DView::IfMouseTouchZ(double x, double y, double z)
2278 {
2279         double delta=5;
2280         bool result=false;
2281         if (_direction==0)
2282         {
2283                 if (( z<GetVtkmprbasedata()->GetZ()+delta ) && ( z>GetVtkmprbasedata()->GetZ()-delta ))
2284                 {
2285                         result = true;
2286                 }
2287         }
2288         if (_direction==1)
2289         {
2290                 if (( z<GetVtkmprbasedata()->GetZ()+delta ) && ( z>GetVtkmprbasedata()->GetZ()-delta ))
2291                 {
2292                         result = true;
2293                 }
2294         }
2295         if (_direction==2)
2296         {
2297         }
2298         return result;
2299 }
2300 //-------------------------------------------------------------------
2301 void wxVtkMPR2DView::MoveX(double x, double y, double z)
2302 {
2303         if (_direction==0)
2304         {
2305         }
2306         if (_direction==1)
2307         {
2308                 GetVtkmprbasedata()->SetX(x);
2309         }
2310         if (_direction==2)
2311         {
2312                 GetVtkmprbasedata()->SetX(x);
2313         }
2314 }
2315 //-------------------------------------------------------------------
2316 void wxVtkMPR2DView::MoveY(double x, double y, double z)
2317 {
2318         if (_direction==0)
2319         {
2320                 GetVtkmprbasedata()->SetY(y);
2321         }
2322         if (_direction==1)
2323         {
2324         }
2325         if (_direction==2)
2326         {
2327                 GetVtkmprbasedata()->SetY(y);
2328         }
2329 }
2330 //-------------------------------------------------------------------
2331 void wxVtkMPR2DView::MoveZ(double x, double y, double z)
2332 {
2333         if (_direction==0)
2334         {
2335                 GetVtkmprbasedata()->SetZ(z);
2336         }
2337         if (_direction==1)
2338         {
2339                 GetVtkmprbasedata()->SetZ(z);
2340         }
2341         if (_direction==2)
2342         {
2343         }
2344 }
2345 //-------------------------------------------------------------------
2346 void wxVtkMPR2DView::ChangeAxisColor(double x, double y, double z)
2347 {
2348         double c1r=1,c1g=1,c1b=0;
2349         double c2r=1,c2g=0,c2b=0;
2350
2351         if (_direction==0)
2352         {
2353                 if (IfMouseTouchY(x,y,z)==true)
2354                 {
2355                         _lineBActor->GetProperty()->SetDiffuseColor(c1r,c1g,c1b);
2356                 } else {
2357                         _lineBActor->GetProperty()->SetDiffuseColor(c2r,c2g,c2b);
2358                 }
2359                 if (IfMouseTouchZ(x,y,z)==true)
2360                 {
2361                         _lineAActor->GetProperty()->SetDiffuseColor(c1r,c1g,c1b);
2362                 } else {
2363                         _lineAActor->GetProperty()->SetDiffuseColor(c2r,c2g,c2b);
2364                 }
2365         }
2366
2367         if (_direction==1)
2368         {
2369                 if (IfMouseTouchX(x,y,z)==true)
2370                 {
2371                         _lineBActor->GetProperty()->SetDiffuseColor(c1r,c1g,c1b);
2372                 } else {
2373                         _lineBActor->GetProperty()->SetDiffuseColor(c2r,c2g,c2b);
2374                 }
2375                 if (IfMouseTouchZ(x,y,z)==true)
2376                 {
2377                         _lineAActor->GetProperty()->SetDiffuseColor(c1r,c1g,c1b);
2378                 } else {
2379                         _lineAActor->GetProperty()->SetDiffuseColor(c2r,c2g,c2b);
2380                 }
2381         }
2382
2383         if (_direction==2)
2384         {
2385                 if (IfMouseTouchX(x,y,z)==true)
2386                 {
2387                         _lineBActor->GetProperty()->SetDiffuseColor(c1r,c1g,c1b);
2388                 } else {
2389                         _lineBActor->GetProperty()->SetDiffuseColor(c2r,c2g,c2b);
2390                 }
2391                 if (IfMouseTouchY(x,y,z)==true)
2392                 {
2393                         _lineAActor->GetProperty()->SetDiffuseColor(c1r,c1g,c1b);
2394                 } else {
2395                         _lineAActor->GetProperty()->SetDiffuseColor(c2r,c2g,c2b);
2396                 }
2397         }
2398         Refresh();
2399 }
2400 //-------------------------------------------------------------------
2401 void wxVtkMPR2DView::TransfromeCoordViewWorld(double &X, double &Y, double &Z, int type) // virtual
2402 {
2403         wxVtkBaseView::TransfromeCoordScreenToWorld(X,Y,Z,_direction);
2404
2405         if (_direction==0)
2406         {
2407                 X = ((vtkMPRBaseData*)GetVtkBaseData())->GetX();
2408         }
2409         if (_direction==1)
2410         {
2411                 Y = ((vtkMPRBaseData*)GetVtkBaseData())->GetY();
2412         }
2413         if (_direction==2)
2414         {
2415                 Z = ((vtkMPRBaseData*)GetVtkBaseData())->GetZ();
2416         }
2417 }
2418 //-------------------------------------------------------------------
2419 //-------------------------------------------------------------------
2420 //-------------------------------------------------------------------
2421 //void boxVolumeObserver::Execute(vtkObject *wdg, unsigned long eventId, void* calldata) {  // virtual
2422 //      if (eventId==vtkCommand::StartInteractionEvent){
2423 //              _renWin->SetDesiredUpdateRate(10);
2424 //      }
2425 //      if (eventId==vtkCommand::InteractionEvent){
2426 //              _renWin->SetDesiredUpdateRate(0.001);
2427 //      }
2428 //      if (eventId==vtkCommand::EndInteractionEvent){
2429 //              vtkPlanes *planes = vtkPlanes::New();
2430 //              vtkBoxWidget *boxwidget = reinterpret_cast<vtkBoxWidget*>(wdg);
2431 //              boxwidget->GetPlanes(planes);
2432 //              _volumeMapper->SetClippingPlanes(planes);
2433 //              planes -> Delete();
2434 //      }
2435 //}
2436
2437 //-------------------------------------------------------------------
2438 //void boxVolumeObserver::SetRenWin( vtkRenderWindow *renWin ){
2439 //      _renWin = renWin;
2440 //}
2441 //-------------------------------------------------------------------
2442 //void boxVolumeObserver::SetVolumeMapper(vtkVolumeRayCastMapper *volumeMapper){
2443 //      _volumeMapper = volumeMapper;
2444 //}
2445
2446
2447
2448 //-------------------------------------------------------------------
2449 //-------------------------------------------------------------------
2450 //-------------------------------------------------------------------
2451 // EED 9 fev 2007
2452 void boxSurfaceObserver::Execute(vtkObject *wdg, unsigned long eventId, void* calldata) {  // virtual
2453         vtkBoxWidget *boxwidget = reinterpret_cast<vtkBoxWidget*>(wdg);
2454         boxwidget->GetPlanes(_planes);
2455
2456         if ( _vtkVolumeRayCastMapper != NULL )
2457         {
2458                 _vtkVolumeRayCastMapper->RemoveAllClippingPlanes();
2459 //              vtkPlanes *planes = vtkPlanes::New();
2460 //              boxwidget->GetPlanes(planes);
2461 //              _vtkVolumeRayCastMapper->SetClippingPlanes(planes);
2462                 _vtkVolumeRayCastMapper->SetClippingPlanes(_planes);
2463         }
2464
2465 //      _actor->VisibilityOn();
2466
2467 }
2468 //-------------------------------------------------------------------
2469 void boxSurfaceObserver::SetPlanes(vtkPlanes *planes){
2470         _planes = planes;
2471 }
2472 //-------------------------------------------------------------------
2473 void boxSurfaceObserver::SetActor(vtkProp *actor){
2474         _actor = actor;
2475 }
2476
2477 //-------------------------------------------------------------------
2478 void boxSurfaceObserver::SetvtkVolumeRayCastMapper(vtkVolumeRayCastMapper *vtkvolumeraycastmapper)
2479 {
2480         _vtkVolumeRayCastMapper = vtkvolumeraycastmapper;
2481 }
2482
2483
2484 //-------------------------------------------------------------------
2485 //-------------------------------------------------------------------
2486 //-------------------------------------------------------------------
2487
2488 wxVtkMPR3DViewCntrlPanel::wxVtkMPR3DViewCntrlPanel(wxWindow *parent, wxVtkMPR3DView *wxvtkmpr3Dview )
2489 : wxPanel(parent, -1)
2490 {
2491
2492         wxPanel *panel  = this;
2493         _wxvtkmpr3Dview = wxvtkmpr3Dview;
2494
2495         int maxX = _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetMaxPositionX();
2496         int maxY = _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetMaxPositionY();
2497         int maxZ = _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetMaxPositionZ();
2498         wxCheckBox              *ckBoxX                 = new wxCheckBox(panel,-1,_T("X           "));
2499                                         _positionX              = new wxSlider(panel,-1,maxX/2,0,maxX, wxDefaultPosition, wxSize(150,40), wxSL_HORIZONTAL | wxSL_LABELS);
2500         wxCheckBox              *ckBoxY                 = new wxCheckBox(panel,-1,_T("Y           "));
2501                                         _positionY              = new wxSlider(panel,-1,maxY/2,0,maxY, wxDefaultPosition, wxSize(150,40), wxSL_HORIZONTAL | wxSL_LABELS);
2502         wxCheckBox              *ckBoxZ                 = new wxCheckBox(panel,-1,_T("Z           "));
2503                                         _positionZ              = new wxSlider(panel,-1,maxZ/2,0,maxZ, wxDefaultPosition, wxSize(150,40), wxSL_HORIZONTAL | wxSL_LABELS);
2504         wxButton                *btnColorTable  = new wxButton (panel, -1, _T("Edit Color Table") );
2505
2506         _ckBoxXYZ                       = new wxCheckBox(panel,-1,_T("XYZ                  "));
2507         _ckBoxPlane                     = new wxCheckBox(panel,-1,_T("Plane"));
2508
2509         ckBoxX->SetValue(false);
2510         ckBoxY->SetValue(false);
2511         ckBoxZ->SetValue(false);
2512         _ckBoxXYZ->SetValue(false);
2513         _ckBoxPlane->SetValue(false);
2514
2515         _positionX->SetSize(400,20);
2516         _positionY->SetSize(400,20);
2517         _positionZ->SetSize(400,20);
2518
2519         Connect(ckBoxX->GetId()                 , wxEVT_COMMAND_CHECKBOX_CLICKED          , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisX   );
2520         Connect(_positionX->GetId()             , wxEVT_COMMAND_SLIDER_UPDATED            , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnPositionX              );
2521         Connect(ckBoxY->GetId()                 , wxEVT_COMMAND_CHECKBOX_CLICKED          , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisY   );
2522         Connect(_positionY->GetId()             , wxEVT_COMMAND_SLIDER_UPDATED            , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnPositionY              );
2523         Connect(ckBoxZ->GetId()                 , wxEVT_COMMAND_CHECKBOX_CLICKED          , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisZ   );
2524         Connect(_positionZ->GetId()             , wxEVT_COMMAND_SLIDER_UPDATED            , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnPositionZ              );
2525         Connect(btnColorTable->GetId()  , wxEVT_COMMAND_BUTTON_CLICKED            , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnEditColorTable );
2526
2527         Connect(_ckBoxXYZ->GetId()  , wxEVT_COMMAND_CHECKBOX_CLICKED      , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisXYZ );
2528         Connect(_ckBoxPlane->GetId(), wxEVT_COMMAND_CHECKBOX_CLICKED      , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisiblePlane   );
2529
2530
2531         wxFlexGridSizer *sizer   = new wxFlexGridSizer(1);
2532 //      wxBoxSizer *sizer        = new wxBoxSizer(wxVERTICAL);
2533
2534 //      wxBoxSizer *sizerH4 = new wxBoxSizer(wxHORIZONTAL);
2535         wxFlexGridSizer *sizerH4 = new wxFlexGridSizer(10);
2536         wxFlexGridSizer *sizerH5 = new wxFlexGridSizer(10);
2537
2538
2539
2540 //EED 28 sep 2006
2541 //      wxFlexGridSizer *sizerH6 = new wxFlexGridSizer(10);
2542 //      wxFlexGridSizer *sizerH7 = new wxFlexGridSizer(10);
2543
2544 //      sizerH4->Add( ckBoxX            , 1, wxALL|wxEXPAND, 0);
2545 //      sizerH4->Add( new wxStaticText(panel, -1,"  ")                  , 1, wxALL|wxEXPAND, 0);
2546 //      sizerH4->Add( _positionX        , 1, wxALL|wxEXPAND, 0);
2547
2548 //      sizerH5->Add( ckBoxY            , 1, wxALL|wxEXPAND, 0);
2549 //      sizerH5->Add( new wxStaticText(panel, -1,"  ")                  , 1, wxALL|wxEXPAND, 0);
2550 //      sizerH5->Add( _positionY        , 1, wxALL|wxEXPAND, 0);
2551
2552 //      sizerH6->Add( ckBoxZ            , 1, wxALL|wxEXPAND, 0);
2553 //      sizerH6->Add( new wxStaticText(panel, -1,"  ")                  , 1, wxALL|wxEXPAND, 0);
2554 //      sizerH6->Add( _positionZ        , 1, wxALL|wxEXPAND, 0);
2555
2556 //      sizerH7->Add( _ckBoxXYZ         , 1, wxALL|wxEXPAND, 0);
2557 //      sizerH7->Add( _ckBoxPlane       , 1, wxALL|wxEXPAND, 0);
2558
2559 //      sizer->Add( sizerH4                     , 1, wxALL|wxEXPAND, 2);
2560 //      sizer->Add( sizerH5                     , 1, wxALL|wxEXPAND, 2);
2561 //      sizer->Add( sizerH6                     , 1, wxALL|wxEXPAND, 2);
2562 //      sizer->Add( sizerH7                     , 1, wxALL|wxEXPAND, 2);
2563
2564         sizerH4->Add( _positionX                                                                ,1,wxGROW                                       , 0 );
2565         sizerH4->Add( ckBoxX                                                                    ,0,wxALIGN_CENTER_VERTICAL|wxSHAPED     , 0 );
2566         sizerH4->Add( _positionY                                                                ,1,wxGROW                                       , 0 );
2567         sizerH4->Add( ckBoxY                                                                    ,0,wxALIGN_CENTER_VERTICAL|wxSHAPED     , 0 );
2568         sizerH4->Add( _positionZ                                                                ,1,wxGROW                                       , 0 );
2569         sizerH4->Add( ckBoxZ                                                                    ,0,wxALIGN_CENTER_VERTICAL|wxSHAPED     , 0 );
2570         sizerH4->Add( btnColorTable                                                             ,0,wxALIGN_CENTER_VERTICAL|wxSHAPED     , 0 );
2571
2572         sizerH5->Add( _ckBoxXYZ                         ,  1, wxALL|wxEXPAND, 0);
2573         sizerH5->Add( _ckBoxPlane                       ,  1, wxALL|wxEXPAND, 0);
2574         sizerH5->Add( new wxStaticText(panel, -1,_T("      "))                  , 1, wxALL|wxEXPAND, 0);
2575 //      sizerH5->Add( ckBoxX                            ,  1, wxALL|wxEXPAND, 0);
2576 //      sizerH5->Add( ckBoxY                            ,  1, wxALL|wxEXPAND, 0);
2577 //      sizerH5->Add( ckBoxZ                            ,  1, wxALL|wxEXPAND, 0);
2578
2579         sizer->Add( sizerH4                                     ,  1, wxALL|wxGROW, 2);
2580         sizer->Add( sizerH5                                     ,  1, wxALL|wxEXPAND, 2);
2581
2582
2583         panel->SetSize(400,50);
2584         panel->SetAutoLayout(true);
2585         panel->SetSizer(sizer);
2586         panel->Layout();
2587
2588         panel->SetEventHandler((wxEvtHandler*)this);
2589
2590 }
2591 //-------------------------------------------------------------------
2592 wxVtkMPR3DViewCntrlPanel::~wxVtkMPR3DViewCntrlPanel()
2593 {
2594 }
2595 //-------------------------------------------------------------------
2596 void wxVtkMPR3DViewCntrlPanel::Refresh()
2597 {
2598 //      wxPanel::Refresh();
2599         _positionX->SetValue( (int)(_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetX( )) );
2600         _positionY->SetValue( (int)(_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetY( )) );
2601         _positionZ->SetValue( (int)(_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetZ( )) );
2602 }
2603 /*
2604 //-------------------------------------------------------------------
2605 int wxVtkMPR3DViewCntrlPanel::GetIdTissue()
2606 {
2607         int idTissue=-1;
2608         if (_surfA->GetValue()==true)
2609         {
2610                 idTissue=0;
2611         }
2612         if (_surfB->GetValue()==true)
2613         {
2614                 idTissue=1;
2615         }
2616         if (_surfC->GetValue()==true)
2617         {
2618                 idTissue=2;
2619         }
2620         if (_surfD->GetValue()==true)
2621         {
2622                 idTissue=3;
2623         }
2624
2625         return idTissue;
2626 }
2627 */
2628
2629 //-------------------------------------------------------------------
2630 void wxVtkMPR3DViewCntrlPanel::OnEditColorTable(wxCommandEvent& event)
2631 {
2632
2633         vtkColorTransferFunction *ctfun                 = this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetvtkColorTransferFunction();
2634         std::vector<double> *ctfunVectorPoint   = this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetctFunVectorPoint();
2635         std::vector<double> *ctfunVectorRed             = this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetctFunVectorRed();
2636         std::vector<double> *ctfunVectorGreen   = this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetctFunVectorGreen();
2637         std::vector<double> *ctfunVectorBlue    =   this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetctFunVectorBlue();
2638
2639         //void *p=this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer(); // JPRx
2640
2641
2642         int i=0,xi,r,g,b;
2643
2644         vtkImageData *imagedata = this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
2645
2646         HistogramDialog* hDlg=new HistogramDialog(NULL,_T("Color table"),imagedata,2);
2647
2648
2649         hDlg->erasePointsTransferenceFunction();
2650         int ctfSize=ctfunVectorRed->size();
2651         if(ctfSize>0)
2652         {
2653 // MACHETE  OJO Eduardo
2654                 int i=0;
2655                         while(i<ctfSize)
2656                         {
2657                                 double gr       = (*ctfunVectorPoint)[i];
2658                                 double r        = (*ctfunVectorRed)[i];
2659                                 double g        = (*ctfunVectorGreen)[i];
2660                                 double b        = (*ctfunVectorBlue)[i];
2661
2662 hDlg->addColorPoint(gr,(int)(r*255),(int)(g*255),(int)(b*255));
2663                                 i++;
2664                         }
2665         }
2666
2667         //
2668         // when the user had changed the transference Function
2669         //
2670
2671         //setting variables if the user wants to do refresh
2672
2673         hDlg->setCTF(ctfun);
2674         hDlg->setMPR3Dview(_wxvtkmpr3Dview);
2675
2676         if(hDlg->ShowModal()== wxID_OK )
2677         {
2678
2679                 // -- vtkColorTransferFunction  --
2680                         ctfun->RemoveAllPoints ();
2681                         //clean colors
2682                         ctfunVectorPoint->clear();
2683                         ctfunVectorRed->clear();
2684                         ctfunVectorGreen->clear();
2685                         ctfunVectorBlue->clear();
2686
2687                         int nCTFpoints=hDlg->getSizeBarColor();
2688 // Machete .. Ojo Eduardo
2689                         i=0;
2690                         while(i<nCTFpoints)
2691                         {
2692                                 hDlg->getDataBarColorPoint(i,xi,r,g,b);
2693                                 /*
2694                                 if (i==0)
2695                                 {
2696                                         hDlg->getDataBarColorPoint(1,xi,r,g,b);
2697                                 }
2698                                 if (i==nCTFpoints)
2699                                 {
2700                                         hDlg->getDataBarColorPoint(i-1,xi,r,g,b);
2701                                 }
2702                                 */
2703                                 ctfun->AddRGBPoint(xi,r/255.0,g/255.0,b/255.0 );
2704                                 ctfunVectorPoint->push_back(xi);
2705                                 ctfunVectorRed->push_back(r/255.0);
2706                                 ctfunVectorGreen->push_back(g/255.0);
2707                                 ctfunVectorBlue->push_back(b/255.0);
2708                                 i++;
2709
2710                         }
2711
2712         }
2713
2714         else
2715         {
2716
2717                 if(hDlg->getRefreshed())
2718                 {
2719                         // -- vtkColorTransferFunction  --
2720                         ctfun->RemoveAllPoints ();
2721
2722                         int i=0;
2723                         int size=ctfunVectorPoint->size();
2724
2725                         for(i=0;i<size;i++)
2726                         {
2727                                 double grey2=(*ctfunVectorPoint)[i];
2728                                 double red =(*ctfunVectorRed)[i];
2729                                 double green =(*ctfunVectorGreen)[i];
2730                                 double blue = (*ctfunVectorBlue)[i];
2731                                 ctfun->AddRGBPoint(grey2,red,green,blue);
2732                         }
2733                  }
2734
2735         }
2736
2737  hDlg->Destroy();
2738 }
2739
2740
2741 //-------------------------------------------------------------------
2742 void wxVtkMPR3DViewCntrlPanel::OnVisibleAxisX(wxCommandEvent& event)
2743 {
2744         _wxvtkmpr3Dview->VisibleImageActor(0, event.IsChecked() );
2745         _wxvtkmpr3Dview->Refresh();
2746
2747         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
2748         _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
2749
2750 }
2751 //-------------------------------------------------------------------
2752 void wxVtkMPR3DViewCntrlPanel::OnVisibleAxisY(wxCommandEvent& event)
2753 {
2754         _wxvtkmpr3Dview->VisibleImageActor(1, event.IsChecked() );
2755         _wxvtkmpr3Dview->Refresh();
2756
2757         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
2758         _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
2759
2760 }
2761 //-------------------------------------------------------------------
2762 void wxVtkMPR3DViewCntrlPanel::OnVisibleAxisZ(wxCommandEvent& event)
2763 {
2764         _wxvtkmpr3Dview->VisibleImageActor(2, event.IsChecked() );
2765         _wxvtkmpr3Dview->Refresh();
2766
2767         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
2768         _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
2769 }
2770
2771 //-------------------------------------------------------------------
2772 void wxVtkMPR3DViewCntrlPanel::OnVisibleAxisXYZ(wxCommandEvent& event)
2773 {
2774         _wxvtkmpr3Dview->VisiblePointWidget(event.IsChecked());
2775 }
2776
2777 //-------------------------------------------------------------------
2778 void wxVtkMPR3DViewCntrlPanel::OnVisiblePlane(wxCommandEvent& event)
2779 {
2780         _wxvtkmpr3Dview->VisiblePlaneWidget(event.IsChecked());
2781 }
2782
2783
2784 //-------------------------------------------------------------------
2785 void wxVtkMPR3DViewCntrlPanel::OnPositionX(wxScrollEvent& event)
2786 {
2787         _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetX( _positionX->GetValue() );
2788         _wxvtkmpr3Dview->RefreshView();
2789         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
2790         _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
2791 }
2792 //-------------------------------------------------------------------
2793 void wxVtkMPR3DViewCntrlPanel::OnPositionY(wxScrollEvent& event)
2794 {
2795         _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetY( _positionY->GetValue() );
2796         _wxvtkmpr3Dview->RefreshView();
2797         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
2798         _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
2799 }
2800 //-------------------------------------------------------------------
2801 void wxVtkMPR3DViewCntrlPanel::OnPositionZ(wxScrollEvent& event)
2802 {
2803         _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetZ( _positionZ->GetValue() );
2804         _wxvtkmpr3Dview->RefreshView();
2805         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
2806         _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
2807 }
2808
2809
2810 //-------------------------------------------------------------------
2811 //-------------------------------------------------------------------
2812 //-------------------------------------------------------------------
2813
2814 wxVtkClipping3DViewCntrlPanel::wxVtkClipping3DViewCntrlPanel(wxWindow *parent, wxVtkClipping3DView *wxvtkclipping3Dview )
2815 : wxPanel(parent, -1)
2816 {
2817         wxPanel *panel  = this;
2818         _wxvtkclipping3Dview    = wxvtkclipping3Dview;
2819
2820 //EEDx2.6
2821 //      wxStaticText    *text1                  = new wxStaticText(panel, -1,_T("          "));
2822 //      wxStaticText    *text2                  = new wxStaticText(panel, -1,_T("  "));
2823
2824                                         _surfA                  = new wxRadioButton(panel,-1,_T("A"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
2825                                         _surfB                  = new wxRadioButton(panel,-1,_T("B"));
2826                                         _surfC                  = new wxRadioButton(panel,-1,_T("C"));
2827                                         _surfD                  = new wxRadioButton(panel,-1,_T("D"));
2828
2829         wxCheckBox              *ckVolum                = new wxCheckBox(panel,-1,_T("Vol"));
2830         wxCheckBox              *ckBoxSurface   = new wxCheckBox(panel,-1,_T("Surface Box"));
2831         wxCheckBox              *ckBoxVolume    = new wxCheckBox(panel,-1,_T("Volume Box"));
2832
2833                                         _color                  = new wxButton(panel,-1,_T(""));
2834                                         _visible                = new wxCheckBox(panel,-1,_T("Vis"));
2835                                         _opacity                = new wxSlider(panel,-1,50,0,100, wxDefaultPosition, wxSize(800,40), wxSL_HORIZONTAL | wxSL_LABELS);
2836
2837         wxStaticText    *isoValueTitle  = new wxStaticText(panel,-1,_T("isoValue"));
2838                                         _isoValue               = new wxSlider(panel,-1,2000,110,2000, wxDefaultPosition, wxSize(800,40), wxSL_HORIZONTAL  |  wxSL_AUTOTICKS | wxSL_LABELS);
2839
2840
2841                                         _wireFrameRep   = new wxRadioButton(panel,-1,_T("WireFrame"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
2842                                         _surfaceRep             = new wxRadioButton(panel,-1,_T("Surface"));
2843
2844
2845         double range[2];
2846         vtkImageData *vtkimagedata = wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
2847         vtkimagedata->GetScalarRange( range );
2848         _isoValue->SetRange( (int)(range[1]*0.1) , (int)(range[1]) );
2849         _isoValue->SetValue( (int)(wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetIsovalue(0)) );
2850
2851
2852         _isoValue->SetTickFreq(25,0);
2853
2854         _isoValueSpin   = new wxSlider(panel , -1,5,1,10,wxDefaultPosition , wxSize(25,45), wxSL_VERTICAL | wxSL_AUTOTICKS |wxSL_LEFT  );
2855         _isoValueSpin->SetRange(1,8);
2856         _isoValueSpin->SetValue(5);
2857         Connect(_isoValueSpin->GetId()  , wxEVT_COMMAND_SLIDER_UPDATED   , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnIsoValueSpin );
2858
2859         wxButton *btnSTL                                = new wxButton(panel,-1,_T("Create STL File"));
2860         wxButton *btnSaveRaw                    = new wxButton(panel,-1,_T("Save Raw Volume"));
2861
2862         wxButton *btnVolumeFunctions    = new wxButton(panel,-1,_T("Read Volume Functions"));
2863
2864
2865         Connect(btnSTL->GetId()                         , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnBtnCreateFileSTL    );
2866         Connect(btnSaveRaw->GetId()                     , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnBtnSaveRawVolume    );
2867         Connect(btnVolumeFunctions->GetId()     , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnBtnVolumeFunctions  );
2868
2869
2870         wxButton *btnMeshVTKLoad        = new wxButton(panel,-1,_T("Load Mesh"));
2871         Connect(btnMeshVTKLoad->GetId() , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnBtnMeshVTKLoad      );
2872
2873
2874 /*
2875         int maxX = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetMaxPositionX();
2876         int maxY = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetMaxPositionY();
2877         int maxZ = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetMaxPositionZ();
2878         wxCheckBox              *ckBoxX                 = new wxCheckBox(panel,-1,"X");
2879                                         _positionX              = new wxSlider(panel,-1,maxX/2,0,maxX, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS);
2880         wxCheckBox              *ckBoxY                 = new wxCheckBox(panel,-1,"Y");
2881                                         _positionY              = new wxSlider(panel,-1,maxY/2,0,maxY, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS);
2882         wxCheckBox              *ckBoxZ                 = new wxCheckBox(panel,-1,"Z");
2883                                         _positionZ              = new wxSlider(panel,-1,maxZ/2,0,maxZ, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS);
2884 */
2885
2886 //      ckVolum->Enable(false);
2887         ckBoxSurface->SetValue(false);
2888         ckBoxVolume->SetValue(false);
2889         _color->SetSize(40,20);
2890         _opacity->SetSize(370,20);
2891 //      ckBoxX->SetValue(true);
2892 //      ckBoxY->SetValue(true);
2893 //      ckBoxZ->SetValue(true);
2894         _surfA->SetValue(true);
2895         _wireFrameRep->SetValue(false);
2896         _surfaceRep->SetValue(true);
2897         _visible->SetValue(false);
2898 //      _positionX->SetSize(400,20);
2899 //      _positionY->SetSize(400,20);
2900 //      _positionZ->SetSize(400,20);
2901
2902         Connect(ckVolum->GetId()                , wxEVT_COMMAND_CHECKBOX_CLICKED          , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnVisibleVolume                             );
2903         Connect(ckBoxVolume->GetId()    , wxEVT_COMMAND_CHECKBOX_CLICKED          , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnVisibleBoxVolume                  );
2904
2905         Connect(_surfA->GetId()                 , wxEVT_COMMAND_RADIOBUTTON_SELECTED  , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnSurface                                       );
2906         Connect(_surfB->GetId()                 , wxEVT_COMMAND_RADIOBUTTON_SELECTED  , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnSurface                                       );
2907         Connect(_surfC->GetId()                 , wxEVT_COMMAND_RADIOBUTTON_SELECTED  , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnSurface                                       );
2908         Connect(_surfD->GetId()                 , wxEVT_COMMAND_RADIOBUTTON_SELECTED  , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnSurface                                       );
2909         Connect(ckBoxSurface->GetId()   , wxEVT_COMMAND_CHECKBOX_CLICKED          , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnVisibleBoxSurface                 );
2910
2911         Connect(_wireFrameRep->GetId()  , wxEVT_COMMAND_RADIOBUTTON_SELECTED  , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnRepresentationSurfaceWireFrame        );
2912         Connect(_surfaceRep->GetId()    , wxEVT_COMMAND_RADIOBUTTON_SELECTED  , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnRepresentationSurfaceWireFrame        );
2913
2914         Connect(_color->GetId()                 , wxEVT_COMMAND_BUTTON_CLICKED            , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnColor                                             );
2915         Connect(_visible->GetId()               , wxEVT_COMMAND_CHECKBOX_CLICKED          , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnVisibleSurface                    );
2916         Connect(_opacity->GetId()               , wxEVT_COMMAND_SLIDER_UPDATED            , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnOpacity                                   );
2917
2918 //EED 27Dic2007
2919 //      Connect(_isoValue->GetId()              , wxEVT_COMMAND_SLIDER_UPDATED            , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnIsoValue                                  );
2920         Connect(_isoValue->GetId()              , wxEVT_SCROLL_THUMBRELEASE               , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnIsoValue                                          );
2921
2922 /*
2923         Connect(ckBoxX->GetId()     , wxEVT_COMMAND_CHECKBOX_CLICKED      , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisX   );
2924         Connect(_positionX->GetId()     , wxEVT_COMMAND_SLIDER_UPDATED            , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnPositionX              );
2925         Connect(ckBoxY->GetId()     , wxEVT_COMMAND_CHECKBOX_CLICKED      , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisY   );
2926         Connect(_positionY->GetId()     , wxEVT_COMMAND_SLIDER_UPDATED            , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnPositionY              );
2927         Connect(ckBoxZ->GetId()     , wxEVT_COMMAND_CHECKBOX_CLICKED      , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisZ   );
2928         Connect(_positionZ->GetId()     , wxEVT_COMMAND_SLIDER_UPDATED            , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnPositionZ              );
2929 */
2930
2931         wxFlexGridSizer *sizer   = new wxFlexGridSizer(1);
2932         wxFlexGridSizer *sizerH0 = new wxFlexGridSizer(20);
2933         wxFlexGridSizer *sizerH1 = new wxFlexGridSizer(20);
2934         wxFlexGridSizer *sizerH2 = new wxFlexGridSizer(10);
2935         wxFlexGridSizer *sizerH3 = new wxFlexGridSizer(10);
2936         //wxFlexGridSizer *sizerH4 = new wxFlexGridSizer(10); // JPRx
2937         //wxFlexGridSizer *sizerH5 = new wxFlexGridSizer(10); // JPRx
2938         //wxFlexGridSizer *sizerH6 = new wxFlexGridSizer(10); // JPRx
2939
2940         sizerH0->Add( ckVolum                                                                   , 1, wxALL|wxEXPAND, 0);
2941         sizerH0->Add( new wxStaticText(panel, -1,_T("          "))      , 1, wxALL|wxEXPAND, 0);
2942         sizerH0->Add( ckBoxVolume                                                               , 1, wxALL|wxEXPAND, 0);
2943         sizerH0->Add( new wxStaticText(panel, -1,_T("          "))      , 1, wxALL|wxEXPAND, 0);
2944         sizerH0->Add( btnVolumeFunctions                                                , 1, wxALL|wxEXPAND, 0);
2945         sizerH0->Add( new wxStaticText(panel, -1,_T("          "))      , 1, wxALL|wxEXPAND, 0);
2946         sizerH0->Add( btnMeshVTKLoad                                                    , 1, wxALL|wxEXPAND, 0);
2947
2948
2949         sizerH1->Add( _surfA                                                                    , 1, wxALL|wxEXPAND, 0);
2950         sizerH1->Add( new wxStaticText(panel, -1,_T("  "))                      , 1, wxALL|wxEXPAND, 0);
2951         sizerH1->Add( _surfB                                                                    , 1, wxALL|wxEXPAND, 0);
2952         sizerH1->Add( new wxStaticText(panel, -1,_T("  "))                      , 1, wxALL|wxEXPAND, 0);
2953         sizerH1->Add( _surfC                                                                    , 1, wxALL|wxEXPAND, 0);
2954         sizerH1->Add( new wxStaticText(panel, -1,_T("  "))                      , 1, wxALL|wxEXPAND, 0);
2955         sizerH1->Add( _surfD                                                                    , 1, wxALL|wxEXPAND, 0);
2956         sizerH1->Add( new wxStaticText(panel, -1,_T("          "))      , 1, wxALL|wxEXPAND, 0);
2957         sizerH1->Add( ckBoxSurface                                                              , 1, wxALL|wxEXPAND, 0);
2958         sizerH1->Add( new wxStaticText(panel, -1,_T("          "))      , 1, wxALL|wxEXPAND, 0);
2959         sizerH1->Add( btnSTL                                                                    , 1, wxALL|wxEXPAND, 0);
2960         sizerH1->Add( new wxStaticText(panel, -1,_T("          "))      , 1, wxALL|wxEXPAND, 0);
2961         sizerH1->Add( btnSaveRaw                                                                , 1, wxALL|wxEXPAND, 0);
2962
2963
2964 //      sizerH2->Add( new wxStaticText(panel, -1,_T("          ")                       , 1, wxALL|wxEXPAND, 0);
2965         sizerH2->Add( _color                            , 1, wxALL|wxEXPAND, 0);
2966         sizerH2->Add( new wxStaticText(panel, -1,_T("          "))                      , 1, wxALL|wxEXPAND, 0);
2967         sizerH2->Add( _visible                          , 1, wxALL|wxEXPAND, 0);
2968         sizerH2->Add( new wxStaticText(panel, -1,_T("          "))                      , 1, wxALL|wxEXPAND, 0);
2969
2970
2971         sizerH2->Add( _wireFrameRep                             , 1,wxSHAPED | wxALIGN_CENTER_VERTICAL , 0);
2972         sizerH2->Add( new wxStaticText(panel, -1,_T("   "))                                     , 1, wxALL|wxEXPAND, 0);
2973         sizerH2->Add( _surfaceRep                               , 1,wxSHAPED | wxALIGN_CENTER_VERTICAL , 0);
2974         sizerH2->Add( new wxStaticText(panel, -1,_T("          "))                      , 1, wxALL|wxEXPAND, 0);
2975
2976         sizerH2->Add( _opacity                          , 1, wxALL|wxEXPAND, 0);
2977
2978
2979         sizerH3->Add( isoValueTitle                     , 1, wxALL|wxEXPAND, 0);
2980         sizerH3->Add( _isoValueSpin                     , 1, wxALL|wxEXPAND, 0);
2981         sizerH3->Add( _isoValue                         , 1, wxALL|wxEXPAND, 0);
2982
2983 /*
2984         sizerH4->Add( ckBoxX            , 1, wxALL|wxEXPAND, 0);
2985         sizerH4->Add( text2                     , 1, wxALL|wxEXPAND, 0);
2986         sizerH4->Add( _positionX                , 1, wxALL|wxEXPAND, 0);
2987
2988         sizerH5->Add( ckBoxY            , 1, wxALL|wxEXPAND, 0);
2989         sizerH5->Add( text2                     , 1, wxALL|wxEXPAND, 0);
2990         sizerH5->Add( _positionY                , 1, wxALL|wxEXPAND, 0);
2991
2992         sizerH6->Add( ckBoxZ            , 1, wxALL|wxEXPAND, 0);
2993         sizerH6->Add( text2                     , 1, wxALL|wxEXPAND, 0);
2994         sizerH6->Add( _positionZ                , 1, wxALL|wxEXPAND, 0);
2995 */
2996         sizer->Add( sizerH0 , 1, wxALL|wxEXPAND, 2);
2997         sizer->Add( sizerH1 , 1, wxALL|wxEXPAND, 2);
2998         sizer->Add( sizerH2 , 1, wxALL|wxEXPAND, 2);
2999         sizer->Add( sizerH3 , 1, wxALL|wxEXPAND, 2);
3000 //      sizer->Add( sizerH4 , 1, wxALL|wxEXPAND, 2);
3001 //      sizer->Add( sizerH5 , 1, wxALL|wxEXPAND, 2);
3002 //      sizer->Add( sizerH6 , 1, wxALL|wxEXPAND, 2);
3003
3004         panel->SetSize(300,60);
3005         panel->SetAutoLayout(true);
3006         panel->SetSizer(sizer);
3007         panel->Layout();
3008
3009         panel->SetEventHandler((wxEvtHandler*)this);
3010
3011 }
3012 //-------------------------------------------------------------------
3013 wxVtkClipping3DViewCntrlPanel::~wxVtkClipping3DViewCntrlPanel()
3014 {
3015 }
3016 //-------------------------------------------------------------------
3017 void wxVtkClipping3DViewCntrlPanel::Refresh()
3018 {
3019 //      wxPanel::Refresh();
3020 /*
3021         _positionX->SetValue( _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetX( ) );
3022         _positionY->SetValue( _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetY( ) );
3023         _positionZ->SetValue( _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetZ( ) );
3024 */
3025 }
3026 //-------------------------------------------------------------------
3027 int wxVtkClipping3DViewCntrlPanel::GetIdTissue()
3028 {
3029         int idTissue=-1;
3030         if (_surfA->GetValue()==true)
3031         {
3032                 idTissue=0;
3033         }
3034         if (_surfB->GetValue()==true)
3035         {
3036                 idTissue=1;
3037         }
3038         if (_surfC->GetValue()==true)
3039         {
3040                 idTissue=2;
3041         }
3042         if (_surfD->GetValue()==true)
3043         {
3044                 idTissue=3;
3045         }
3046
3047         return idTissue;
3048 }
3049 /*
3050 //-------------------------------------------------------------------
3051 void wxVtkClipping3DViewCntrlPanel::OnVisibleAxisX(wxCommandEvent& event)
3052 {
3053         _wxvtkclipping3Dview->VisibleImageActor(0, event.IsChecked() );
3054         _wxvtkclipping3Dview->Refresh();
3055 }
3056 //-------------------------------------------------------------------
3057 void wxVtkClipping3DViewCntrlPanel::OnVisibleAxisY(wxCommandEvent& event)
3058 {
3059         _wxvtkclipping3Dview->VisibleImageActor(1, event.IsChecked() );
3060         _wxvtkclipping3Dview->Refresh();
3061 }
3062 //-------------------------------------------------------------------
3063 void wxVtkClipping3DViewCntrlPanel::OnVisibleAxisZ(wxCommandEvent& event)
3064 {
3065         _wxvtkclipping3Dview->VisibleImageActor(2, event.IsChecked() );
3066         _wxvtkclipping3Dview->Refresh();
3067 }
3068 */
3069
3070 //-------------------------------------------------------------------
3071 void wxVtkClipping3DViewCntrlPanel::OnSurface(wxCommandEvent& event)
3072 {
3073         int idTissue=GetIdTissue();
3074         if (idTissue!=-1)
3075         {
3076                 // Color
3077                 vtkActor *tmpActor;
3078                 tmpActor = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetTissueActor(idTissue);
3079                 double rgb[3];
3080                 tmpActor->GetProperty()->GetColor( rgb );
3081                 wxColour colour( (int)(rgb[0]*255) , (int)(rgb[1]*255) , (int)(rgb[2]*255) );
3082                 _color->SetBackgroundColour(colour);
3083
3084                 // Visible
3085                 _visible->SetValue(_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVisibleTissue(idTissue));
3086
3087                 // Opacity
3088                 _opacity->SetValue( (int)(tmpActor->GetProperty()->GetOpacity()*100) );
3089
3090                 // Representation Type  WireFrame / Surface
3091                 _surfaceRep->SetValue(_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetRepresentationType(idTissue));
3092                 _wireFrameRep->SetValue(!_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetRepresentationType(idTissue));
3093
3094                 // isoValue
3095                 int isoValue= (int)(_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetIsovalue(idTissue));
3096                 _isoValue->SetValue(isoValue);
3097         }
3098 }
3099
3100
3101 //-------------------------------------------------------------------
3102 void wxVtkClipping3DViewCntrlPanel::OnRepresentationSurfaceWireFrame(wxCommandEvent& event)
3103 {
3104         int idTissue=GetIdTissue();
3105         if (idTissue!=-1)
3106         {
3107                 _wxvtkclipping3Dview->SetRepSurfaceWireFrame(idTissue , _surfaceRep->GetValue() );
3108
3109                 _wxvtkclipping3Dview->Refresh();
3110
3111                 wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
3112                 _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
3113
3114         }
3115 }
3116
3117 //-------------------------------------------------------------------
3118 void wxVtkClipping3DViewCntrlPanel::OnVisibleVolume(wxCommandEvent& event)
3119 {
3120         _wxvtkclipping3Dview->VisibleVolumeActor( event.IsChecked()  );
3121         _wxvtkclipping3Dview->Refresh();
3122
3123         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
3124         _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
3125 }
3126 //-------------------------------------------------------------------
3127 void wxVtkClipping3DViewCntrlPanel::OnVisibleBoxSurface(wxCommandEvent& event)
3128 {
3129         _wxvtkclipping3Dview->SetVisibleBoxSurface(event.IsChecked() );
3130         _wxvtkclipping3Dview->Refresh();
3131 }
3132 //-------------------------------------------------------------------
3133 void wxVtkClipping3DViewCntrlPanel::OnVisibleBoxVolume(wxCommandEvent& event)
3134 {
3135         _wxvtkclipping3Dview->SetVisibleBoxVolume(event.IsChecked() );
3136         _wxvtkclipping3Dview->Refresh();
3137 }
3138 //-------------------------------------------------------------------
3139 void wxVtkClipping3DViewCntrlPanel::OnColor(wxCommandEvent& event)
3140 {
3141         int idTissue=GetIdTissue();
3142         if (idTissue!=-1)
3143         {
3144 // EED 17 Janvier 2007
3145                 wxColourDialog dlgColour(this);
3146 //              dlgColour.ShowModal();
3147                 if( dlgColour.ShowModal( ) == wxID_OK )
3148                 {
3149                         vtkActor *tmpActor;
3150                         tmpActor = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetTissueActor(idTissue);
3151                         float r=dlgColour.GetColourData().GetColour().Red()/255;
3152                         float g=dlgColour.GetColourData().GetColour().Green()/255;
3153                         float b=dlgColour.GetColourData().GetColour().Blue()/255;
3154                         tmpActor->GetProperty()->SetColor( r , g , b );
3155                         _color->SetBackgroundColour(dlgColour.GetColourData().GetColour());
3156
3157                         _wxvtkclipping3Dview->Refresh();
3158
3159                         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
3160                         _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
3161                 }
3162         }
3163 }
3164 //-------------------------------------------------------------------
3165 void wxVtkClipping3DViewCntrlPanel::OnVisibleSurface(wxCommandEvent& event)
3166 {
3167         int idTissue=GetIdTissue();
3168         if (idTissue!=-1)
3169         {
3170                 _wxvtkclipping3Dview->VisibleActor(idTissue, _visible->GetValue());
3171
3172                 _wxvtkclipping3Dview->Refresh();
3173
3174                 wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
3175                 _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
3176         }
3177 }
3178 //-------------------------------------------------------------------
3179 void wxVtkClipping3DViewCntrlPanel::OnOpacity(wxScrollEvent& event)
3180 {
3181         int idTissue=GetIdTissue();
3182         if (idTissue!=-1)
3183         {
3184                 vtkActor *tmpActor;
3185                 tmpActor = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetTissueActor(idTissue);
3186                 float opacity=_opacity->GetValue();
3187                 tmpActor->GetProperty()->SetOpacity( opacity/100 );
3188
3189                 _wxvtkclipping3Dview->Refresh();
3190
3191                 wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
3192                 _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
3193         }
3194 }
3195
3196 //----------------------------------------------------------------------------
3197 void wxVtkClipping3DViewCntrlPanel::OnIsoValueSpin(wxScrollEvent& event)
3198 {
3199         int value = _isoValue->GetValue();
3200         int delta= (int)pow( 4 , _isoValueSpin->GetValue() );
3201         int min=value - delta/2;
3202         int max=value + delta/2;
3203         if (min<0)
3204         {
3205                 min=0;
3206                 max=delta;
3207         }
3208         _isoValue->SetRange(min,max);
3209 }
3210
3211
3212 //------------------------------------------------------------------------
3213 void wxVtkClipping3DViewCntrlPanel::OnIsoValue(wxScrollEvent& event)
3214 {
3215         wxBusyCursor wait;
3216
3217         int idTissue=GetIdTissue();
3218         if (idTissue!=-1)
3219         {
3220                 int isoValue=_isoValue->GetValue();
3221                 _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->SetIsovalue(idTissue,isoValue);
3222 //              wxString tmpStr;
3223 //              tmpStr.Printf("%d",isoValue);
3224
3225                 _wxvtkclipping3Dview->Refresh();
3226
3227                 wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
3228                 _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
3229         }
3230
3231 }
3232 //-------------------------------------------------------------------
3233 void wxVtkClipping3DViewCntrlPanel::OnBtnCreateFileSTL(wxCommandEvent& event)
3234 {
3235
3236         int idTissue=GetIdTissue();
3237         if (idTissue==-1)
3238         {
3239                 idTissue=0;
3240         }
3241
3242
3243         wxString dirSTL = wxGetHomeDir( ) ;
3244         wxFileDialog dialog( this, _T("Choose a directory..."), dirSTL , _T(""), _T("*.*"), wxSAVE );
3245
3246         if( dialog.ShowModal( ) == wxID_OK )
3247         {
3248
3249
3250                 // ------------------------------------------------------------------------
3251                 //  1.  GENERATE STL FILES
3252                 // ------------------------------------------------------------------------
3253 //              const char* fileprefix = "c:\\Creatis\\";
3254                 std::string prefix = (const char*) (dialog.GetPath().mb_str() );
3255                 std::string filename;
3256
3257                 // 1.1. Se hace un filtro triangular puesto que el stl writer solo recibe poligonos triangulares.
3258
3259         vtkTriangleFilter *filtro = vtkTriangleFilter::New();
3260
3261
3262                 filtro->SetInput( this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetTissueClipper(idTissue)->GetOutput() );
3263                 vtkPolyDataConnectivityFilter *pdcf = vtkPolyDataConnectivityFilter::New();
3264         pdcf->SetInput( filtro->GetOutput() );
3265         vtkClosePolyData *cpd = vtkClosePolyData::New();
3266         cpd->SetInput( pdcf->GetOutput() );
3267
3268                 // 1.2 se escribe a disco el archivo stl de la superficie interna
3269         cpd->Update();
3270         vtkSTLWriter *writer = vtkSTLWriter::New();
3271         writer->SetInput( cpd->GetOutput() );
3272                 filename =prefix;
3273         writer->SetFileName(filename.c_str());
3274         writer->SetFileTypeToASCII();
3275         writer->Write();
3276         writer->Delete();
3277
3278
3279         filtro->Delete();
3280         cpd->Delete();
3281         pdcf->Delete();
3282         }
3283
3284 }
3285
3286 //EED 30 Janvier 2007
3287 //-------------------------------------------------------------------
3288 void wxVtkClipping3DViewCntrlPanel::OnBtnSaveRawVolume(wxCommandEvent& event)
3289 {
3290         wxFileDialog dialog(this, _T("Choose a file"), _T(""), _T(""), _T("*.maracas"), wxSAVE );
3291         if (dialog.ShowModal() == wxID_OK)
3292         {
3293                 std::string directory = (const char*) (dialog.GetDirectory().mb_str() );
3294                 std::string filename  = (const char*) (dialog.GetFilename().mb_str() );
3295                 float rescalaSlope           =  1;
3296                 float rescalaIntercept       =  0;
3297                 vtkMPRBaseData *vtkmprbasedata = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData();
3298                 vtkImageData *vtkimagedata       = vtkmprbasedata->GetImageData();
3299                 int dim[3];
3300                 vtkimagedata->GetDimensions(dim);
3301                 int voi[6];
3302                 voi[0]=0;
3303                 voi[1]=dim[0];
3304                 voi[2]=0;
3305                 voi[3]=dim[1];
3306                 voi[4]=0;
3307                 voi[5]=dim[2];
3308 //EED 10 oct 2007 MaracasVisu pour bbMaracasvisu
3309                 marRAW2Files marraw2;
3310                 marraw2.saveVolume(directory,filename,vtkimagedata,voi,rescalaSlope,rescalaIntercept);
3311         }
3312 }
3313
3314 //EED 22 Fevrier 2007
3315 //-------------------------------------------------------------------
3316 void wxVtkClipping3DViewCntrlPanel::OnBtnVolumeFunctions(wxCommandEvent& event)
3317 {
3318
3319         int /*i=0,*/ xi,yi,r,g,b;  // JPRx
3320         vtkColorTransferFunction* ctfun = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetColorTransferenceFunction();
3321         vtkPiecewiseFunction* tfun      = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetTransferencefunction();
3322         std::vector<double>* gtf                = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetGreyValuesTransferenceFVector();
3323         std::vector<double>* itf                = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetIntensityValuesTransferenceFVector();
3324         std::vector<double>* greyctf    = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetGreyValueColorsOfColorTransferenceFVector();
3325         std::vector<double>* rctf               = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetRedColorsOfColorTransferenceFVector();
3326         std::vector<double>* gctf               = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetGreenColorsOfColorTransferenceFVector();
3327         std::vector<double>* bctf               = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetBlueColorsOfColorTransferenceFVector();
3328         vtkImageData *imagedata = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
3329
3330         //use for update in the refresh
3331         /*
3332         vtkVolumeRayCastMapper* volumeMapper = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVolumeMapper();
3333         vtkVolume* newvol       =this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVolumeActor();
3334         */
3335
3336         /*
3337         MMLR BORRAME
3338         wxFileDialog dialog(this, _T("Choose a file"), _T("c:/Maracas_configuration"),_T(""), _T("*.MarVolConf"), wxOPEN);
3339         if (dialog.ShowModal() == wxID_OK)
3340         {
3341                 _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->ReadVolumeFunctions( (char *)dialog.GetPath().c_str() );
3342
3343
3344         }
3345         */
3346
3347         HistogramDialog* hDlg=new HistogramDialog(NULL,_T("Histogram Dialog"),imagedata,1);
3348         //
3349         // put in a method
3350         //
3351         int tfSize=gtf->size();
3352                 if(tfSize>0)
3353                 {
3354                         int i=0;
3355                         hDlg->erasePointsTransferenceFunction();
3356                         while(i<tfSize)
3357                         {
3358                                 double g=(*gtf)[i];
3359                                 double in=(*itf)[i];
3360                                 hDlg->addPointToTransferenceFunction(g,in*100);
3361                                 i++;
3362                         }
3363
3364                 }
3365
3366         int ctfSize=rctf->size();
3367         if(ctfSize>0)
3368         {
3369                 int i=0;
3370                         while(i<ctfSize)
3371                         {
3372                                 double gr=(*greyctf)[i];
3373                                 double r=(*rctf)[i];
3374                                 double g=(*gctf)[i];
3375                                 double b=(*bctf)[i];
3376                                 hDlg->addColorPoint(gr,(int)(r*255),(int)(g*255),(int)(b*255));
3377                                 i++;
3378                         }
3379         }
3380         //setting variables if the user wants to do refresh
3381         hDlg->setCTF(ctfun);
3382         hDlg->setTF(tfun);
3383         hDlg->setClipping3DView(_wxvtkclipping3Dview);
3384         /*
3385         hDlg->setVolume(newvol);
3386         hDlg->setVolumeMapper(volumeMapper);
3387         */
3388         //
3389         // when the user had changed the transference Function
3390         //
3391         if(hDlg->ShowModal()== wxID_OK )
3392         {
3393                         // -- vtkPiecewiseFunction --
3394                         tfun->RemoveAllPoints();
3395                         gtf->clear();
3396                         itf->clear();
3397
3398                         int nTFPoints=hDlg->getSizeTransferenceFunction();
3399                         int i=0;
3400                         while(i<nTFPoints)
3401                         {
3402                                 hDlg->getTransferenceFunctionPoint(i,xi,yi);
3403                                 tfun->AddPoint( xi , yi/100.0 );
3404                                 gtf->push_back(xi);
3405                                 itf->push_back(yi/100.0);
3406                                 i++;
3407                         }
3408                         // -- vtkColorTransferFunction  --
3409                         ctfun->RemoveAllPoints ();
3410                         //clean colors
3411                         rctf->clear();
3412                         gctf->clear();
3413                         bctf->clear();
3414                         greyctf->clear();
3415
3416                         int nCTFpoints=hDlg->getSizeBarColor();
3417                         i=0;
3418                         while(i<nCTFpoints)
3419                         {
3420                                 hDlg->getDataBarColorPoint(i,xi,r,g,b);
3421                                 ctfun->AddRGBPoint(xi,r/255.0,g/255.0,b/255.0 );
3422                                 rctf->push_back(r/255.0);
3423                                 gctf->push_back(g/255.0);
3424                                 bctf->push_back(b/255.0);
3425                                 greyctf->push_back(xi);
3426                                 i++;
3427                         }
3428                         //---------------------------------
3429                         // Refreshing and sending the event
3430                         //---------------------------------
3431                         //_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->ReadVolumeFunctions();
3432                         _wxvtkclipping3Dview->Refresh();
3433                         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
3434                         _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
3435
3436                         /*
3437                         volumeMapper->Update();
3438                         newvol->Update();
3439                         */
3440         }
3441
3442         else
3443         {
3444
3445                 if(hDlg->getRefreshed())
3446                 {
3447                         int i=0,size;
3448                         //--Transference Function----
3449                         tfun->RemoveAllPoints();
3450                         i=0;
3451                         size=gtf->size();
3452                         for(i=0;i<size;i++)
3453                         {
3454                                 double grey1=(*gtf)[i];
3455                                 double  in2=(*itf)[i];
3456                                 tfun->AddPoint( grey1 , in2 );
3457                         }
3458
3459                         // -- vtkColorTransferFunction  --
3460                         ctfun->RemoveAllPoints ();
3461
3462                         i=0;
3463                         size=greyctf->size();
3464                         for(i=0;i<size;i++)
3465                         {
3466                                 double grey2=(*greyctf)[i];
3467                                 double red =(*rctf)[i];
3468                                 double green =(*gctf)[i];
3469                                 double blue = (*bctf)[i];
3470                                 ctfun->AddRGBPoint(grey2,red,green,blue);
3471                         }
3472
3473                         //---------------------------------
3474                         // Refreshing and sending the event
3475                         //---------------------------------
3476                         //_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->ReadVolumeFunctions();
3477                         _wxvtkclipping3Dview->Refresh();
3478                         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
3479                         _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
3480
3481                         /*
3482                         volumeMapper->Update();
3483                         newvol->Update();
3484                         */
3485                  }
3486
3487         }
3488         //destroy the dialog
3489         hDlg->Destroy();
3490 }
3491
3492 //EED 23 Mai 2007
3493 //-------------------------------------------------------------------
3494 void wxVtkClipping3DViewCntrlPanel::OnBtnMeshVTKLoad(wxCommandEvent& event)
3495 {
3496         wxFileDialog dialog(this, _T("Choose a file"), _T("c:/Maracas_configuration"),_T(""), _T("*.vtk"), wxOPEN);
3497         if (dialog.ShowModal() == wxID_OK)
3498         {
3499                 _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->ReadMeshVTK( (char *)dialog.GetPath().c_str() );
3500                 _wxvtkclipping3Dview->Refresh();
3501                 wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
3502                 _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
3503         }
3504 }
3505
3506
3507 //-------------------------------------------------------------------
3508 //-------------------------------------------------------------------
3509 //-------------------------------------------------------------------
3510
3511
3512 wxVtkMPR3DView::wxVtkMPR3DView( wxVtk3DBaseView *wxvtk3Dbaseview )
3513 {
3514         _wxvtk3Dbaseview                        =       wxvtk3Dbaseview;
3515         _vtkmpr3Ddataviewer                     =       NULL;
3516         _wxvtkmpr3DviewCntrlPanel       =       NULL;
3517 }
3518
3519 //-------------------------------------------------------------------
3520 wxVtkMPR3DView::~wxVtkMPR3DView()
3521 {
3522 }
3523
3524 //-------------------------------------------------------------------
3525 void wxVtkMPR3DView::Refresh()   // virtual
3526 {
3527         _vtkmpr3Ddataviewer     ->      Refresh();
3528         if (_wxvtkmpr3DviewCntrlPanel!=NULL)
3529         {
3530                 _wxvtkmpr3DviewCntrlPanel->Refresh();
3531         }
3532
3533 }
3534 //-------------------------------------------------------------------
3535 void wxVtkMPR3DView::RefreshView()   // virtual
3536 {
3537         double spc[3];
3538         this->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData()->GetSpacing(spc);
3539
3540         //double nx=1,ny=0,nz=0; // JPRx
3541         Refresh();
3542         double x=GetVtkMPR3DDataViewer ()->GetVtkMPRBaseData()->GetX();
3543         double y=GetVtkMPR3DDataViewer ()->GetVtkMPRBaseData()->GetY();
3544         double z=GetVtkMPR3DDataViewer ()->GetVtkMPRBaseData()->GetZ();
3545
3546         x=x*spc[0];
3547         y=y*spc[1];
3548         z=z*spc[2];
3549
3550         _pointWidget->SetPosition( x,y,z );
3551
3552
3553         double in[3];
3554         double normal[3];
3555         vtkTransform *transform = GetVtkMPR3DDataViewer ()->GetVtkMPRBaseData()->GetTransformOrientation();
3556         in[0]=1;                in[1]=0;                        in[2]=0;
3557         transform->TransformPoint(in,normal);
3558         _planeWidget->SetNormal( normal[0],normal[1],normal[2] );
3559
3560
3561         _planeWidget->SetCenter( x,y,z );
3562         _planeWidget->UpdatePlacement();
3563         _planeWidget->GetPolyData(_vtkplane);
3564 }
3565 //-------------------------------------------------------------------
3566 wxPanel* wxVtkMPR3DView::CreateControlPanel(wxWindow *parent)
3567 {
3568         _wxvtkmpr3DviewCntrlPanel = new wxVtkMPR3DViewCntrlPanel(parent,this);
3569         return _wxvtkmpr3DviewCntrlPanel;
3570 }
3571 //-------------------------------------------------------------------
3572 vtkMPR3DDataViewer* wxVtkMPR3DView::GetVtkMPR3DDataViewer()
3573 {
3574         return _vtkmpr3Ddataviewer;
3575 }
3576 //-------------------------------------------------------------------
3577 wxVtk3DBaseView* wxVtkMPR3DView::GetWxvtk3Dbaseview()
3578 {
3579         return _wxvtk3Dbaseview;
3580 }
3581 //-------------------------------------------------------------------
3582 void wxVtkMPR3DView::Configure(){
3583         _wxvtk3Dbaseview->Configure();
3584
3585         // Actors are added to the renderer.
3586         _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkmpr3Ddataviewer->GetOutlineActor() );
3587 //      _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkmpr3Ddataviewer->GetImageActor(0)  );    // _saggital
3588 //      _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkmpr3Ddataviewer->GetImageActor(1)  );    // _axial
3589 //      _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkmpr3Ddataviewer->GetImageActor(2)  );    // _coronal
3590
3591
3592         // An initial camera view is created.  The Dolly() method moves
3593         // the camera towards the FocalPoint, thereby enlarging the image.
3594         _wxvtk3Dbaseview->GetRenderer()->SetActiveCamera(_wxvtk3Dbaseview->GetCamera());
3595         _wxvtk3Dbaseview->GetRenderer()->ResetCamera ();
3596         _wxvtk3Dbaseview->GetCamera()->Dolly(1.5);
3597
3598         // Set a background color for the renderer and set the size of the
3599         // render window (expressed in pixels).
3600         _wxvtk3Dbaseview->GetRenderer()->SetBackground( 0.36 , 0.36 , 0.36 );
3601         _wxvtk3Dbaseview->GetRenWin()->SetSize(400, 400);
3602
3603         // Note that when camera movement occurs (as it does in the Dolly()
3604         // method), the clipping planes often need adjusting. Clipping planes
3605         // consist of two planes: near and far along the view direction. The
3606         // near plane clips out objects in front of the plane; the far plane
3607         // clips out objects behind the plane. This way only what is drawn
3608         // between the planes is actually rendered.
3609         _wxvtk3Dbaseview->GetRenderer()->ResetCameraClippingRange();
3610
3611
3612         // vtkPointWidget
3613         _myCallback = vtkmyPWCallback_3DPointWidget::New();
3614         _myCallback->SetWxVtkMPR3DView(this);
3615
3616         _pointWidget = vtkPointWidget::New();
3617         _myCallback->SetVtkPointWidget(_pointWidget);
3618         _pointWidget->SetInteractor( GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor() );
3619         _pointWidget->SetInput( GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData() );
3620
3621         _pointWidget->AllOff();
3622
3623         _pointWidget->PlaceWidget();
3624 //      _pointWidget->SetPosition( x,y,z );
3625
3626 //EED01 29Mars2009
3627 // MACOS probleme vtk-window out of wx-window
3628 //      _pointWidget->On();
3629
3630         _pointWidget->AddObserver(vtkCommand::InteractionEvent,_myCallback);
3631
3632
3633 // PlaneWidget
3634         _planeWidget = vtkPlaneWidget::New();
3635         _myCallback->SetVtkPlaneWidget(_planeWidget);
3636         _planeWidget->SetInput( GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData() );
3637         _planeWidget->NormalToXAxisOn();
3638         _planeWidget->SetResolution(50);
3639         _planeWidget->SetRepresentationToOutline();
3640         int dim[3];
3641         GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData()->GetDimensions(dim);
3642         int px=(dim[0]/2);
3643         int py=(dim[1]/2);
3644         int pz=(dim[2]/2);
3645         int dd=20;
3646         _planeWidget->PlaceWidget( px-dd , px+dd , py-dd , py+dd , pz-dd , pz+dd );
3647         _vtkplane = vtkPolyData::New();
3648         _planeWidget->GetPolyData(_vtkplane);
3649
3650         vtkProbeFilter *probe = vtkProbeFilter::New();
3651         probe->SetInput(_vtkplane);
3652         vtkImageData *imageData = GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
3653         probe->SetSource( imageData );
3654
3655         vtkPolyDataMapper *contourMapper = vtkPolyDataMapper::New();
3656
3657         contourMapper->SetInput( probe->GetPolyDataOutput() );
3658
3659     contourMapper->SetScalarRange( imageData->GetScalarRange() );
3660         _contourPlaneActor = vtkActor::New();
3661         _contourPlaneActor->SetMapper(contourMapper);
3662
3663         _contourPlaneActor->VisibilityOff();
3664
3665         _planeWidget->SetInteractor( GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor() );
3666         _planeWidget->AddObserver(vtkCommand::InteractionEvent,_myCallback);
3667
3668         _planeWidget->Off();
3669         _wxvtk3Dbaseview->GetRenderer()->AddActor( _contourPlaneActor );
3670 }
3671 //-------------------------------------------------------------------
3672 void wxVtkMPR3DView::VisibleImageActor(int idPosition, bool visible){
3673         if (visible!=_vtkmpr3Ddataviewer->GetVisiblePosition(idPosition)){
3674                 if (visible==false){
3675                         _wxvtk3Dbaseview->GetRenderer()->RemoveActor( _vtkmpr3Ddataviewer->GetImageActor(idPosition)  );
3676                 } else {
3677                         _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkmpr3Ddataviewer->GetImageActor(idPosition)  );
3678                 }
3679                 _vtkmpr3Ddataviewer->SetVisiblePosition(idPosition,visible);
3680         }
3681 }
3682
3683
3684 //-------------------------------------------------------------------
3685 void wxVtkMPR3DView::VisiblePointWidget( bool visible )
3686 {
3687         if (visible==true)
3688         {
3689                 _pointWidget->On();
3690         } else {
3691                 _pointWidget->Off();
3692         }
3693 }
3694
3695 //-------------------------------------------------------------------
3696 void wxVtkMPR3DView::VisiblePlaneWidget( bool visible )
3697 {
3698         if (visible==true)
3699         {
3700                 _planeWidget->On();
3701                 _contourPlaneActor->VisibilityOn();
3702
3703         } else {
3704                 _planeWidget->Off();
3705                 _contourPlaneActor->VisibilityOff();
3706         }
3707 }
3708
3709 //-------------------------------------------------------------------
3710 void wxVtkMPR3DView::SetVtkMPR3DDataViewer(vtkMPR3DDataViewer *vtkmpr3Ddataviewer)
3711 {
3712         _vtkmpr3Ddataviewer = vtkmpr3Ddataviewer;
3713 }
3714
3715 //-------------------------------------------------------------------
3716 void wxVtkMPR3DView::InitOrientationPointWidget()
3717 {
3718         this->_planeWidget->SetNormal(1,0,0);
3719 }
3720
3721
3722
3723
3724 //-------------------------------------------------------------------
3725 // EED 25 Janvier 2007 testLoic
3726 void wxVtkMPR3DView::TestLoic1()
3727 {
3728
3729         int sizeIma     = 128;
3730   double dimIma = sizeIma*2;
3731
3732         vtkImageData *vtkimagedata =  this->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
3733
3734         double spc[3];
3735         vtkimagedata->GetSpacing(spc);
3736
3737         vtkimagedata->Update();
3738
3739
3740          double p[3], n[3];
3741      this->_planeWidget->GetOrigin(p);
3742      this->_planeWidget->GetNormal(n);
3743
3744
3745
3746     vtkPlaneSource* pSource = vtkPlaneSource::New( );
3747     pSource->SetResolution( sizeIma - 1, sizeIma - 1 );
3748     pSource->SetOrigin( p[ 0 ], p[ 1 ], p[ 2 ] );
3749     pSource->SetPoint1( p[ 0 ] + dimIma - 1.0, p[ 1 ], p[ 2 ] );
3750     pSource->SetPoint2( p[ 0 ], p[ 1 ]+ dimIma - 1.0 , p[ 2 ] );
3751     pSource->Update( );
3752     pSource->SetCenter( p[ 0 ], p[ 1 ], p[ 2 ] );
3753     pSource->SetNormal( n[ 0 ], n[ 1 ], n[ 2 ] );
3754     pSource->Update( );
3755
3756     vtkProbeFilter* slices = vtkProbeFilter::New();
3757     slices->SetInput( ( vtkDataSet* )pSource->GetOutput( ) );
3758     slices->SetSource( vtkimagedata );
3759     slices->Update( );
3760     pSource->Delete( );
3761
3762         vtkStructuredPoints   *stPoints = vtkStructuredPoints::New();
3763         stPoints -> GetPointData( )->SetScalars(  slices->GetOutput()->GetPointData()->GetScalars()  );
3764         stPoints -> SetDimensions( sizeIma, sizeIma, 1 );
3765         stPoints -> SetScalarType( vtkimagedata->GetScalarType() );
3766         stPoints -> SetScalarTypeToShort();
3767         stPoints -> Update();
3768
3769         vtkImageChangeInformation  *change = vtkImageChangeInformation ::New();
3770         change    -> SetInput( stPoints );
3771         change    -> Update();    //important
3772
3773         double _range[2];
3774         vtkimagedata->GetScalarRange(_range);
3775    vtkWindowLevelLookupTable *_bwlookup = vtkWindowLevelLookupTable::New( );
3776    _bwlookup->SetHueRange( 0 , 1 );
3777    _bwlookup->SetNumberOfColors( (int)(_range[1] - _range[0] + 1) );
3778    _bwlookup->SetTableRange( _range[0] , _range[1] );
3779    _bwlookup->SetSaturationRange( 0 , 0 );
3780    _bwlookup->SetValueRange( 0 , 1 );
3781    _bwlookup->SetAlphaRange( 1 , 1 );
3782    _bwlookup->Build( );
3783
3784    vtkLookupTable * _collookup = vtkLookupTable::New( );
3785    _collookup->SetNumberOfColors( 256 );
3786    _collookup->SetTableRange( 0 , 255 );
3787    _collookup->Build( );
3788    _collookup->SetTableValue( 0  , 1 , 0 , 0 , 1 );
3789    _collookup->SetTableValue(128 , 0 , 0 , 1 , 1 );
3790    _collookup->SetTableValue(255 , 0 , 1 , 0 , 1 );
3791
3792
3793         vtkMetaImageWriter *writer = vtkMetaImageWriter::New( );
3794         writer->SetInput( stPoints );
3795         writer->SetFileName( "C:/Users/Images/temp_EED/image.mhd" );
3796         writer->SetFileDimensionality( 2 );
3797         writer->Write( );
3798
3799
3800
3801         vtkDataSetMapper *_3DSliceMapper = vtkDataSetMapper::New( );
3802         _3DSliceMapper->SetInput(change->GetOutput( ) );
3803         _3DSliceMapper->SetLookupTable( _bwlookup );
3804         _3DSliceMapper->SetScalarRange( _range );
3805         _3DSliceMapper->ImmediateModeRenderingOn( );
3806
3807         vtkActor *_3DSliceActor = vtkActor::New( );
3808         _3DSliceActor->SetMapper( _3DSliceMapper );
3809
3810  // The usual rendering stuff.
3811   vtkCamera *camera = vtkCamera::New();
3812       camera->SetPosition(1,1,1);
3813       camera->SetFocalPoint(0,0,0);
3814
3815   vtkRenderer *renderer = vtkRenderer::New();
3816   vtkRenderWindow *renWin = vtkRenderWindow::New();
3817     renWin->AddRenderer(renderer);
3818
3819   vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
3820     iren->SetRenderWindow(renWin);
3821
3822   renderer->AddActor( _3DSliceActor );
3823       renderer->SetActiveCamera(camera);
3824       renderer->ResetCamera();
3825       renderer->SetBackground(1,1,1);
3826
3827   renWin->SetSize(300,300);
3828
3829   // interact with data
3830   renWin->Render();
3831   iren->Start();
3832
3833
3834
3835
3836
3837 }
3838
3839 //-------------------------------------------------------------------
3840 // EED 25 Janvier 2007 testLoic
3841 void wxVtkMPR3DView::TestLoic2()
3842 {
3843 /*
3844  vtkVectorNorm *vecMagnitude = vtkVectorNorm::New();
3845                 vecMagnitude->SetInput(VtkMainGrid);
3846                 vecMagnitude->NormalizeOff();
3847                 vecMagnitude->Update();
3848 */
3849
3850         vtkPlane *slicePlane = vtkPlane::New();
3851                                 this->_planeWidget->GetPlane( slicePlane );
3852
3853
3854         vtkCutter* sliceCutter = vtkCutter::New();
3855                 vtkImageData *vtkimagedata =  this->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
3856                 sliceCutter->SetInput( vtkimagedata );
3857                 sliceCutter->SetCutFunction( slicePlane );
3858
3859 //EED
3860 //        vtkLookupTable *lut = BuildHueWeightBaseMap();
3861
3862
3863         vtkPolyDataMapper *slice = vtkPolyDataMapper::New();
3864                 slice->SetInput( sliceCutter->GetOutput() );
3865         double range[2];
3866 // EED
3867 //                slice->Update();
3868                                   vtkimagedata->GetScalarRange(range);
3869 //                vecMagnitude->GetOutput()->GetScalarRange( range );
3870 //                range[1] *= 0.7; // reduce the upper range by 30%
3871 //                slice->SetScalarRange( range );
3872 //                slice->SetLookupTable( lut );
3873
3874 //       vtkActor *sliceActor = vtkActor::New();
3875 //                sliceActor->SetMapper( slice );
3876
3877         vtkPolyDataMapper *contourMapper = vtkPolyDataMapper::New();
3878                 contourMapper->SetInput( sliceCutter->GetOutput() );
3879                 contourMapper->SetScalarRange( range );
3880   //              contourMapper->SetLookupTable( lut );
3881
3882
3883         vtkActor *contourActor = vtkActor::New();
3884                 contourActor->SetMapper( contourMapper );
3885
3886
3887
3888  // The usual rendering stuff.
3889   vtkCamera *camera = vtkCamera::New();
3890       camera->SetPosition(1,1,1);
3891       camera->SetFocalPoint(0,0,0);
3892
3893   vtkRenderer *renderer = vtkRenderer::New();
3894   vtkRenderWindow *renWin = vtkRenderWindow::New();
3895     renWin->AddRenderer(renderer);
3896
3897   vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
3898     iren->SetRenderWindow(renWin);
3899
3900   renderer->AddActor( contourActor );
3901 //  renderer->AddActor(cubeActor);
3902       renderer->SetActiveCamera(camera);
3903       renderer->ResetCamera();
3904       renderer->SetBackground(1,1,1);
3905
3906   renWin->SetSize(300,300);
3907
3908   // interact with data
3909   renWin->Render();
3910   iren->Start();
3911
3912
3913 }
3914
3915 //-------------------------------------------------------------------
3916 //-------------------------------------------------------------------
3917 //-------------------------------------------------------------------
3918
3919 wxVtkClipping3DView::wxVtkClipping3DView(wxVtk3DBaseView* wxvtk3Dbaseview)
3920 {
3921         _wxvtk3Dbaseview                                =       wxvtk3Dbaseview;
3922         _vtkclipping3Ddataviewer                =       NULL;
3923         _wxvtkclipping3DviewCntrlPanel  =       NULL;
3924
3925         _boxWidgetVolume                                =       NULL;
3926         _boxWidgetS1                                    =       NULL;
3927 }
3928
3929 //-------------------------------------------------------------------
3930 wxVtkClipping3DView::~wxVtkClipping3DView(){
3931         if (_boxWidgetVolume!=NULL)                              { _boxWidgetVolume     -> Delete();                                    }
3932         if (_boxWidgetS1!=NULL)                                  { _boxWidgetS1         -> Delete();                                    }
3933         if (_vtkclipping3Ddataviewer!=NULL)              { delete _vtkclipping3Ddataviewer;                     }
3934         if (_wxvtkclipping3DviewCntrlPanel!=NULL){ delete _wxvtkclipping3DviewCntrlPanel;       }
3935 }
3936 //-------------------------------------------------------------------
3937 void wxVtkClipping3DView::SetVisibleBoxSurface(bool visible)
3938 {
3939         if (visible==true){
3940                 _boxWidgetS1->On();
3941         } else {
3942                 _boxWidgetS1->Off();
3943         }
3944 }
3945 //-------------------------------------------------------------------
3946 void wxVtkClipping3DView::SetVisibleBoxVolume(bool visible)
3947 {
3948         if (_boxWidgetVolume!=NULL){
3949                 if (visible==true){
3950                         _boxWidgetVolume->On();
3951                 } else {
3952                         _boxWidgetVolume->Off();
3953                 }
3954         }
3955 }
3956 //-------------------------------------------------------------------
3957 void wxVtkClipping3DView::Refresh()
3958 {
3959         _vtkclipping3Ddataviewer->Refresh();
3960         if (_wxvtkclipping3DviewCntrlPanel!=NULL)
3961         {
3962                 _wxvtkclipping3DviewCntrlPanel->Refresh();
3963         }
3964 }
3965 //-------------------------------------------------------------------
3966 wxPanel* wxVtkClipping3DView::CreateControlPanel(wxWindow *parent)
3967 {
3968         _wxvtkclipping3DviewCntrlPanel = new wxVtkClipping3DViewCntrlPanel(parent,this);
3969         return _wxvtkclipping3DviewCntrlPanel;
3970 }
3971 //-------------------------------------------------------------------
3972 vtkClipping3DDataViewer* wxVtkClipping3DView::GetVtkClipping3DDataViewer()
3973 {
3974         return _vtkclipping3Ddataviewer;
3975 }
3976 //-------------------------------------------------------------------
3977 void wxVtkClipping3DView::VisibleActor(int idTissue, bool visTissue){
3978         if (visTissue!=_vtkclipping3Ddataviewer->GetVisibleTissue(idTissue)){
3979                 if (visTissue==false){
3980                         _wxvtk3Dbaseview->GetRenderer()->RemoveActor( _vtkclipping3Ddataviewer->GetTissueActor(idTissue)  );
3981                 } else {
3982                         _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkclipping3Ddataviewer->GetTissueActor(idTissue)  );
3983 //                      _boxWidgetS1->GetPlanes( this->GetVtkClipping3DDataViewer()->GetTissuePlanes(idTissue) );
3984 //                      _actor->VisibilityOn();
3985                 }
3986                 _vtkclipping3Ddataviewer->SetVisibleTissue(idTissue,visTissue);
3987         }
3988 }
3989 //-------------------------------------------------------------------
3990 void wxVtkClipping3DView::SetRepSurfaceWireFrame(int idTissue , bool representationType )
3991 {
3992         vtkActor *tmpActor;
3993         tmpActor = GetVtkClipping3DDataViewer()->GetTissueActor(idTissue);
3994
3995         if (representationType==false){
3996                 tmpActor->GetProperty()->SetRepresentationToWireframe();
3997         } else {
3998                 tmpActor->GetProperty()->SetRepresentationToSurface();
3999         }
4000
4001         _vtkclipping3Ddataviewer->SetRepresentationType(idTissue,representationType);
4002 }
4003
4004 //-------------------------------------------------------------------
4005 void wxVtkClipping3DView::VisibleVolumeActor( bool visVolume){
4006         if (visVolume!=_vtkclipping3Ddataviewer->GetVisibleVolume() ){
4007                 if (visVolume==false){
4008 //EED 31/03/2008
4009 //                      _wxvtk3Dbaseview->GetRenderer()->RemoveActor( _vtkclipping3Ddataviewer->GetVolumeActor()  );
4010                         _wxvtk3Dbaseview->GetRenderer()->RemoveVolume( _vtkclipping3Ddataviewer->GetVolumeActor()  );
4011                 } else {
4012 //EED 31/03/2008
4013 //                      _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkclipping3Ddataviewer->GetVolumeActor() );
4014                         _wxvtk3Dbaseview->GetRenderer()->AddVolume( _vtkclipping3Ddataviewer->GetVolumeActor() );
4015                 }
4016                 _vtkclipping3Ddataviewer->SetVisibleVolume(visVolume);
4017         }
4018 }
4019 //-------------------------------------------------------------------
4020 wxVtk3DBaseView* wxVtkClipping3DView::GetWxvtk3Dbaseview()
4021 {
4022         return _wxvtk3Dbaseview;
4023 }
4024 //-------------------------------------------------------------------
4025 void wxVtkClipping3DView::Configure(){
4026         _wxvtk3Dbaseview->Configure();
4027
4028         // Actors are added to the renderer.
4029         _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkclipping3Ddataviewer->GetOutlineActor() );
4030
4031         _boxWidgetS1 = vtkBoxWidget::New();
4032         _boxWidgetS1->SetInteractor( _wxvtk3Dbaseview->GetWxVTKRenderWindowInteractor() );
4033         _boxWidgetS1->SetPlaceFactor(1.25);
4034
4035
4036
4037         vtkStripper *stripper=_vtkclipping3Ddataviewer->GetTissueStripper(0);
4038         vtkPolyData *polydata= stripper->GetOutput();
4039
4040
4041         _boxWidgetS1->SetInput( polydata );
4042         _boxWidgetS1->PlaceWidget();
4043
4044         int i;
4045         for (i=0; i< VTKMPRDATA_MAXTISSUE ; i++)
4046         {
4047                 _boxWidgetS1->AddObserver( vtkCommand::InteractionEvent          , _vtkclipping3Ddataviewer->GetObserverS(i) );
4048         }
4049
4050
4051
4052
4053 //      _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkclipping3Ddataviewer->GetTissueActor(0) );
4054 //      _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkclipping3Ddataviewer->GetTissueActor(3));
4055
4056         VisibleActor(0, false );
4057         VisibleActor(1, false );
4058         VisibleActor(2, false );
4059         VisibleActor(3, false );
4060
4061         _boxWidgetS1->HandlesOn ();
4062
4063 //EED 29Mars2009
4064 //      _boxWidgetS1->On();
4065
4066         _boxWidgetS1->Off();
4067
4068         _boxWidgetS1->GetPlanes( this->GetVtkClipping3DDataViewer()->GetTissuePlanes(0) );
4069         _boxWidgetS1->GetPlanes( this->GetVtkClipping3DDataViewer()->GetTissuePlanes(1) );
4070         _boxWidgetS1->GetPlanes( this->GetVtkClipping3DDataViewer()->GetTissuePlanes(2) );
4071         _boxWidgetS1->GetPlanes( this->GetVtkClipping3DDataViewer()->GetTissuePlanes(3) );
4072
4073 // EED 9 fev 2007
4074 // box Volume
4075         _boxWidgetVolume = vtkBoxWidget::New();
4076         _boxWidgetVolume->SetInteractor( _wxvtk3Dbaseview->GetWxVTKRenderWindowInteractor() );
4077         _boxWidgetVolume->SetPlaceFactor(1.25);
4078
4079         _boxWidgetVolume->SetInput( this->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetImageData() );
4080         _boxWidgetVolume->PlaceWidget();
4081
4082         _boxWidgetVolume->AddObserver( vtkCommand::InteractionEvent              , _vtkclipping3Ddataviewer->GetObserverV() );
4083
4084         _boxWidgetVolume->HandlesOn ();
4085
4086 //EED 29Mars2009
4087 //      _boxWidgetVolume->On();
4088
4089         _boxWidgetVolume->Off();
4090
4091
4092 //      vtkPlanes *vtkplanes=this->GetVtkClipping3DDataViewer()->GetVolumePlanes();
4093 //      _boxWidgetVolume->GetPlanes( vtkplanes );
4094
4095
4096   // An initial camera view is created.  The Dolly() method moves
4097   // the camera towards the FocalPoint, thereby enlarging the image.
4098   _wxvtk3Dbaseview->GetRenderer()->SetActiveCamera(_wxvtk3Dbaseview->GetCamera());
4099   _wxvtk3Dbaseview->GetRenderer()->ResetCamera ();
4100   _wxvtk3Dbaseview->GetCamera()->Dolly(1.5);
4101
4102   // Set a background color for the renderer and set the size of the
4103   // render window (expressed in pixels).
4104   _wxvtk3Dbaseview->GetRenderer()->SetBackground( 0.36 , 0.36 , 0.36 );
4105   _wxvtk3Dbaseview->GetRenWin()->SetSize(400, 400);
4106
4107   // Note that when camera movement occurs (as it does in the Dolly()
4108   // method), the clipping planes often need adjusting. Clipping planes
4109   // consist of two planes: near and far along the view direction. The
4110   // near plane clips out objects in front of the plane; the far plane
4111   // clips out objects behind the plane. This way only what is drawn
4112   // between the planes is actually rendered.
4113   _wxvtk3Dbaseview->GetRenderer()->ResetCameraClippingRange();
4114 }
4115 //-------------------------------------------------------------------
4116 void wxVtkClipping3DView::SetVtkClipping3DDataViewer(vtkClipping3DDataViewer *vtkclipping3Ddataviewer)
4117 {
4118         _vtkclipping3Ddataviewer = vtkclipping3Ddataviewer;
4119 }
4120
4121
4122 //---------------------------------------------------------------------------
4123 //---------------------------------------------------------------------------
4124 //---------------------------------------------------------------------------
4125 vtkInteractorStyle3DView::vtkInteractorStyle3DView()
4126 {
4127 }
4128 //---------------------------------------------------------------------------
4129 vtkInteractorStyle3DView::~vtkInteractorStyle3DView()
4130 {
4131 }
4132 //---------------------------------------------------------------------------
4133 bool vtkInteractorStyle3DView::OnLeftDClick()
4134 {
4135         SelectMarchibCubePoint();
4136         return true;
4137 }
4138 //---------------------------------------------------------------------------
4139 bool vtkInteractorStyle3DView::SelectMarchibCubePoint()
4140 {
4141         bool ok=false;
4142     gtm::TVector< double > pO( 3 ), pF( 3 ), pp( 3 ), cp( 3 );
4143     gtm::TVector< double > xc( 3 );
4144     gtm::TVector< double > x1( 3 ), n1( 3 );
4145     gtm::TVector< double > x2( 3 ), n2( 3 );
4146
4147         double pickPoint[ 3 ], cameraPos[ 3 ];
4148         int eventrwi[2];
4149         vtkPointPicker* picker = vtkPointPicker::New( );
4150         eventrwi[0]= _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
4151         eventrwi[1]= _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
4152         vtkRenderer *pRenderer = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetRenderer();
4153         picker->Pick( eventrwi[0], eventrwi[1], 0.0, pRenderer );
4154         pRenderer->GetActiveCamera( )->GetPosition( cameraPos );
4155         picker->GetPickPosition( pickPoint );
4156         picker->Delete( );
4157
4158         pp( 0 ) = pickPoint[ 0 ]; pp( 1 ) = pickPoint[ 1 ]; pp( 2 ) = pickPoint[ 2 ];
4159     cp( 0 ) = cameraPos[ 0 ]; cp( 1 ) = cameraPos[ 1 ]; cp( 2 ) = cameraPos[ 2 ];
4160
4161
4162 //EED 27 sep 2006  (1/2)
4163 //      wxVtkMPR3DView *wxvtkmpr3Dview = (wxVtkMPR3DView *)_vtkInteractorStyleBaseView->GetWxVtk3DBaseView();
4164 //      double spc[3];
4165 //      wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetSpacing(spc);
4166
4167
4168         vtkImageData *imageData = GetWxVtkMPR3DView()->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
4169         int dim[3];
4170         double spc[3];
4171         imageData->GetDimensions(dim);
4172         imageData->GetSpacing(spc);
4173
4174
4175         vtkMarchingCubes *mcubes = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetMCubes(0);
4176
4177
4178         UtilVtk3DGeometriSelection utilVtk3DGeometriSelection;
4179         utilVtk3DGeometriSelection.SetDimentions(dim[0],dim[1],dim[2]);
4180
4181         utilVtk3DGeometriSelection.SetMarchingCube(mcubes);
4182
4183     double fac;
4184     fac = GTM_MAX( dim[0], dim[2] );
4185
4186
4187     if( utilVtk3DGeometriSelection.FindCubePointsFromPoints(
4188       pO.GetAnsiRef( ), pF.GetAnsiRef( ),
4189       pp.GetAnsiRef( ), cp.GetAnsiRef( ) )  )
4190         {
4191
4192                 if( utilVtk3DGeometriSelection.GetPointAndNormalIntersection(
4193                             x1.GetAnsiRef( ), n1.GetAnsiRef( ),
4194                                 pO.GetAnsiRef( ), pF.GetAnsiRef( ) ) )
4195                 {
4196                     if( utilVtk3DGeometriSelection.GetPointAndNormalIntersection(
4197                               x2.GetAnsiRef( ), n2.GetAnsiRef( ),
4198                                  ( x1 - n1 ).GetAnsiRef( ), ( x1 - ( n1 * fac ) ).GetAnsiRef( )   ) )
4199                         {
4200                                 xc = ( x2 + x1 ) * 0.5;
4201 //EED 27 sep 2006  (2/2)
4202                                 this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetX(xc(0)/spc[0]);
4203                                 this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetY(xc(1)/spc[1]);
4204                                 this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetZ(xc(2)/spc[2]);
4205                                 wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
4206                                 this->_wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
4207                                 ok=true;
4208                         }
4209                 }
4210         }
4211
4212
4213         return ok;
4214 }
4215 //-------------------------------------------------------------------
4216 void vtkInteractorStyle3DView::SetWxVtkMPR3DView( wxVtkMPR3DView *wxvtkmpr3Dview )
4217 {
4218         _wxvtkmpr3Dview = wxvtkmpr3Dview;
4219 }
4220 //-------------------------------------------------------------------
4221 wxVtkMPR3DView *vtkInteractorStyle3DView::GetWxVtkMPR3DView()
4222 {
4223         return _wxvtkmpr3Dview;
4224 }
4225 //-------------------------------------------------------------------
4226 wxVtkClipping3DView *vtkInteractorStyle3DView::GetWxVtkClipping3DView()
4227 {
4228         return _wxvtkclipping3Dview;
4229 }
4230 //-------------------------------------------------------------------
4231 void vtkInteractorStyle3DView::SetWxVtkClipping3DView( wxVtkClipping3DView *wxvtkclipping3Dview)
4232 {
4233         _wxvtkclipping3Dview = wxvtkclipping3Dview;
4234 }
4235
4236
4237
4238 //-------------------------------------------------------------------
4239 //-------------------------------------------------------------------
4240 //-------------------------------------------------------------------
4241 void vtkmyPWCallback_3DPointWidget::Execute(vtkObject *caller, unsigned long, void*)
4242 {
4243         double n[3];
4244         double p[3];
4245         double delta = 0.000000001;
4246
4247         vtkInteractorStyleBaseView *isbv = _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetInteractorStyleBaseView();
4248
4249         if (caller==_pointWidget)
4250         {
4251                 _pointWidget->GetPosition(p);
4252         }
4253         if (caller==_planeWidget)
4254         {
4255                 _planeWidget->GetCenter(p);
4256                 _planeWidget->GetNormal(n);
4257                 _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetNormal(n[0],n[1],n[2]);
4258         }
4259
4260         double spc[3];
4261         _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData()->GetSpacing(spc);
4262         p[0]=p[0]/spc[0];
4263         p[1]=p[1]/spc[1];
4264         p[2]=p[2]/spc[2];
4265
4266         // Orientation change
4267         if ( (fabs(n[0]-_backNormal[0])>delta) || (fabs(n[1]-_backNormal[1])>delta) || (fabs(n[2]-_backNormal[2])>delta) )
4268         {
4269                 _backNormal[0] = n[0];
4270                 _backNormal[1] = n[1];
4271                 _backNormal[2] = n[2];
4272                 isbv->SetParent_refresh_waiting();
4273         }
4274
4275         // ----------
4276
4277         double tx = _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetX();
4278         double ty = _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetY();
4279         double tz = _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetZ();
4280
4281         // Position Change
4282         if ( (fabs(tx-p[0])>delta) || (fabs(ty-p[1])>delta) || (fabs(tz-p[2])>delta) )
4283         {
4284                 _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetX( p[0] );
4285                 _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetY( p[1] );
4286                 _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetZ( p[2] );
4287                 vtkInteractorStyleBaseView *isbv = _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetInteractorStyleBaseView();
4288                 isbv->BlockRefresh();
4289                 isbv->vtkInteractorStyleBaseView::OnLeftButtonDown();
4290                 isbv->SetParent_refresh_waiting();
4291                 isbv->vtkInteractorStyleBaseView::OnMouseMove();
4292                 isbv->UnBlockRefresh();
4293         }
4294         isbv->EvaluateToRefresh();
4295 }
4296 //-------------------------------------------------------------------
4297 void vtkmyPWCallback_3DPointWidget::SetWxVtkMPR3DView( wxVtkMPR3DView *wxvtkmpr3Dview )
4298 {
4299         _wxvtkmpr3Dview=wxvtkmpr3Dview;
4300 }
4301 //-------------------------------------------------------------------
4302 void vtkmyPWCallback_3DPointWidget::SetVtkPointWidget( vtkPointWidget *pointWidget )
4303 {
4304         _pointWidget=pointWidget;
4305 }
4306 //-------------------------------------------------------------------
4307 void vtkmyPWCallback_3DPointWidget::SetVtkPlaneWidget( vtkPlaneWidget *planeWidget )
4308 {
4309         _planeWidget=planeWidget;
4310 }
4311 //-------------------------------------------------------------------
4312 //-------------------------------------------------------------------
4313 //-------------------------------------------------------------------
4314
4315 wxPanelCuttingImageData::wxPanelCuttingImageData (wxWindow *parent)
4316 : wxPanel( parent, -1)
4317 {
4318         _imageData=NULL;
4319         _histogrammeVector=NULL;
4320         CreateInterface();
4321         CreateModel();
4322         Create3DViewObjects();
4323 }
4324
4325 //-------------------------------------------------------------------
4326 wxPanelCuttingImageData::~wxPanelCuttingImageData()
4327 {
4328
4329         delete _modelCube;
4330         delete _modelSphere;
4331         delete _modelCylinder;
4332
4333         _vtkcube                -> Delete();
4334         _vtksphere              -> Delete();
4335         _vtkcylinder    -> Delete();
4336         _cubeMapper             -> Delete();
4337         _sphereMapper   -> Delete();
4338         _cylinderMapper -> Delete();
4339         _cubeActor              -> Delete();
4340         _sphereActor    -> Delete();
4341         _cylinderActor  -> Delete();
4342 //      _xyplot->RemoveAllInputs();
4343         _xyplot                 -> Delete();
4344         _histogrammeVector->Delete();
4345
4346         delete _wxvtkbaseView;
4347
4348 }
4349
4350 //-------------------------------------------------------------------
4351 void wxPanelCuttingImageData::RemoveActors()
4352 {
4353         _wxvtk3Dbaseview->GetRenderer()->RemoveActor( _actualActor );
4354 }
4355
4356
4357 //-------------------------------------------------------------------
4358 void wxPanelCuttingImageData::SetWxVtk3DBaseView( wxVtk3DBaseView * wxvtk3Dbaseview )
4359 {
4360         _wxvtk3Dbaseview=wxvtk3Dbaseview;
4361 }
4362
4363 //-------------------------------------------------------------------
4364
4365 void wxPanelCuttingImageData::SetVtkClipping3DDataViewer( vtkClipping3DDataViewer *vtkclipping3Ddataviewer )
4366 {
4367         this->_vtkclipping3Ddataviewer = vtkclipping3Ddataviewer;
4368 }
4369
4370 //-------------------------------------------------------------------
4371 void wxPanelCuttingImageData::Create3DViewObjects()
4372 {
4373         // Sphere
4374         _vtksphere              = vtkSphereSource::New();
4375         _vtksphere->SetThetaResolution (20);
4376         _vtksphere->SetPhiResolution (20);
4377         _sphereMapper   = vtkPolyDataMapper::New();
4378         _sphereMapper->SetInput( _vtksphere->GetOutput() );
4379         _sphereActor    = vtkActor::New();
4380         _sphereActor->SetMapper(_sphereMapper);
4381         _sphereActor->SetOrigin(0, 0, 0);
4382         _sphereActor->SetPosition(0, 0, 0);
4383         _sphereActor->GetProperty()->SetColor(1, 0, 0);
4384         _sphereActor->SetUserTransform( _modelSphere->GetVtkTransform() );
4385
4386         // cube
4387         _vtkcube                = vtkCubeSource::New();
4388         _vtkcube->SetXLength (1);
4389         _vtkcube->SetYLength (1);
4390         _vtkcube->SetZLength (1);
4391         _cubeMapper             = vtkPolyDataMapper::New();
4392         _cubeMapper->SetInput( _vtkcube->GetOutput() );
4393         _cubeActor              = vtkActor::New();
4394         _cubeActor->SetMapper(_cubeMapper);
4395         _cubeActor->SetOrigin(0, 0, 0);
4396         _cubeActor->SetPosition(0, 0, 0);
4397         _cubeActor->GetProperty()->SetColor(1, 0, 0);
4398         _cubeActor->SetUserTransform( _modelCube->GetVtkTransform() );
4399
4400         // cylinder
4401         _vtkcylinder    = vtkCylinderSource::New();
4402         _vtkcylinder->SetResolution(20);
4403         _cylinderMapper = vtkPolyDataMapper::New();
4404         _cylinderMapper->SetInput( _vtkcylinder->GetOutput() );
4405         _cylinderActor  = vtkActor::New();
4406         _cylinderActor->SetMapper(_cylinderMapper);
4407         _cylinderActor->SetOrigin(0, 0, 0);
4408         _cylinderActor->SetPosition(0, 0, 0);
4409         _cylinderActor->GetProperty()->SetColor(1, 0, 0);
4410         _cylinderActor->SetUserTransform( _modelCylinder->GetVtkTransform() );
4411
4412
4413 }
4414
4415 //-------------------------------------------------------------------
4416 void wxPanelCuttingImageData::CreateModel()
4417 {
4418         _modelCube              = new figureCuttingCubeModel();
4419         _modelSphere    = new figureCuttingSphereModel();
4420         _modelCylinder  = new figureCuttingCylinderModel();
4421
4422 //      _modelCube->SetVtkTransform( _modelCube->GetVtkTransform()                      );
4423 //      _modelSphere->SetVtkTransform( _modelSphere->GetVtkTransform()          );
4424 //      _modelCylinder->SetVtkTransform( _modelCylinder->GetVtkTransform()      );
4425 }
4426
4427 //-------------------------------------------------------------------
4428
4429 void wxPanelCuttingImageData::InitHistogramme()
4430 {
4431         double rangeA[2];
4432         if (_imageData==NULL)
4433         {
4434                 rangeA[1]=1;
4435         } else {
4436                 _imageData->GetScalarRange(rangeA);
4437         }
4438         _xyplot->RemoveAllInputs();
4439 /*
4440         if ( _histogrammeVector!=NULL )
4441         {
4442                 _histogrammeVector -> Delete();
4443         }
4444 */
4445         _histogrammeVector =  vtkImageData::New();
4446     _histogrammeVector -> SetDimensions ( (int)(rangeA[1]),1,1 );
4447     _histogrammeVector -> SetScalarTypeToUnsignedShort();
4448     _histogrammeVector -> AllocateScalars();
4449     _histogrammeVector -> Update();
4450
4451         unsigned short *p_vol = (unsigned short*)_histogrammeVector->GetScalarPointer(0,0,0);
4452         int i,size = (int) (rangeA[1]);
4453         for (i=0; i < size; i++)
4454         {
4455                 *p_vol=0;
4456                 p_vol++;
4457         }
4458         _xyplot->SetXRange(0, rangeA[1]);
4459         _xyplot->SetYRange(0, 10);
4460         _xyplot->AddInput( _histogrammeVector );
4461 }
4462
4463 //-------------------------------------------------------------------
4464 wxWindow *wxPanelCuttingImageData::CreatePlotHistogrammeInterface()
4465 {
4466         _xyplot = vtkXYPlotActor::New();
4467         InitHistogramme();
4468         _xyplot->GetPositionCoordinate()->SetValue(0.00, 0.00, 0);
4469         _xyplot->GetPosition2Coordinate()->SetValue(1.0, 1.00, 0); //relative to Position
4470         _xyplot->SetXValuesToArcLength();
4471         _xyplot->SetNumberOfXLabels(6);
4472
4473         _xyplot->SetTitle("Histogramme");
4474         _xyplot->SetXTitle("Gray level");
4475         _xyplot->SetYTitle("Occurrences ");
4476         _xyplot->GetProperty()->SetColor(1, 0, 0);
4477         _xyplot->GetProperty()->SetPointSize(2);
4478         vtkTextProperty *tprop = _xyplot->GetTitleTextProperty();
4479         tprop->SetColor( 1,0,1 );
4480         tprop->BoldOff ();
4481         _xyplot->SetAxisTitleTextProperty(tprop);
4482         _xyplot->SetAxisLabelTextProperty(tprop);
4483         _xyplot->PlotPointsOn();
4484         _xyplot->GetProperty()->SetPointSize(3);
4485
4486         _wxvtkbaseView = new wxVtkBaseView(this);
4487         _wxvtkbaseView->Configure();
4488
4489         vtkRenderer *ren = vtkRenderer::New();
4490         vtkRenderWindow *renWin = _wxvtkbaseView->GetRenWin();
4491         renWin->AddRenderer( ren );
4492         ren->AddActor2D( _xyplot );
4493
4494         return _wxvtkbaseView->GetWxVTKRenderWindowInteractor();
4495 }
4496
4497 //-------------------------------------------------------------------
4498
4499 void wxPanelCuttingImageData::CreateInterface()
4500 {
4501         SetSize(300,500);
4502         wxBoxSizer      *topsizer               = new wxBoxSizer(wxVERTICAL);   // Principal sizer
4503
4504         wxBoxSizer              *sizerH0        = new wxBoxSizer(wxHORIZONTAL   );  // type of segmentation figure
4505         wxBoxSizer          *sizerH2    = new wxBoxSizer(wxHORIZONTAL   );      // scale
4506         wxBoxSizer              *sizerH3        = new wxBoxSizer(wxHORIZONTAL   );      // rotation
4507         wxBoxSizer              *sizerH4        = new wxBoxSizer(wxHORIZONTAL   );  // intern extern
4508         wxBoxSizer              *sizerH5        = new wxBoxSizer(wxHORIZONTAL   );  // Isovalue
4509         wxBoxSizer              *sizerH6        = new wxBoxSizer(wxHORIZONTAL   );  // Buttons
4510         wxFlexGridSizer *sizerH7        = new wxFlexGridSizer(2                 );  // Volumic information
4511
4512
4513         _typeFig        = new wxChoice(this,-1);
4514         _opacityFig     = new wxSlider(this,-1,100,0,100, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
4515
4516         _scaleX         = new wxSlider(this,-1,6,0,500  , wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
4517         _scaleY         = new wxSlider(this,-1,20,0,500 , wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
4518         _scaleZ         = new wxSlider(this,-1,7,0,500  , wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
4519
4520         _rotationX      = new wxSlider(this,-1,0,-360,360, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
4521         _rotationY      = new wxSlider(this,-1,0,-360,360, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
4522         _rotationZ      = new wxSlider(this,-1,0,-360,360, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
4523
4524         _volIntern              = new wxRadioButton(this,-1, _T("Volume intern " ));
4525         _volExtern              = new wxRadioButton(this,-1, _T("Volume extern " ));
4526
4527         _histogrammeAccumulated = new wxCheckBox(this,-1,_T("Histogramme accumulated"));
4528
4529         _isoValue                               = new wxSlider(this,-1, 200, 0,2000, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
4530         _valueBeforeIsoValue    = new wxSlider(this,-1,-1,-1,2000, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
4531         _valueAfterIsoValue             = new wxSlider(this,-1,-1,-1,2000, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
4532
4533         wxButton *btnExtract    = new wxButton(this, -1,_T("Extract"));
4534
4535         _infoToVo       = new wxStaticText(this,-1,_T("########################"));
4536         _infoSuVoA      = new wxStaticText(this,-1,_T("############"));
4537         _infoSuVo       = new wxStaticText(this,-1,_T("############"));
4538         _infoPixLe      = new wxStaticText(this,-1,_T("############"));
4539         _infoPixHi      = new wxStaticText(this,-1,_T("############"));
4540
4541
4542         wxWindow *panelPlotHistogramme = CreatePlotHistogrammeInterface();
4543
4544         _typeFig->Append(_T("Cylindre"));
4545         _typeFig->Append(_T("Cube"));
4546         _typeFig->Append(_T("Sphere"));
4547         _typeFig->SetSelection(0);
4548         _volIntern->SetValue(true);
4549
4550         Connect(_typeFig->GetId()                               , wxEVT_COMMAND_CHOICE_SELECTED         , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTypeFig );
4551
4552         Connect(_opacityFig->GetId()                    , wxEVT_COMMAND_SLIDER_UPDATED          , (wxObjectEventFunction) &wxPanelCuttingImageData::OnOpacityFig );
4553         Connect(_rotationX->GetId()                             , wxEVT_COMMAND_SLIDER_UPDATED          , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTransform );
4554         Connect(_rotationY->GetId()                             , wxEVT_COMMAND_SLIDER_UPDATED          , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTransform );
4555         Connect(_rotationZ->GetId()                             , wxEVT_COMMAND_SLIDER_UPDATED          , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTransform );
4556         Connect(_scaleX->GetId()                                , wxEVT_COMMAND_SLIDER_UPDATED          , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTransform );
4557         Connect(_scaleY->GetId()                                , wxEVT_COMMAND_SLIDER_UPDATED          , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTransform );
4558         Connect(_scaleZ->GetId()                                , wxEVT_COMMAND_SLIDER_UPDATED          , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTransform );
4559         Connect(btnExtract->GetId()                             , wxEVT_COMMAND_BUTTON_CLICKED          , (wxObjectEventFunction) &wxPanelCuttingImageData::OnExtract   );
4560
4561
4562 //      wxStaticText *text=new wxStaticText(this,-1, " ");
4563
4564         sizerH0 -> Add( new wxStaticText(this,-1, _T("Fig. Type:   "),wxDefaultPosition, wxSize(50,20)) ,1,wxALL  ,0);
4565         sizerH0 -> Add( _typeFig                ,1,wxALL  ,0);
4566         sizerH0 -> Add( _opacityFig             ,1,wxALL|wxEXPAND  ,0);
4567
4568         sizerH2 -> Add( new wxStaticText(this,-1,_T("Scale :   "))              ,1,wxALL  ,0);
4569         sizerH2 -> Add( _scaleX         ,1,wxALL | wxEXPAND ,0 );
4570         sizerH2 -> Add( _scaleY         ,1,wxALL | wxEXPAND ,0 );
4571         sizerH2 -> Add( _scaleZ         ,1,wxALL | wxEXPAND ,0 );
4572
4573         sizerH3 -> Add( new wxStaticText(this,-1,_T("Rotation :   "))   ,1,wxALL  ,0);
4574         sizerH3 -> Add( _rotationX      ,1,wxALL | wxEXPAND ,0 );
4575         sizerH3 -> Add( _rotationY      ,1,wxALL | wxEXPAND ,0 );
4576         sizerH3 -> Add( _rotationZ      ,1,wxALL | wxEXPAND ,0 );
4577
4578
4579         sizerH4 -> Add( new wxStaticText(this,-1,_T("Intern / Extern :   "))    ,1,wxALL  ,0);
4580         sizerH4 -> Add( _volIntern                                              ,1,wxALL  ,0);
4581         sizerH4 -> Add( new wxStaticText(this,-1, _T(" "))      ,1,wxALL  ,0);
4582         sizerH4 -> Add( _volExtern                                              ,1,wxALL  ,0);
4583
4584         sizerH5 -> Add( new wxStaticText(this,-1,_T("Isovalue   "))     ,1,wxALL  ,0);
4585         sizerH5 -> Add( _isoValue                                               ,1,wxALL | wxEXPAND ,0 );
4586         sizerH5 -> Add( _valueBeforeIsoValue                    ,1,wxALL | wxEXPAND ,0 );
4587         sizerH5 -> Add( _valueAfterIsoValue                             ,1,wxALL | wxEXPAND ,0 );
4588
4589         sizerH6 -> Add( new wxStaticText(this,-1, _T(" "))              ,1,wxALL  ,0);
4590         sizerH6 -> Add( btnExtract      ,1,wxALL  ,0);
4591
4592         sizerH7 -> Add( new wxStaticText(this,-1,_T("Total Volume: "), wxDefaultPosition, wxSize(200,12))                       , 1 , wxALL  ,0);
4593         sizerH7 -> Add( _infoToVo                                                                               , 1 , wxALL  ,0);
4594         sizerH7 -> Add( new wxStaticText(this,-1,_T("SubVolume:   "), wxDefaultPosition, wxSize(200,12) )               , 1 , wxALL  ,0);
4595         sizerH7 -> Add( _infoSuVo                                                                               , 1 , wxALL  ,0);
4596         sizerH7 -> Add( new wxStaticText(this,-1,_T("SubVolume (ana.): "), wxDefaultPosition, wxSize(200,12))   , 1 , wxALL  ,0);
4597         sizerH7 -> Add( _infoSuVoA                                                                              , 1 , wxALL  ,0);
4598         sizerH7 -> Add( new wxStaticText(this,-1,_T("Pix < isovalue:   ") , wxDefaultPosition, wxSize(200,12))  , 1 , wxALL  ,0);
4599         sizerH7 -> Add( _infoPixLe                                                                              , 1 , wxALL  ,0);
4600         sizerH7 -> Add( new wxStaticText(this,-1,_T("Pix > isovalue: "), wxDefaultPosition, wxSize(200,12))     , 1 , wxALL  ,0);
4601         sizerH7 -> Add( _infoPixHi                                                                              , 1 , wxALL  ,0);
4602 //      sizerH7 -> SetMinSize(300, 120);
4603
4604         // Figure type
4605         topsizer -> Add( sizerH0 ,1,wxALL|wxEXPAND  ,0);
4606
4607         // Scale
4608         topsizer -> Add( sizerH2 ,1,wxALL|wxEXPAND  ,0);
4609
4610         // Rotation
4611         topsizer -> Add( sizerH3 ,1,wxALL|wxEXPAND  ,0);
4612
4613         // Intern / Extern
4614         topsizer -> Add( sizerH4 ,1,wxALL  ,0);
4615
4616
4617         // Isovalue limite
4618         topsizer -> Add( sizerH5 ,1,wxALL |wxEXPAND ,0);
4619
4620         // btn Extraction
4621         topsizer -> Add( sizerH6        , 1 , wxALL  ,0);
4622
4623         // Histograme
4624         topsizer -> Add( _histogrammeAccumulated ,1,  wxALL  ,0);
4625
4626         // Volumic information
4627         topsizer -> Add( sizerH7                                , 1 , wxALL|wxEXPAND   ,0);
4628
4629
4630
4631 //    wxBoxSizer *sizerHor = new wxBoxSizer(wxHORIZONTAL);
4632     wxBoxSizer *sizerHor = new wxBoxSizer(wxVERTICAL);
4633         sizerHor -> Add( topsizer                               , 1 , wxALL | wxEXPAND  ,0);
4634         sizerHor -> Add( panelPlotHistogramme   , 1 , wxGROW  ,0);
4635
4636
4637         this->SetAutoLayout(true);
4638         this->SetSizer( sizerHor );
4639         this->Layout();
4640 //EEDxx2.4
4641 //      this->FitInside();
4642 }
4643
4644 //-------------------------------------------------------------------
4645
4646 void wxPanelCuttingImageData::OnExtract(wxCommandEvent& event)
4647 {
4648         wxBusyCursor wait;
4649
4650         bool                    inside;
4651         bool                    volInt, volExt;
4652         int                             xx,yy,zz;
4653         unsigned short  *pOrg;
4654         unsigned short  *p_histogramme;
4655         int                             dim[3];
4656         double                  spc[3];
4657         long int                contAfter = 0;
4658         long int                contBefor = 0;
4659
4660         double min=999999999;
4661         double max=-999999999;
4662
4663         volExt=_volExtern->GetValue();
4664         volInt=_volIntern->GetValue();
4665         int isoValue                = _isoValue->GetValue();
4666         int valueBeforeIsoValue = _valueBeforeIsoValue->GetValue();
4667         int valueAfterIsoValue  = _valueAfterIsoValue ->GetValue();
4668
4669         InitHistogramme();
4670         p_histogramme = (unsigned short*)_histogrammeVector->GetScalarPointer(0,0,0);
4671
4672         _imageData->GetDimensions(dim);
4673         _imageData->GetSpacing(spc);
4674         _actualCuttingModel->CalculeInversMatrix();
4675
4676         for (xx=0;xx<dim[0]; xx++)
4677         {
4678                 for (yy=0;yy<dim[1]; yy++)
4679                 {
4680                         for (zz=0;zz<dim[2];zz++)
4681                         {
4682                                 inside=_actualCuttingModel->IfPointInside(xx,yy,zz);
4683                                 if (  ((inside==true)&&(volInt==true)) || ((!inside==true)&&(volExt==true)) )
4684                                 {
4685                                         pOrg=(unsigned short*)_imageData->GetScalarPointer (xx,yy,zz);
4686
4687                                         if ((*pOrg)<isoValue)
4688                                         {
4689                                                 contBefor++;
4690                                                 if (valueBeforeIsoValue!=-1)
4691                                                 {
4692                                                         *pOrg=valueBeforeIsoValue;
4693                                                 }
4694                                         } else {
4695                                                 contAfter++;
4696                                                 if (valueAfterIsoValue!=-1)
4697                                                 {
4698                                                         *pOrg=valueAfterIsoValue;
4699                                                 } // if
4700                                         } // if isovalue
4701
4702                                         p_histogramme[*pOrg]++;
4703                                         if (*pOrg<min) min=*pOrg;
4704                                         if (*pOrg>max) max=*pOrg;
4705                                 } // if inside
4706                         } // for zz
4707                 } // for yy
4708         } // for xx
4709
4710
4711         // Information
4712         wxString infoToVo;
4713         wxString infoSuVo;
4714         wxString infoSuVoA;
4715         wxString infoPixLe;
4716         wxString infoPixHi;
4717
4718         double volumeUnit = spc[0]*spc[1]*spc[2];
4719         long int totalSubVolume = contBefor + contAfter;
4720         double contBeforPorc    = 100*(double)contBefor/(double)totalSubVolume;
4721         double contAfterPorc    = 100*(double)contAfter/(double)totalSubVolume;
4722         infoToVo.Printf(_T("%dx%dx%d = %d"),dim[0],dim[1],dim[2], dim[0]*dim[1]*dim[2] );
4723         infoSuVo.Printf(_T("%ld") , totalSubVolume);
4724         infoSuVoA.Printf(_T("%.2f"), _actualCuttingModel->GetTheoricVolume() );
4725         infoPixLe.Printf(_T("%ld pix.   (%.2f %s)  -  %.2f mm^3"),contBefor, contBeforPorc ,_T("%"),contBefor*volumeUnit);
4726         infoPixHi.Printf(_T("%ld pix.   (%.2f %s)  -  %.2f mm^3"),contAfter, contAfterPorc ,_T("%"),contAfter*volumeUnit);
4727
4728         _infoToVo->SetLabel(infoToVo);
4729         _infoSuVo->SetLabel(infoSuVo);
4730         _infoSuVoA->SetLabel(infoSuVoA);
4731         _infoPixLe->SetLabel(infoPixLe);
4732         _infoPixHi->SetLabel(infoPixHi);
4733
4734         // Histogram
4735         if ( _histogrammeAccumulated->GetValue()==true )
4736         {
4737                 int dimHist[3];
4738                 _histogrammeVector -> GetDimensions ( dimHist );
4739
4740                 int i,size=dimHist[0];
4741                 for (i=1; i<=size; i++)
4742                 {
4743                         p_histogramme[i] = p_histogramme[i] + p_histogramme[i-1];
4744                 }
4745         }
4746         double range[2];
4747         _histogrammeVector->Update();
4748         _histogrammeVector->GetScalarRange(range);
4749         _xyplot->SetYRange( 0   , range[1]      );
4750         _xyplot->SetXRange( min , max           );
4751
4752         _vtkclipping3Ddataviewer->RefreshSurface();
4753         _wxvtkbaseView->Refresh();
4754
4755 //      _wxvtkbaseView->RefreshView();
4756         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
4757         _wxvtkbaseView->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
4758 }
4759
4760
4761 //-------------------------------------------------------------------
4762 void wxPanelCuttingImageData::OnTypeFig(wxCommandEvent& event)
4763 {
4764         _wxvtk3Dbaseview->GetRenderer()->RemoveActor( _actualActor );
4765
4766         if (_typeFig->GetSelection()==0){
4767                 _actualCuttingModel=_modelCylinder;
4768                 _actualActor=_cylinderActor;
4769         }
4770         if (_typeFig->GetSelection()==1){
4771                 _actualCuttingModel=_modelCube;
4772                 _actualActor=_cubeActor;
4773         }
4774         if (_typeFig->GetSelection()==2){
4775                 _actualCuttingModel=_modelSphere;
4776                 _actualActor=_sphereActor;
4777         }
4778         _wxvtk3Dbaseview->GetRenderer()->AddActor( _actualActor );
4779         RefreshOpacity();
4780         RefreshView();
4781 }
4782
4783 //-------------------------------------------------------------------
4784 void wxPanelCuttingImageData::RefreshOpacity()
4785 {
4786         double op= _opacityFig->GetValue()/100.0;
4787         _actualActor->GetProperty()->SetOpacity( op );
4788 }
4789
4790 //-------------------------------------------------------------------
4791 void wxPanelCuttingImageData::OnOpacityFig(wxScrollEvent& event)
4792 {
4793         RefreshOpacity();
4794         Refresh();
4795 }
4796 //-------------------------------------------------------------------
4797 void wxPanelCuttingImageData::RefreshView()
4798 {
4799         SetParamsOfTransformation( );
4800         Refresh();
4801 }
4802 //-------------------------------------------------------------------
4803 void wxPanelCuttingImageData::Refresh()
4804 {
4805         _wxvtk3Dbaseview->Refresh();
4806 }
4807
4808 //-------------------------------------------------------------------
4809 void wxPanelCuttingImageData::SetParamsOfTransformation( )
4810 {
4811         double spc[3];
4812         vtkImageData *vtkimagedata = _vtkmprbasedata->GetImageData();
4813         vtkimagedata->GetSpacing(spc);
4814         int px = (int) (_vtkmprbasedata->GetX() );
4815         int py = (int) (_vtkmprbasedata->GetY() );
4816         int pz = (int) (_vtkmprbasedata->GetZ() );
4817         int sx = (int) (_scaleX->GetValue() * spc[0] );
4818         int sy = (int) (_scaleY->GetValue() * spc[1] );
4819         int sz = (int) (_scaleZ->GetValue() * spc[2] );
4820         _actualCuttingModel     -> SetScale             ( sx    , sy    , sz );
4821         _actualCuttingModel     -> SetPosition  ( px    , py , pz       );
4822         _actualCuttingModel     -> SetRotation  ( _rotationX->GetValue()        , _rotationY->GetValue() , _rotationZ->GetValue()       );
4823         _actualCuttingModel     -> SetSpacing   ( spc[0]        , spc[1]    , spc[2] );
4824         _actualCuttingModel     -> CalculeMatrix();
4825 }
4826
4827 //-------------------------------------------------------------------
4828
4829 void wxPanelCuttingImageData::OnTransform(wxScrollEvent& event)
4830 {
4831         RefreshView();
4832 }
4833
4834 //-------------------------------------------------------------------
4835 void wxPanelCuttingImageData::SetVtkMPRBaseData( vtkMPRBaseData *vtkmprbasedata )
4836 {
4837         _vtkmprbasedata = vtkmprbasedata;
4838         _imageData              = _vtkmprbasedata->GetImageData();
4839 }
4840
4841 //-------------------------------------------------------------------
4842
4843 void wxPanelCuttingImageData::Configure()
4844 {
4845         _actualCuttingModel=_modelCylinder;
4846         _actualActor=_cylinderActor;
4847         _wxvtk3Dbaseview->GetRenderer()->AddActor( _actualActor );
4848         SetParamsOfTransformation();
4849         RefreshView();
4850 }
4851
4852
4853
4854 //-------------------------------------------------------------------
4855 //-------------------------------------------------------------------
4856 //-------------------------------------------------------------------
4857
4858 /*
4859 BEGIN_EVENT_TABLE( wxWidgetMesure2D , wxSplitterWindow )
4860         EVT_MENU( 12121, wxWidgetMesure2D::OnRefreshView )
4861 END_EVENT_TABLE( );
4862 */
4863 //-------------------------------------------------------------------
4864
4865 wxWidgetMesure2D::wxWidgetMesure2D( wxWindow *parent )
4866 : wxSplitterWindow( parent , -1)
4867 {
4868 // EED 27 oct 2007
4869         this->SplitHorizontally( new wxPanel(this,-1) ,  new wxPanel(this,-1), 2 );
4870         this->SetMinimumPaneSize(50);
4871 }
4872 //-------------------------------------------------------------------
4873 wxWidgetMesure2D::~wxWidgetMesure2D()
4874 {
4875 }
4876 //-------------------------------------------------------------------
4877 wxWindow *wxWidgetMesure2D::CreateWin1a(wxWindow *parent) // virtual
4878 {
4879         wxPanel *panel = new wxPanel(parent,-1);
4880
4881         _cb_messuretool  = new wxCheckBox(panel,-1,_T("Active messure tool     "));
4882         _cb_mt_visible   = new wxCheckBox(panel,-1,_T("Visibles    "));
4883         _cb_closeContour = new wxCheckBox(panel,-1,_T("Close/Open    "));
4884         _cb_visibleText  = new wxCheckBox(panel,-1,_T("Information    "));
4885
4886         _cb_mt_visible->SetValue(true);
4887         _cb_closeContour->SetValue(true);
4888         _cb_visibleText->SetValue(true);
4889
4890         wxFlexGridSizer *sizer = new wxFlexGridSizer(4);
4891
4892         sizer->Add(_cb_messuretool);
4893         sizer->Add(_cb_mt_visible);
4894         sizer->Add(_cb_closeContour);
4895         sizer->Add(_cb_visibleText);
4896
4897         panel->SetAutoLayout(true);
4898         panel->SetSizer(sizer);
4899         panel->SetSize(400,30);
4900         panel->Layout();
4901 //EEDxx2.4
4902 //      panel->FitInside();
4903
4904         Connect(_cb_messuretool->GetId()  , wxEVT_COMMAND_CHECKBOX_CLICKED        , (wxObjectEventFunction) &wxWidgetMesure2D::OnActiveMessureTool      );
4905         Connect(_cb_mt_visible->GetId()   , wxEVT_COMMAND_CHECKBOX_CLICKED        , (wxObjectEventFunction) &wxWidgetMesure2D::OnVisibleMessureTool     );
4906         Connect(_cb_closeContour->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED        , (wxObjectEventFunction) &wxWidgetMesure2D::OnCloseContour           );
4907         Connect(_cb_visibleText->GetId()  , wxEVT_COMMAND_CHECKBOX_CLICKED        , (wxObjectEventFunction) &wxWidgetMesure2D::OnVisibleInformation     );
4908
4909         return panel;
4910 }
4911
4912 //-------------------------------------------------------------------
4913 void wxWidgetMesure2D::ConfigureA(wxVtk2DBaseView *wxvtk2Dbaseview) // virtual
4914 {
4915         _wxvtk2Dbaseview = wxvtk2Dbaseview;
4916
4917         // Contorno 1
4918         _manContourControl_1    = new manualContourControler();
4919         _mContourModel_1                = new manualContourModel();
4920         _mViewContour_1                 = new manualViewContour();
4921         _mViewContour_1->SetModel( _mContourModel_1 );
4922         _mViewContour_1->SetWxVtkBaseView( _wxvtk2Dbaseview );
4923         _mViewContour_1->SetRange( 1 );
4924
4925 // EED 3 oct 2006
4926 //      double spc[3];
4927 //      _wxvtk2Dbaseview->GetSpacing( spc );
4928 //      _mViewContour_1->SetSpacing( spc );
4929
4930
4931
4932         _manContourControl_1->SetZ( 1000 );
4933         _manContourControl_1->SetModelView( _mContourModel_1 , _mViewContour_1 );
4934         _wxvtk2Dbaseview->GetInteractorStyleBaseView()->AddInteractorStyleMaracas( _manContourControl_1 );
4935         _manContourControl_1->CreateNewManualContour();
4936         _manContourControl_1->SetActive( false );
4937         _mViewContour_1->RefreshContour();
4938
4939 //EED 27 Oct 2007
4940
4941 //      this->ReplaceWindow( this->GetWindow1() ,  CreateWin1a(this) );
4942 //      this->ReplaceWindow( this->GetWindow2() ,  _wxvtk2Dbaseview->GetWxVTKRenderWindowInteractor() );
4943 //      CreateWin1a(this->GetWindow1() );
4944
4945         wxBoxSizer *sizerA = new wxBoxSizer(wxHORIZONTAL);
4946         sizerA->Add(  CreateWin1a( this->GetWindow1()) ,1, wxGROW );
4947         this->GetWindow1()->SetSizer(sizerA);
4948         this->SetAutoLayout(true);
4949         this->Layout();
4950
4951         wxBoxSizer *sizerB = new wxBoxSizer(wxHORIZONTAL);
4952         sizerB->Add(  _wxvtk2Dbaseview->GetWxVTKRenderWindowInteractor()  ,1, wxGROW );
4953         this->GetWindow2()->SetSizer(sizerB);
4954         this->SetAutoLayout(true);
4955         this->Layout();
4956
4957
4958 //      this->SplitHorizontally( CreateWin1a(this) , _wxvtk2Dbaseview->GetWxVTKRenderWindowInteractor() , 2 );
4959
4960
4961 //EEDxx2.4
4962 //      this->FitInside();
4963 }
4964
4965
4966 //-------------------------------------------------------------------
4967 void wxWidgetMesure2D::ActiveMessureTool(bool ok)
4968 {
4969         _wxvtk2Dbaseview->GetInteractorStyleBaseView()->SetActiveAllInteractors(!ok);
4970         _manContourControl_1->SetActive( ok );
4971 }
4972
4973 //-------------------------------------------------------------------
4974 void wxWidgetMesure2D::OnActiveMessureTool(wxCommandEvent& event)
4975 {
4976         ActiveMessureTool( _cb_messuretool->GetValue() );
4977         if ( _cb_messuretool->GetValue() == true )
4978         {
4979                 _cb_mt_visible->SetValue(true);
4980                 _mViewContour_1->SetVisible( _cb_mt_visible->GetValue() );
4981                 _cb_closeContour->Enable(true);
4982                 _cb_visibleText->Enable(true);
4983         } else{
4984                 _cb_closeContour->Enable(false);
4985                 _cb_visibleText->Enable(false);
4986         }
4987         _wxvtk2Dbaseview->Refresh();
4988         _wxvtk2Dbaseview->RefreshView();
4989 }
4990
4991 //-------------------------------------------------------------------
4992 void wxWidgetMesure2D::OnVisibleMessureTool(wxCommandEvent& event)
4993 {
4994         _cb_messuretool->SetValue( _cb_mt_visible->GetValue() );
4995         if (_cb_messuretool->GetValue()==true)
4996         {
4997                 _cb_closeContour->Enable(true);
4998                 _cb_visibleText->Enable(true);
4999         }
5000         ActiveMessureTool( _cb_messuretool->GetValue() );
5001         _mViewContour_1->SetVisible( _cb_mt_visible->GetValue() );
5002         _mViewContour_1->Refresh();
5003         _wxvtk2Dbaseview->Refresh();
5004         _wxvtk2Dbaseview->RefreshView();
5005 }
5006
5007 //-------------------------------------------------------------------
5008 void wxWidgetMesure2D::OnCloseContour(wxCommandEvent& event)
5009 {
5010         _mContourModel_1->SetCloseContour( _cb_closeContour->GetValue() );
5011         _mViewContour_1->Refresh();
5012         _wxvtk2Dbaseview->Refresh();
5013         _wxvtk2Dbaseview->RefreshView();
5014
5015 }
5016 //-------------------------------------------------------------------
5017 void wxWidgetMesure2D::OnVisibleInformation(wxCommandEvent& event)
5018 {
5019         _mViewContour_1->SetShowText( _cb_visibleText->GetValue() );
5020         _mViewContour_1->Refresh();
5021         _wxvtk2Dbaseview->Refresh();
5022         _wxvtk2Dbaseview->RefreshView();
5023 }
5024 //-------------------------------------------------------------------
5025 void wxWidgetMesure2D::SetMesureScale(double mesureScale)
5026 {
5027         _mViewContour_1->SetMesureScale(mesureScale);
5028 }
5029 //-------------------------------------------------------------------
5030 manualContourModel*     wxWidgetMesure2D::GetManualContourModel()
5031 {
5032         return _mContourModel_1;
5033 }
5034
5035 //-------------------------------------------------------------------
5036 //-------------------------------------------------------------------
5037 //-------------------------------------------------------------------
5038
5039 wxWidgetMesure2D_Plane::wxWidgetMesure2D_Plane(wxWindow *parent)
5040 : wxWidgetMesure2D(parent)
5041 {
5042         // Circle 1
5043         _ptsCircle1             = NULL;
5044         _circle1Actor   = NULL;
5045         _circle1Mapper  = NULL;
5046     _pdCircle1          = NULL;
5047         // Circle 2
5048         _ptsCircle2             = NULL;
5049         _circle2Actor   = NULL;
5050         _circle2Mapper  = NULL;
5051     _pdCircle2          = NULL;
5052         // line reference 1
5053         _ptsLineRef1    = NULL;
5054         _lineRef1Actor  = NULL;
5055         _lineRef1Mapper = NULL;
5056     _pdLineRef1         = NULL;
5057         // line reference 2
5058         _ptsLineRef2    = NULL;
5059         _lineRef2Actor  = NULL;
5060         _lineRef2Mapper = NULL;
5061     _pdLineRef2         = NULL;
5062
5063 }
5064
5065 //-------------------------------------------------------------------
5066
5067 wxWidgetMesure2D_Plane::~wxWidgetMesure2D_Plane()
5068 {
5069         // Circle 1
5070     if (        _ptsCircle1             != NULL){       _ptsCircle1                     -> Delete(); }
5071     if (        _circle1Actor   != NULL){       _circle1Actor           -> Delete(); }
5072     if (        _circle1Mapper  != NULL){       _circle1Mapper          -> Delete(); }
5073     if (    _pdCircle1          != NULL){       _pdCircle1                      -> Delete(); }
5074         // Circle 2
5075     if (        _ptsCircle2             != NULL){       _ptsCircle2                     -> Delete(); }
5076     if (        _circle2Actor   != NULL){       _circle2Actor           -> Delete(); }
5077     if (        _circle2Mapper  != NULL){       _circle2Mapper          -> Delete(); }
5078     if (    _pdCircle2          != NULL){       _pdCircle2                      -> Delete(); }
5079         // line reference 1
5080     if (        _ptsLineRef1    != NULL){       _ptsLineRef1            -> Delete(); }
5081     if (        _lineRef1Actor  != NULL){       _lineRef1Actor          -> Delete(); }
5082     if (        _lineRef1Mapper != NULL){       _lineRef1Mapper         -> Delete(); }
5083      if (   _pdLineRef1         != NULL){       _pdLineRef1                     -> Delete(); }
5084         // line reference 2
5085     if (        _ptsLineRef2    != NULL){       _ptsLineRef2            -> Delete(); }
5086     if (        _lineRef2Actor  != NULL){       _lineRef2Actor          -> Delete(); }
5087     if (        _lineRef2Mapper != NULL){       _lineRef2Mapper         -> Delete(); }
5088     if (    _pdLineRef2         != NULL){       _pdLineRef2                     -> Delete(); }
5089 }
5090
5091 //-------------------------------------------------------------------
5092
5093 wxWindow *wxWidgetMesure2D_Plane::CreateWin1a(wxWindow *parent) // virtual
5094 {
5095         wxPanel *panel = new wxPanel(parent,-1);
5096
5097         _cb_circle              = new wxCheckBox(panel,-1,_T("Circle        "));
5098         _cb_line                = new wxCheckBox(panel,-1,_T("Rotation Axe "));
5099
5100
5101         wxBoxSizer *sizerA = new wxBoxSizer(wxHORIZONTAL);
5102         sizerA->Add(_cb_circle);
5103         sizerA->Add(_cb_line);
5104
5105
5106         wxFlexGridSizer *sizer = new wxFlexGridSizer(1);
5107         sizer->Add( sizerA );
5108         sizer->Add( wxWidgetMesure2D::CreateWin1a(panel) );
5109
5110         panel->SetAutoLayout(true);
5111         panel->SetSizer(sizer);
5112         panel->SetSize(400,30);
5113         panel->Layout();
5114 //EEDxx2.4
5115 //      panel->FitInside();
5116
5117         Connect(_cb_line->GetId()        , wxEVT_COMMAND_CHECKBOX_CLICKED         , (wxObjectEventFunction) &wxWidgetMesure2D_Plane::OnActiveLine                       );
5118         Connect(_cb_circle->GetId()      , wxEVT_COMMAND_CHECKBOX_CLICKED         , (wxObjectEventFunction) &wxWidgetMesure2D_Plane::OnActiveCirlcle            );
5119
5120         return panel;
5121 }
5122
5123
5124 //-------------------------------------------------------------------
5125 void wxWidgetMesure2D_Plane::OnActiveCirlcle(wxCommandEvent& event)
5126 {
5127         SetVisibleCircle( _cb_circle->GetValue() );
5128         _wxvtk2Dbaseview->RefreshView();
5129 }
5130
5131 //-------------------------------------------------------------------
5132 void wxWidgetMesure2D_Plane::SetVisibleCircle( bool ok )
5133 {
5134         double opacity;
5135         if (ok==true)
5136         {
5137                 opacity=1;
5138         } else {
5139                 opacity=0;
5140         }
5141         _lineRef1Actor->GetProperty()->SetOpacity( opacity );
5142         _lineRef2Actor->GetProperty()->SetOpacity( opacity );
5143         _circle1Actor->GetProperty()->SetOpacity( opacity );
5144         _circle2Actor->GetProperty()->SetOpacity( opacity );
5145 }
5146 //-------------------------------------------------------------------
5147 void wxWidgetMesure2D_Plane::OnActiveLine(wxCommandEvent& event)
5148 {
5149         vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)_wxvtk2Dbaseview;
5150         vtkplane2Dview->SetVisibleLine( _cb_line->GetValue() );
5151         _wxvtk2Dbaseview->RefreshView();
5152 }
5153
5154
5155 //-------------------------------------------------------------------
5156 void wxWidgetMesure2D_Plane::ConfigureA(wxVtk2DBaseView *wxvtk2Dbaseview) // virtual
5157 {
5158         wxWidgetMesure2D::ConfigureA(wxvtk2Dbaseview);
5159         CircleLine();
5160         ConfigureCircleLine();
5161         SetVisibleCircle(false);
5162 }
5163
5164
5165 //-------------------------------------------------------------------
5166 void wxWidgetMesure2D_Plane::ConfigureCircleLine()
5167 {
5168         double ang;
5169
5170         vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)_wxvtk2Dbaseview;
5171         int sizeIma = vtkplane2Dview->GetImgSize();
5172
5173         double i,maxPts=20;
5174         double k=(360/(maxPts-1)) * (3.1416/180);
5175         double x,y,r1=5,r2=10,r3=15;
5176         for (i=0;i<maxPts;i++)
5177         {
5178                 x=cos( k*i ) ;
5179                 y=sin( k*i ) ;
5180                 _ptsCircle1->SetPoint( (int)i , (sizeIma/2) + x*r1      , (sizeIma/2) + y*r1    , 1 );
5181                 _ptsCircle2->SetPoint( (int)i , (sizeIma/2) + x*r2      , (sizeIma/2) + y*r2    , 1 );
5182         }
5183
5184         //
5185         ang=(45) * (3.1416/180);
5186         x=cos( ang ) ;
5187         y=sin( ang ) ;
5188         _ptsLineRef1->SetPoint( 0 , (sizeIma/2) + x*r3  , (sizeIma/2) + y*r3    , 1 );
5189
5190         ang=(45+180) * (3.1416/180);
5191         x=cos( ang ) ;
5192         y=sin( ang ) ;
5193         _ptsLineRef1->SetPoint( 1 , (sizeIma/2) + x*r3  , (sizeIma/2) + y*r3    , 1 );
5194
5195         //
5196         ang=(135) * (3.1416/180);
5197         x=cos( ang ) ;
5198         y=sin( ang ) ;
5199         _ptsLineRef2->SetPoint( 0 , (sizeIma/2) + x*r3  , (sizeIma/2) + y*r3    , 1 );
5200
5201         ang=(135+180) * (3.1416/180);
5202         x=cos( ang ) ;
5203         y=sin( ang ) ;
5204         _ptsLineRef2->SetPoint( 1 , (sizeIma/2) + x*r3  , (sizeIma/2) + y*r3    , 1 );
5205 }
5206
5207
5208
5209 //-------------------------------------------------------------------
5210 void wxWidgetMesure2D_Plane::CircleLine()
5211 {
5212         int i,maxPts=20;
5213         vtkCellArray *lines;
5214
5215         vtkImageViewer2_XYZ *imageViewer2XYZ = _wxvtk2Dbaseview->_imageViewer2XYZ;
5216
5217
5218 // Circle 1 Horizontal
5219         _ptsCircle1 = vtkPoints::New();
5220         _ptsCircle1->SetNumberOfPoints(maxPts);
5221         lines = vtkCellArray::New();
5222         lines->InsertNextCell(maxPts);
5223         for (i=0;i<maxPts;i++)
5224         {
5225                 lines->InsertCellPoint(i);
5226                 _ptsCircle1->SetPoint(i, 0      , 0     , 0 );
5227         }
5228         lines->InsertCellPoint(0);
5229         _ptsCircle1->SetPoint(0, -1000  , -1000 , -1000 );
5230         _ptsCircle1->SetPoint(1,  1000  ,  1000 ,  1000 );
5231
5232         _pdCircle1 = vtkPolyData::New();
5233     _pdCircle1->SetPoints( _ptsCircle1 );
5234     _pdCircle1->SetLines( lines );
5235         lines->Delete();  //do not delete lines ??
5236         _circle1Actor                                   =       vtkActor::New();
5237     _circle1Mapper                                      =       vtkPolyDataMapper::New();
5238         _circle1Mapper->SetInput(_pdCircle1);
5239         _circle1Mapper->ImmediateModeRenderingOn();
5240         _circle1Actor->SetMapper(_circle1Mapper);
5241         _circle1Actor->GetProperty()->BackfaceCullingOn();
5242         _circle1Actor->GetProperty()->SetDiffuseColor(0,0,1);
5243         _circle1Actor->GetProperty()->SetLineWidth(2);
5244     imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _circle1Actor );
5245
5246 // Circle 2 Horizontal
5247         _ptsCircle2 = vtkPoints::New();
5248         _ptsCircle2->SetNumberOfPoints(maxPts);
5249         lines = vtkCellArray::New();
5250         lines->InsertNextCell(maxPts);
5251         for (i=0;i<maxPts;i++)
5252         {
5253                 lines->InsertCellPoint(i);
5254                 _ptsCircle2->SetPoint(i, 0      , 0     , 0 );
5255         }
5256         _ptsCircle2->SetPoint(0, -1000  , -1000 , -1000 );
5257         _ptsCircle2->SetPoint(1,  1000  ,  1000 ,  1000 );
5258
5259         _pdCircle2 = vtkPolyData::New();
5260     _pdCircle2->SetPoints( _ptsCircle2 );
5261     _pdCircle2->SetLines( lines );
5262         lines->Delete();  //do not delete lines ??
5263         _circle2Actor                                   =       vtkActor::New();
5264     _circle2Mapper                                      =       vtkPolyDataMapper::New();
5265         _circle2Mapper->SetInput(_pdCircle2);
5266         _circle2Mapper->ImmediateModeRenderingOn();
5267         _circle2Actor->SetMapper(_circle2Mapper);
5268         _circle2Actor->GetProperty()->BackfaceCullingOn();
5269         _circle2Actor->GetProperty()->SetDiffuseColor(0,0,1);
5270         _circle2Actor->GetProperty()->SetLineWidth(2);
5271     imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _circle2Actor );
5272
5273 // Line Referance 1
5274         _ptsLineRef1 = vtkPoints::New();
5275         _ptsLineRef1->SetNumberOfPoints(2);
5276         _ptsLineRef1->SetPoint(0, -1000 , -1000 , -1000 );
5277         _ptsLineRef1->SetPoint(1,  1000 ,  1000 ,  1000 );
5278         lines = vtkCellArray::New();
5279         lines->InsertNextCell(2);
5280         lines->InsertCellPoint(0);
5281         lines->InsertCellPoint(1);
5282
5283         _pdLineRef1 = vtkPolyData::New();
5284     _pdLineRef1->SetPoints( _ptsLineRef1 );
5285     _pdLineRef1->SetLines( lines );
5286         lines->Delete();  //do not delete lines ??
5287         _lineRef1Actor                                  =       vtkActor::New();
5288     _lineRef1Mapper                                     =       vtkPolyDataMapper::New();
5289         _lineRef1Mapper->SetInput(_pdLineRef1);
5290         _lineRef1Mapper->ImmediateModeRenderingOn();
5291         _lineRef1Actor->SetMapper(_lineRef1Mapper);
5292         _lineRef1Actor->GetProperty()->BackfaceCullingOn();
5293         _lineRef1Actor->GetProperty()->SetDiffuseColor(0,0,1);
5294         _lineRef1Actor->GetProperty()->SetLineWidth(2);
5295     imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineRef1Actor );
5296
5297 // Line Referance 2
5298         _ptsLineRef2 = vtkPoints::New();
5299         _ptsLineRef2->SetNumberOfPoints(2);
5300         _ptsLineRef2->SetPoint(0, -1000 , -1000 , -1000 );
5301         _ptsLineRef2->SetPoint(1,  1000 ,  1000 ,  1000 );
5302         lines = vtkCellArray::New();
5303         lines->InsertNextCell(2);
5304         lines->InsertCellPoint(0);
5305         lines->InsertCellPoint(1);
5306
5307         _pdLineRef2 = vtkPolyData::New();
5308     _pdLineRef2->SetPoints( _ptsLineRef2 );
5309     _pdLineRef2->SetLines( lines );
5310         lines->Delete();  //do not delete lines ??
5311         _lineRef2Actor                                  =       vtkActor::New();
5312     _lineRef2Mapper                                     =       vtkPolyDataMapper::New();
5313         _lineRef2Mapper->SetInput(_pdLineRef2);
5314         _lineRef2Mapper->ImmediateModeRenderingOn();
5315         _lineRef2Actor->SetMapper(_lineRef2Mapper);
5316         _lineRef2Actor->GetProperty()->BackfaceCullingOn();
5317         _lineRef2Actor->GetProperty()->SetDiffuseColor(0,0,1);
5318         _lineRef2Actor->GetProperty()->SetLineWidth(2);
5319     imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineRef2Actor );
5320
5321
5322 }
5323
5324
5325 //-------------------------------------------------------------------
5326 //-------------------------------------------------------------------
5327 //-------------------------------------------------------------------
5328
5329 wxWidgetMesure2D_Plane_in_MPR::wxWidgetMesure2D_Plane_in_MPR(wxWindow *parent)
5330 :wxWidgetMesure2D_Plane(parent)
5331 {
5332         _vtkplane2Dview=NULL;
5333 }
5334
5335 //-------------------------------------------------------------------
5336
5337 wxWidgetMesure2D_Plane_in_MPR::~wxWidgetMesure2D_Plane_in_MPR()
5338 {
5339 }
5340 //-------------------------------------------------------------------
5341 void wxWidgetMesure2D_Plane_in_MPR::OnActiveLink(wxCommandEvent& event)
5342 {
5343         if (_vtkplane2Dview!=NULL)
5344         {
5345                 _vtkplane2Dview->SetActive( _cb_link->GetValue() );
5346                 _vtkplane2Dview->Refresh();
5347                 _vtkplane2Dview->RefreshView();
5348         }
5349 }
5350
5351
5352 //-------------------------------------------------------------------
5353 void wxWidgetMesure2D_Plane_in_MPR::SetActiveLink(bool ok)
5354 {
5355         _cb_link->SetValue(ok);
5356         if (_vtkplane2Dview!=NULL)
5357         {
5358                 _vtkplane2Dview->SetActive( _cb_link->GetValue() );
5359         }
5360 }
5361 //-------------------------------------------------------------------
5362
5363 void wxWidgetMesure2D_Plane_in_MPR::SetVtkPlane2DView(vtkPlane2DView *vtkplane2Dview)
5364 {
5365         _vtkplane2Dview = vtkplane2Dview;
5366 }
5367
5368 //-------------------------------------------------------------------
5369
5370 wxWindow *wxWidgetMesure2D_Plane_in_MPR::CreateWin1a(wxWindow *parent) // virtual
5371 {
5372         wxPanel *panel = new wxPanel(parent,-1);
5373
5374         _cb_link                = new wxCheckBox(panel,-1,_T("LINK                    "));
5375         _cb_link->SetValue(true);
5376
5377         wxFlexGridSizer *sizer = new wxFlexGridSizer(1);
5378
5379         sizer->Add(_cb_link);
5380
5381         sizer->Add( wxWidgetMesure2D_Plane::CreateWin1a(panel) );
5382
5383         panel->SetAutoLayout(true);
5384         panel->SetSizer(sizer);
5385         panel->SetSize(400,30);
5386         panel->Layout();
5387
5388 //EEDxx2.4
5389 //      panel->FitInside();
5390
5391         Connect(_cb_link->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxWidgetMesure2D_Plane_in_MPR::OnActiveLink );
5392
5393         return panel;
5394 }
5395
5396
5397
5398
5399 //-------------------------------------------------------------------
5400 //-------------------------------------------------------------------
5401 //-------------------------------------------------------------------
5402
5403 BEGIN_EVENT_TABLE( wxMPRWidget, wxPanel )
5404         EVT_MENU( 12121, wxMPRWidget::OnRefreshView )
5405         EVT_MENU( 12122, wxMPRWidget::OnDClickLeft  )
5406 END_EVENT_TABLE( );
5407
5408
5409
5410 wxMPRWidget::wxMPRWidget( wxWindow* parent,
5411                           marImageData *marimageData , double voxelSize)
5412 : wxPanel( parent, -1, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL)
5413 {
5414
5415         _vtkmpr2Dview[0]                                = NULL;
5416         _vtkmpr2Dview[1]                                = NULL;
5417         _vtkmpr2Dview[2]                                = NULL;
5418         _vtkplane2Dview                                 = NULL;
5419         _widgetMesure                                   = NULL;
5420         _wxsphereview                                   = NULL;
5421         _wxvtk3Dbaseview_MPRClipping3D  = NULL;
5422         _wxvtkmpr3Dview                                 = NULL;
5423         _wxvtkclipping3Dview                    = NULL;
5424         _vtkplane2Dview_B                               = NULL;
5425         _widgetMesure_B                                 = NULL;
5426
5427         _vtkmpr2Dview_B[0]                              = NULL;
5428         _vtkmpr2Dview_B[1]                              = NULL;
5429         _vtkmpr2Dview_B[2]                              = NULL;
5430         _vtkplane2Dview_B                               = NULL;
5431         _widgetMesure_B                                 = NULL;
5432         _wxsphereview_B                                 = NULL;
5433         _wxvtk3Dbaseview_MPR3D_B                = NULL;
5434         _wxvtkmpr3Dview_B                               = NULL;
5435         _wxvtk3Dbaseview_Clipping3D_BB  = NULL;
5436         _wxvtkmpr3Dview_BB                              = NULL;
5437         _wxvtkclipping3Dview_BB                 = NULL;
5438
5439         _vtkmprbasedata                                 = NULL;
5440
5441
5442
5443         _framePanelCutting                              = NULL;
5444         _panelCutting                                   = NULL;
5445
5446
5447         wxBoxSizer                      *sizer          = new wxBoxSizer(wxVERTICAL  );
5448
5449         if(marimageData!=NULL){
5450                 _marImageData                                   = marimageData;
5451                 _voxelSize                                              = voxelSize;
5452                 _vtkmprbasedata                                 = new vtkMPRBaseData();
5453                 _vtkmprbasedata->SetMarImageData(_marImageData);
5454
5455
5456
5457
5458                 wxSplitterWindow        *pnlSplitter            = new wxSplitterWindow( this , -1);
5459                 pnlSplitter     -> SetMinimumPaneSize( 2 );
5460
5461                 wxPanel                         *MPRPanel       = CreateMPRPanel(pnlSplitter,_vtkmprbasedata);
5462                 wxPanel                         *controlPanel   = CreateControlPanel(pnlSplitter);
5463                 pnlSplitter     -> SplitVertically( MPRPanel, controlPanel, 550 );
5464
5465                 sizer           -> Add( pnlSplitter ,1,wxGROW  ,0);
5466
5467         }
5468
5469         //int ww,hh;
5470         //wxWindow *pp=this;
5471         //while (pp->GetParent()!=NULL) pp=pp->GetParent();
5472         //pp->GetSize(&ww,&hh);
5473
5474         this            -> SetAutoLayout( true );
5475         this            -> SetSizer(sizer);
5476 //      sizer           ->      Fit( this );
5477         _refreshAPage=0;
5478         _refreshBPage=0;
5479
5480 }
5481 void wxMPRWidget::setMarImage(marImageData *marimageData, double voxelsize){
5482         _marImageData                                   = marimageData;
5483         _voxelSize                                              = voxelsize;
5484         _vtkmprbasedata                                 = new vtkMPRBaseData();
5485         _vtkmprbasedata->SetMarImageData(_marImageData);
5486
5487         wxSplitterWindow        *pnlSplitter            = new wxSplitterWindow( this , -1);
5488         pnlSplitter     -> SetMinimumPaneSize( 2 );
5489
5490         wxPanel                         *MPRPanel       = CreateMPRPanel(pnlSplitter,_vtkmprbasedata);
5491         wxPanel                         *controlPanel   = CreateControlPanel(pnlSplitter);
5492         pnlSplitter     -> SplitVertically( MPRPanel, controlPanel, 550 );
5493
5494         this->GetSizer()                -> Add( pnlSplitter ,1,wxGROW  ,0);
5495 }
5496 //----------------------------------------------------------------------------
5497
5498 wxMPRWidget::~wxMPRWidget( )
5499 {
5500 //EEDxx2.4 DELETE
5501         if (_framePanelCutting!=NULL)
5502         {
5503                 _framePanelCutting->Close();
5504         }
5505
5506         if (_vtkmpr2Dview[0]!=NULL)                                     { delete _vtkmpr2Dview[0]; }
5507         if (_vtkmpr2Dview[1]!=NULL)                                     { delete _vtkmpr2Dview[1]; }
5508         if (_vtkmpr2Dview[2]!=NULL)                                     { delete _vtkmpr2Dview[2]; }
5509
5510         if (_vtkmpr2Dview_B[0]!=NULL)                           { delete _vtkmpr2Dview_B[0]; }
5511
5512         if (_vtkmpr2Dview_B[1]!=NULL)                           { delete _vtkmpr2Dview_B[1]; }
5513         if (_vtkmpr2Dview_B[2]!=NULL)                           { delete _vtkmpr2Dview_B[2]; }
5514
5515         if (_vtkmprbasedata!=NULL)                                      { delete _vtkmprbasedata; }
5516         if (_vtkplane2Dview!=NULL)                                      { delete _vtkplane2Dview; }
5517         if (_wxsphereview!=NULL)                                        { delete _wxsphereview; }
5518         if (_wxvtk3Dbaseview_MPRClipping3D!=NULL)       { delete _wxvtk3Dbaseview_MPRClipping3D; }
5519         if (_wxvtkmpr3Dview!=NULL)                                      { delete _wxvtkmpr3Dview; }
5520         if (_wxvtkclipping3Dview!=NULL)                         { delete _wxvtkclipping3Dview; }
5521
5522         if (_vtkplane2Dview_B!=NULL)                            { delete _vtkplane2Dview_B; }
5523         if (_wxsphereview_B!=NULL)                                      { delete _wxsphereview_B; }
5524
5525         if (_wxvtk3Dbaseview_MPR3D_B!=NULL)                     { delete _wxvtk3Dbaseview_MPR3D_B; }
5526         if (_wxvtkmpr3Dview_B!=NULL)                            { delete _wxvtkmpr3Dview_B; }
5527
5528         if (_wxvtk3Dbaseview_Clipping3D_BB!=NULL)       { delete _wxvtk3Dbaseview_Clipping3D_BB; }
5529         if (_wxvtkmpr3Dview_BB!=NULL)                           { delete _wxvtkmpr3Dview_BB; }
5530         if (_wxvtkclipping3Dview_BB!=NULL)                      { delete _wxvtkclipping3Dview_BB; }
5531 }
5532
5533 //----------------------------------------------------------------------------
5534
5535 wxPanel* wxMPRWidget::CreateControlPanel(wxWindow *parent)
5536 {
5537
5538         wxPanel *panel=new wxPanel(parent,-1);
5539
5540 //EEDxx2.4
5541 //      wxStaticText *tmpText = new wxStaticText(panel,-1,"");
5542
5543         wxStaticText *help0Text = new wxStaticText(panel,-1,_T("General: \n  middle click : contrast\n  ctrl + middle click : rotate image\n  shift + middle click: translate image\n  ctrl + right click: zoom"));
5544
5545         wxStaticText *help1Text = new wxStaticText(panel,-1,_T("mpr2D: \n  double click : choose a point\n  mouse right : change perpendicular slice\n  drag axis: change slice"));
5546
5547         wxStaticText *help2Text = new wxStaticText(panel,-1,_T("Plane: \n  drag mouse: rotate\n  ctrl + drag mouse : fix axis rotation\n  \n mouse right: change perpendicular slice \n  see split control \n     - Active/Desactivet plane tool\n     - Center market\n     - Rotation axis market\n     - 2D messure tool (open/close contour)"));
5548
5549         wxStaticText *help3Text = new wxStaticText(panel,-1,
5550 _T("Sphere: \n  drag mouse: rotation\n  mouse right: change radio \n  click: 3D point selection in MPR 2D \n  double clicks in MPR: show surface sphere"));
5551
5552         wxStaticText *help4Text = new wxStaticText(panel,-1,_T("MPR3D:\n  see split control"));
5553
5554         wxString text=_T("");
5555         text=text+_T("Clipping: \n");
5556         text=text+_T(" see split control \n");
5557         text=text+_T(" 4 MarchingCubes:  \n");
5558         text=text+_T("    color, isovalue, opacity \n");
5559         text=text+_T(" Box:\n");
5560         text=text+_T("    mouse left drag (box): rotation\n");
5561         text=text+_T("    mouse left drag (sphere): size,position\n");
5562         text=text+_T("    mouse right drag (box): box size");
5563         text=text+_T(" Axis: 3D\n");
5564         text=text+_T("    mouse drag: translate\n");
5565         text=text+_T("    shift + mouse drag: translate 2 axis\n");
5566         text=text+_T("    mouse right: scale\n");
5567         text=text+_T(" Plane 3D:\n");
5568         text=text+_T("    mouse drag perpendicular axis: rotate plane\n");
5569         text=text+_T("    mouse drag spheres: size plane\n");
5570         text=text+_T("    ctrl +mouse right over the plane: size plane\n");
5571         text=text+_T("    mouse drag plane: translate\n");
5572         text=text+_T("    middle click perpendicular axis: translate\n");
5573         wxStaticText *help5Text = new wxStaticText(panel,-1, text );
5574
5575
5576     wxFlexGridSizer *sizer  = new wxFlexGridSizer(1);
5577         sizer->Add( new wxStaticText(panel,-1,_T(""))   );
5578         sizer->Add( new wxStaticText(panel,-1,_T(""))   );
5579         sizer->Add( help0Text   );
5580
5581         sizer->Add( new wxStaticText(panel,-1,_T(""))   );
5582         sizer->Add( new wxStaticText(panel,-1,_T(""))   );
5583         sizer->Add( help1Text   );
5584
5585         sizer->Add( new wxStaticText(panel,-1,_T(""))   );
5586         sizer->Add( new wxStaticText(panel,-1,_T(""))   );
5587         sizer->Add( help2Text   );
5588
5589         sizer->Add( new wxStaticText(panel,-1,_T(""))   );
5590         sizer->Add( new wxStaticText(panel,-1,_T(""))   );
5591         sizer->Add( help3Text   );
5592
5593         sizer->Add( new wxStaticText(panel,-1,_T(""))   );
5594         sizer->Add( new wxStaticText(panel,-1,_T(""))   );
5595         sizer->Add( help4Text   );
5596
5597         sizer->Add( new wxStaticText(panel,-1,_T(""))   );
5598         sizer->Add( new wxStaticText(panel,-1,_T(""))   );
5599         sizer->Add( help5Text   );
5600
5601         panel->SetSizer(sizer);
5602         panel->SetAutoLayout(true);
5603         panel->SetSize(350,500);
5604
5605     return panel;
5606 }
5607
5608 //----------------------------------------------------------------------------
5609
5610 void wxMPRWidget::OnPageAChanged(wxNotebookEvent & event)
5611 {
5612         _refreshAPage=event.GetSelection();
5613         Refresh();
5614         RefreshView(true);
5615 }
5616
5617 //----------------------------------------------------------------------------
5618
5619 void wxMPRWidget::OnPageBChanged(wxNotebookEvent & event)
5620 {
5621         _refreshBPage=event.GetSelection();
5622 //      Refresh(false);
5623 //      RefreshView();
5624 }
5625
5626
5627 //----------------------------------------------------------------------------
5628
5629 wxPanel* wxMPRWidget::CreateView(int type,wxWindow *parent, vtkMPRBaseData *vtkmprbasedata)
5630 {
5631         wxWindow *wxwindow;
5632         wxPanel *panel=new wxPanel(parent,-1);
5633
5634         if (type==0)
5635         {
5636                 _vtkmpr2Dview_B[0] = new wxVtkMPR2DView(panel,0);
5637                 _vtkmpr2Dview_B[0]->SetVtkBaseData(vtkmprbasedata);
5638                 wxwindow=_vtkmpr2Dview_B[0]->GetWxVTKRenderWindowInteractor();
5639         }
5640         if (type==1)
5641         {
5642                 _vtkmpr2Dview_B[1] = new wxVtkMPR2DView(panel,1);
5643                 _vtkmpr2Dview_B[1]->SetVtkBaseData(vtkmprbasedata);
5644                 wxwindow=_vtkmpr2Dview_B[1]->GetWxVTKRenderWindowInteractor();
5645         }
5646         if (type==2)
5647         {
5648                 _vtkmpr2Dview_B[2] = new wxVtkMPR2DView(panel,2);
5649                 _vtkmpr2Dview_B[2]->SetVtkBaseData(vtkmprbasedata);
5650                 wxwindow=_vtkmpr2Dview_B[2]->GetWxVTKRenderWindowInteractor();
5651         }
5652         if (type==3)
5653         {
5654                 _widgetMesure_B         = new wxWidgetMesure2D_Plane_in_MPR(panel);
5655                 _vtkplane2Dview_B       = new vtkPlane2DView( _widgetMesure_B->GetWindow2());
5656                 _widgetMesure_B->SetVtkPlane2DView( _vtkplane2Dview_B );
5657                 _vtkplane2Dview_B->SetImgSize( 200 );
5658                 _vtkplane2Dview_B->SetVtkBaseData(vtkmprbasedata);
5659                 wxwindow                        = _widgetMesure_B;
5660         }
5661         if (type==4)
5662         {
5663                 _wxsphereview_B         = new wxSphereView( panel , vtkmprbasedata, vtkmprbasedata->GetImageData() );
5664                 wxwindow=_wxsphereview_B->GetWxVTKRenderWindowInteractor();
5665         }
5666
5667         if (type==5)
5668         {
5669                 wxSplitterWindow *panelMPR3D    = new wxSplitterWindow( panel , -1);
5670                 _wxvtk3Dbaseview_MPR3D_B                = new wxVtk3DBaseView( panelMPR3D );
5671
5672                 _wxvtkmpr3Dview_B                               = new wxVtkMPR3DView(_wxvtk3Dbaseview_MPR3D_B);
5673                 vtkMPR3DDataViewer *vtkmpr3Ddataviewer = new vtkMPR3DDataViewer();
5674                 vtkmpr3Ddataviewer->SetVtkMPRBaseData(vtkmprbasedata);
5675                 vtkmpr3Ddataviewer->Configure();
5676                 _wxvtkmpr3Dview_B->SetVtkMPR3DDataViewer(vtkmpr3Ddataviewer);
5677
5678                 wxWindow        *window3D                       = _wxvtk3Dbaseview_MPR3D_B->GetWxVTKRenderWindowInteractor();
5679                 wxPanel         *controlPanel3D         = _wxvtkmpr3Dview_B->CreateControlPanel(panelMPR3D);
5680
5681 //EEDxx2.4
5682                 panelMPR3D      -> SetMinimumPaneSize( 5 );
5683                 panelMPR3D      -> SplitHorizontally( controlPanel3D,window3D,600  );
5684
5685                 wxwindow=panelMPR3D;
5686         }
5687
5688         if (type==6)
5689         {
5690                 wxSplitterWindow        *panelClipping3D        = new wxSplitterWindow( panel , -1);
5691                 _wxvtk3Dbaseview_Clipping3D_BB                  = new wxVtk3DBaseView( panelClipping3D );
5692
5693                 _wxvtkclipping3Dview_BB                                 = new wxVtkClipping3DView(_wxvtk3Dbaseview_Clipping3D_BB);
5694                 vtkClipping3DDataViewer *vtkclipping3Ddataviewer = new vtkClipping3DDataViewer();
5695                 vtkclipping3Ddataviewer->SetVtkMPRBaseData(vtkmprbasedata);
5696                 vtkclipping3Ddataviewer->Configure();
5697                 _wxvtkclipping3Dview_BB->SetVtkClipping3DDataViewer(vtkclipping3Ddataviewer);
5698
5699                 _wxvtkmpr3Dview_BB                                              = new wxVtkMPR3DView( _wxvtk3Dbaseview_Clipping3D_BB );
5700                 vtkMPR3DDataViewer *vtkmpr3Ddataviewer  = new vtkMPR3DDataViewer();
5701                 vtkmpr3Ddataviewer->SetVtkMPRBaseData(vtkmprbasedata);
5702                 vtkmpr3Ddataviewer->Configure();
5703                 _wxvtkmpr3Dview_BB->SetVtkMPR3DDataViewer(vtkmpr3Ddataviewer);
5704
5705                 wxWindow        *window3D                                       = _wxvtk3Dbaseview_Clipping3D_BB->GetWxVTKRenderWindowInteractor();
5706
5707                 wxPanel                 *panelControl                   = new wxPanel(panelClipping3D,-1);
5708                 wxPanel                 *controlPanelMPR3D              = _wxvtkmpr3Dview_BB->CreateControlPanel(panelControl);
5709                 wxPanel                 *controlPanelClipping3D = _wxvtkclipping3Dview_BB->CreateControlPanel(panelControl);
5710                                  _btnCutImageData               = new wxCheckBox(panelControl,-1,_T("Cut Module"));
5711                 Connect(_btnCutImageData->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED  , (wxObjectEventFunction) &wxMPRWidget::OnCutImagaData );
5712
5713                 wxFlexGridSizer  *sizerCtrol             = new wxFlexGridSizer(1);
5714                 sizerCtrol->Add(controlPanelMPR3D               , 1, wxALL|wxEXPAND, 2);
5715                 sizerCtrol->Add(controlPanelClipping3D  , 1, wxALL|wxEXPAND, 2);
5716                 sizerCtrol->Add( _btnCutImageData               , 1, wxALL, 2);
5717
5718                 panelControl->SetAutoLayout(true);
5719                 panelControl->SetSizer(sizerCtrol);
5720                 panelControl->SetSize(400,350);
5721                 panelControl->Layout();
5722 //EEDxx2.4
5723 //              panelControl->FitInside();
5724
5725 //EEDxx2.4
5726                 panelClipping3D -> SetMinimumPaneSize( 5 );
5727                 panelClipping3D -> SplitHorizontally( panelControl , window3D , 10  );
5728                 wxwindow=panelClipping3D;
5729         }
5730
5731     wxBoxSizer *sizerH1                                                 = new wxBoxSizer(wxHORIZONTAL);
5732         sizerH1->Add(wxwindow , 1, wxALL|wxGROW, 0);
5733         panel->SetAutoLayout(true);
5734         panel->SetSizer(sizerH1);
5735         panel->SetSize(400,400);
5736         panel->Layout();
5737
5738         return panel;
5739 }
5740
5741 //----------------------------------------------------------------------------
5742
5743 wxPanel* wxMPRWidget::CreateMPRPanel(wxWindow *parent, vtkMPRBaseData *vtkmprbasedata)
5744 {
5745         wxPanel *panel=new wxPanel(parent,-1);
5746
5747         wxNotebook *notebook = new wxNotebook( panel, -1 );
5748
5749         notebook->AddPage( CreateMPRPanel4View( notebook ,vtkmprbasedata), _T("4-View") );
5750         notebook->AddPage( CreateView(0,notebook,vtkmprbasedata) , _T("Axial")          );
5751         notebook->AddPage( CreateView(1,notebook,vtkmprbasedata) , _T("Sagital")        );
5752         notebook->AddPage( CreateView(2,notebook,vtkmprbasedata) , _T("Coronal")        );
5753         notebook->AddPage( CreateView(3,notebook,vtkmprbasedata) , _T("Plane")          );
5754         notebook->AddPage( CreateView(4,notebook,vtkmprbasedata) , _T("Sphere")         );
5755         notebook->AddPage( CreateView(5,notebook,vtkmprbasedata) , _T("MPR 3D")         );
5756         notebook->AddPage( CreateView(6,notebook,vtkmprbasedata) , _T("Clipping")       );
5757         Connect(notebook->GetId()       , wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED  , (wxObjectEventFunction) &wxMPRWidget::OnPageAChanged   );
5758
5759         wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
5760         sizer->Add(notebook , 1, wxALL|wxGROW, 2);
5761         panel->SetAutoLayout(true);
5762         panel->SetSizer(sizer);
5763         panel->SetSize(400,400);
5764         panel->Layout();
5765
5766 //EEDxx2.4
5767 //      panel->FitInside();
5768
5769         panel->Refresh();
5770         return panel;
5771 }
5772
5773 //----------------------------------------------------------------------------
5774
5775 wxPanel* wxMPRWidget::CreateMPRPanel4View(wxWindow *parent, vtkMPRBaseData *vtkmprbasedata)
5776 {
5777         wxPanel *panel=new wxPanel(parent,-1);
5778
5779         // view 0
5780         _vtkmpr2Dview[0] = new wxVtkMPR2DView(panel,0);
5781         _vtkmpr2Dview[0]->SetVtkBaseData(vtkmprbasedata);
5782         wxVTKRenderWindowInteractor *iren0 = _vtkmpr2Dview[0]->GetWxVTKRenderWindowInteractor();
5783
5784         // view 1
5785         _vtkmpr2Dview[1] = new wxVtkMPR2DView(panel,1);
5786         _vtkmpr2Dview[1]->SetVtkBaseData(vtkmprbasedata);
5787         wxVTKRenderWindowInteractor *iren1 = _vtkmpr2Dview[1]->GetWxVTKRenderWindowInteractor();
5788
5789         // view 2
5790         _vtkmpr2Dview[2] = new wxVtkMPR2DView(panel,2);
5791         _vtkmpr2Dview[2]->SetVtkBaseData(vtkmprbasedata);
5792         wxVTKRenderWindowInteractor *iren2 = _vtkmpr2Dview[2]->GetWxVTKRenderWindowInteractor();
5793
5794         // view 3
5795         wxNotebook *notebook = new wxNotebook( panel, -1 );
5796         notebook->SetSize(400,400);
5797
5798 // EED 27 Oct 2007
5799          // view 3.0
5800         _widgetMesure   = new wxWidgetMesure2D_Plane_in_MPR(notebook);
5801         _vtkplane2Dview = new vtkPlane2DView( _widgetMesure->GetWindow2() );
5802         _widgetMesure->SetVtkPlane2DView( _vtkplane2Dview );
5803         _vtkplane2Dview->SetImgSize( 200 );
5804         _vtkplane2Dview->SetVtkBaseData(vtkmprbasedata);
5805         notebook->AddPage( _widgetMesure, _T("Plane") );
5806
5807          // view 3.1
5808         _wxsphereview = new wxSphereView( notebook , vtkmprbasedata, vtkmprbasedata->GetImageData());
5809         wxVTKRenderWindowInteractor *iren3B = _wxsphereview->GetWxVTKRenderWindowInteractor();
5810         notebook->AddPage( iren3B, _T("Sphere") );
5811
5812
5813          // view 3.2
5814         wxSplitterWindow *panelMPR3D    = new wxSplitterWindow( notebook , -1);
5815         _wxvtk3Dbaseview_MPRClipping3D  = new wxVtk3DBaseView( panelMPR3D );
5816
5817         _wxvtkmpr3Dview = new wxVtkMPR3DView( _wxvtk3Dbaseview_MPRClipping3D );
5818         vtkMPR3DDataViewer *vtkmpr3Ddataviewer = new vtkMPR3DDataViewer();
5819         vtkmpr3Ddataviewer->SetVtkMPRBaseData(vtkmprbasedata);
5820         vtkmpr3Ddataviewer->Configure();
5821         _wxvtkmpr3Dview->SetVtkMPR3DDataViewer(vtkmpr3Ddataviewer);
5822
5823
5824         _wxvtkclipping3Dview = new wxVtkClipping3DView( _wxvtk3Dbaseview_MPRClipping3D );
5825         vtkClipping3DDataViewer *vtkclipping3Ddataviewer = new vtkClipping3DDataViewer();
5826         vtkclipping3Ddataviewer->SetVtkMPRBaseData(vtkmprbasedata);
5827         vtkclipping3Ddataviewer->Configure();
5828         _wxvtkclipping3Dview->SetVtkClipping3DDataViewer(vtkclipping3Ddataviewer);
5829
5830
5831         wxWindow        *window3D                               = _wxvtk3Dbaseview_MPRClipping3D->GetWxVTKRenderWindowInteractor();
5832
5833         wxPanel         *panelControl                   = new wxPanel(panelMPR3D,-1);
5834         wxPanel         *controlPanelMPR3D              = _wxvtkmpr3Dview->CreateControlPanel(panelControl);
5835         wxPanel         *controlPanelClipping3D = _wxvtkclipping3Dview->CreateControlPanel(panelControl);
5836
5837
5838
5839
5840 //    wxBoxSizer         *sizerCtrol             = new wxBoxSizer(wxVERTICAL);
5841         wxFlexGridSizer  *sizerCtrol             = new wxFlexGridSizer(1);
5842         sizerCtrol->Add(controlPanelMPR3D               , 1, wxALL|wxEXPAND, 2);
5843         sizerCtrol->Add(controlPanelClipping3D  , 1, wxALL|wxEXPAND, 2);
5844
5845
5846         panelControl->SetAutoLayout(true);
5847         panelControl->SetSizer(sizerCtrol);
5848         panelControl->SetSize(400,150);
5849         panelControl->Layout();
5850
5851 //EEDxx2.4
5852         panelMPR3D      -> SetMinimumPaneSize( 5 );
5853
5854         panelMPR3D      -> SplitHorizontally( panelControl,window3D,200  );
5855
5856         notebook->AddPage( panelMPR3D, _T("MPR 3D - Clipping") );
5857
5858
5859         Connect(notebook->GetId()       , wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED  , (wxObjectEventFunction) &wxMPRWidget::OnPageBChanged   );
5860
5861         wxBoxSizer *sizerV = new wxBoxSizer(wxVERTICAL);
5862         wxBoxSizer *sizerH1= new wxBoxSizer(wxHORIZONTAL);
5863         wxBoxSizer *sizerH2= new wxBoxSizer(wxHORIZONTAL);
5864         sizerH1->Add(iren2 , 1, wxALL|wxEXPAND, 2);
5865         sizerH1->Add(iren0 , 1, wxALL|wxEXPAND, 2);
5866         sizerH2->Add(iren1 , 1, wxALL|wxEXPAND, 2);
5867 //      sizerH2->Add(iren3 , 1, wxALL|wxEXPAND, 2);
5868         sizerH2->Add(notebook , 1, wxALL|wxEXPAND, 2);
5869
5870         sizerV->Add(sizerH1, 1, wxALL|wxEXPAND, 0);
5871         sizerV->Add(sizerH2, 1, wxALL|wxEXPAND, 0);
5872
5873         panel->SetAutoLayout(true);
5874         panel->SetSizer(sizerV);
5875         panel->SetSize(400,400);
5876         panel->Layout();
5877         return panel;
5878 }
5879
5880 //----------------------------------------------------------------------------
5881 void wxMPRWidget::OnCutImagaData(wxCommandEvent &event)
5882 {
5883         if (_btnCutImageData->GetValue()==true){
5884                 _framePanelCutting = new wxFrame(this,-1,_T("Cutting Module"),wxDefaultPosition,wxDefaultSize,wxCAPTION|wxSTAY_ON_TOP| wxRESIZE_BORDER );
5885                 _framePanelCutting->SetSize(550,400);
5886                 _panelCutting   = new wxPanelCuttingImageData(_framePanelCutting);
5887                 _panelCutting->SetWxVtk3DBaseView( _wxvtk3Dbaseview_Clipping3D_BB  );
5888                 _panelCutting->SetVtkMPRBaseData( GetVtkMPRBaseData() );
5889                 _panelCutting->SetVtkClipping3DDataViewer( this->_wxvtkclipping3Dview_BB->GetVtkClipping3DDataViewer() );
5890                 _panelCutting->Configure( );
5891 /*
5892                 wxBoxSizer *topsizer            = new wxBoxSizer(wxHORIZONTAL  );
5893                 topsizer -> Add( _panelCutting ,1,wxALL  ,0);
5894                 _framePanelCutting->SetAutoLayout(true);
5895                 _framePanelCutting->SetSizer( topsizer );      // use the sizer for layout
5896                 _framePanelCutting->Layout();
5897 //EEDxx2.4
5898 //              _framePanelCutting->FitInside();
5899 */
5900                 _framePanelCutting->Show();
5901         } else {
5902                 if (_framePanelCutting!=NULL){
5903                         _panelCutting->RemoveActors();
5904                         _framePanelCutting->Close();
5905                         _framePanelCutting      = NULL;
5906                         _panelCutting           = NULL;
5907                 }
5908         }
5909 }
5910
5911 //----------------------------------------------------------------------------
5912 void wxMPRWidget::ConfigureVTK(){
5913         int x=0,y=0,z=0;
5914
5915         if (_vtkmprbasedata!=NULL)
5916         {
5917                 x=_vtkmprbasedata                       ->      GetMaxPositionX()/2;
5918                 y=_vtkmprbasedata                       ->      GetMaxPositionY()/2;
5919                 z=_vtkmprbasedata                       ->      GetMaxPositionZ()/2;
5920         }
5921
5922         if(_vtkmpr2Dview[0]!=NULL) {_vtkmpr2Dview[0]                            ->      Configure();}
5923         if(_vtkmpr2Dview[1]!=NULL) {_vtkmpr2Dview[1]                            ->      Configure();}
5924         if(_vtkmpr2Dview[2]!=NULL) {_vtkmpr2Dview[2]                            ->      Configure();}
5925
5926
5927         if (_vtkmpr2Dview_B[0]!=NULL) { _vtkmpr2Dview_B[0]                              ->      Configure(); }
5928         if (_vtkmpr2Dview_B[1]!=NULL) { _vtkmpr2Dview_B[1]                              ->      Configure(); }
5929         if (_vtkmpr2Dview_B[2]!=NULL) { _vtkmpr2Dview_B[2]                              ->      Configure(); }
5930
5931
5932         if (_vtkmprbasedata!=NULL)
5933         {
5934                 _vtkmprbasedata->SetX( x );
5935                 _vtkmprbasedata->SetY( y );
5936                 _vtkmprbasedata->SetZ( z );
5937         }
5938
5939         if (_vtkplane2Dview!=NULL){_vtkplane2Dview                              ->      Configure();}
5940         if (_widgetMesure!=NULL){_widgetMesure                                  ->      ConfigureA(_vtkplane2Dview);}
5941         if (_widgetMesure!=NULL){_widgetMesure                                  ->      SetActiveLink(true);}
5942         if (_widgetMesure!=NULL){_widgetMesure                                  ->      SetMesureScale( _voxelSize );}
5943         if (_wxsphereview!=NULL){_wxsphereview                                  ->      Configure();}
5944
5945         if (_wxvtk3Dbaseview_MPRClipping3D!=NULL){_wxvtk3Dbaseview_MPRClipping3D        ->  Configure();}
5946         if (_wxvtkmpr3Dview!=NULL){
5947                 _wxvtkmpr3Dview                                 ->      Configure();
5948         }
5949         if (_wxvtkclipping3Dview!=NULL){_wxvtkclipping3Dview            ->      Configure();}
5950
5951         if (_vtkplane2Dview_B!=NULL){   _vtkplane2Dview_B                       ->      Configure(); }
5952         if (_widgetMesure_B!=NULL){             _widgetMesure_B                         ->      ConfigureA( _vtkplane2Dview_B ); }
5953         if (_widgetMesure_B!=NULL){             _widgetMesure_B                         ->      SetActiveLink(true); }
5954
5955 //EEDx3
5956 //      double spc[3];
5957 //      vtkImageData *imageData = _vtkmprbasedata->GetImageData();
5958 //      imageData->Update();
5959 //      imageData->GetSpacing(spc);
5960 //      _widgetMesure_B->SetMesureScale(spc[0]);
5961
5962         if (_widgetMesure_B!=NULL)                                      {_widgetMesure_B->SetMesureScale( _voxelSize );}
5963
5964
5965         if (_wxsphereview_B!=NULL)                                      {_wxsphereview_B                                ->      Configure();}
5966
5967         if (_wxvtk3Dbaseview_MPR3D_B!=NULL)                     {_wxvtk3Dbaseview_MPR3D_B               ->  Configure();}
5968         if (_wxvtkmpr3Dview_B!=NULL)                            {_wxvtkmpr3Dview_B                              ->      Configure();}
5969
5970         if ( _wxvtk3Dbaseview_Clipping3D_BB!=NULL)      {_wxvtk3Dbaseview_Clipping3D_BB ->  Configure(); }
5971         if ( _wxvtkmpr3Dview_BB!=NULL)                          {_wxvtkmpr3Dview_BB                             ->      Configure(); }
5972         if ( _wxvtkclipping3Dview_BB!=NULL)                     {_wxvtkclipping3Dview_BB                ->      Configure(); }
5973
5974
5975         vtkInteractorStyle3DView *vtkinteractorstyle3Dview;
5976         if (_wxvtkmpr3Dview_BB!=NULL)
5977         {
5978                 vtkinteractorstyle3Dview        = new vtkInteractorStyle3DView();
5979                 vtkinteractorstyle3Dview->SetWxVtkMPR3DView(_wxvtkmpr3Dview_BB);
5980                 vtkinteractorstyle3Dview->SetWxVtkClipping3DView(_wxvtkclipping3Dview_BB);
5981         }
5982
5983         if (_wxvtk3Dbaseview_Clipping3D_BB!=NULL)
5984         {
5985                 _wxvtk3Dbaseview_Clipping3D_BB->GetInteractorStyleBaseView()->AddInteractorStyleMaracas( vtkinteractorstyle3Dview );
5986         }
5987
5988 //EED 29Mars2009
5989 //      RefreshView(true);
5990
5991 }
5992
5993 //----------------------------------------------------------------------------
5994
5995 void wxMPRWidget::OnRefreshView(wxCommandEvent & event)
5996 {
5997         RefreshView();
5998 }
5999 //----------------------------------------------------------------------------
6000 void wxMPRWidget::OnDClickLeft(wxCommandEvent & event)
6001 {
6002         if (_wxsphereview!=NULL) {
6003                 _wxsphereview   -> RefreshPoint();
6004         }
6005         if (_wxsphereview_B!=NULL) {
6006                 _wxsphereview_B -> RefreshPoint();
6007         }
6008 }
6009 //----------------------------------------------------------------------------
6010 void wxMPRWidget::RefreshView(bool firsttime){
6011
6012         if (_refreshAPage == 0 )
6013         {
6014
6015                 if ((_vtkmpr2Dview[0]!=NULL) && (_vtkmpr2Dview[1]!=NULL) && (_vtkmpr2Dview[2]!=NULL) )
6016                 {
6017                         _vtkmpr2Dview[2] -> Refresh();
6018                         _vtkmpr2Dview[1] -> Refresh();
6019                         _vtkmpr2Dview[0] -> Refresh();
6020
6021                         if (firsttime==false)
6022                         {
6023                                 _vtkmpr2Dview[2] -> RefreshView();
6024                                 _vtkmpr2Dview[1] -> RefreshView();
6025                                 _vtkmpr2Dview[0] -> RefreshView();
6026                         }
6027
6028                         if (_refreshBPage == 0 )
6029                         {
6030                                 if (_vtkplane2Dview!=NULL)
6031                                 {
6032                                         _vtkplane2Dview -> Refresh();
6033                                         if (firsttime==false)
6034                                         {
6035                                                 _vtkplane2Dview -> RefreshView();
6036                                         }
6037 //                                      _wxvtk3Dbaseview_MPR3D_B -> Refresh();
6038                                 }
6039                         }
6040                         if (_refreshBPage == 1 )
6041                         {
6042                                 //sphere
6043                         }
6044                         if (_refreshBPage == 2 )
6045                         {
6046                                 if ((_wxvtkmpr3Dview!=NULL)  && (_wxvtk3Dbaseview_MPRClipping3D!=NULL) && (_wxvtkclipping3Dview!=NULL) )
6047                                 {
6048                                         _wxvtkmpr3Dview                 -> RefreshView();
6049                                         _wxvtk3Dbaseview_MPRClipping3D  -> Refresh();
6050                                         _wxvtkclipping3Dview            -> Refresh();
6051                                 }
6052                         }
6053                 }
6054         }
6055
6056         if (_refreshAPage == 1 )
6057         {
6058                 if (_vtkmpr2Dview_B[0] !=NULL){
6059                         _vtkmpr2Dview_B[0] -> Refresh();
6060                 }
6061         }
6062         if (_refreshAPage == 2 )
6063         {
6064                 if (_vtkmpr2Dview_B[1] !=NULL){
6065                         _vtkmpr2Dview_B[1] -> Refresh();
6066                 }
6067         }
6068         if (_refreshAPage == 3 )
6069         {
6070                 if (_vtkmpr2Dview_B[2] !=NULL){
6071                         _vtkmpr2Dview_B[2] -> Refresh();
6072                 }
6073         }
6074         if (_refreshAPage == 4 )
6075         {
6076                 if (_vtkplane2Dview_B!=NULL){
6077                         _vtkplane2Dview_B -> Refresh();
6078                         if (firsttime==false)
6079                         {
6080                                 _vtkplane2Dview_B -> RefreshView();
6081                         }
6082                 }
6083         }
6084
6085         if (_refreshAPage == 5 )
6086         {
6087                 // sphere
6088         }
6089         if (_refreshAPage == 6 )
6090         {
6091                 if (_wxvtkmpr3Dview_B!=NULL){
6092                         _wxvtkmpr3Dview_B               -> Refresh();
6093                         _wxvtk3Dbaseview_MPR3D_B        -> Refresh();
6094                 }
6095         }
6096         if (_refreshAPage == 7 )
6097         {
6098                 if (_wxvtkmpr3Dview_BB!=NULL){
6099                         _wxvtkmpr3Dview_BB              -> RefreshView();
6100                         _wxvtkclipping3Dview_BB         -> Refresh();
6101                         _wxvtk3Dbaseview_Clipping3D_BB  -> Refresh();
6102                         if (_panelCutting!=NULL)
6103                         {
6104                                 _panelCutting->RefreshView();
6105                         }
6106                 }
6107         }
6108
6109 }
6110 //----------------------------------------------------------------------------
6111 vtkMPRBaseData  *wxMPRWidget::GetVtkMPRBaseData(){
6112         return _vtkmprbasedata;
6113 }
6114 //----------------------------------------------------------------------------
6115 vtkPlane2DView *wxMPRWidget::GetVtkPlane2DView()
6116 {
6117         return _vtkplane2Dview;
6118 }
6119 //----------------------------------------------------------------------------
6120 wxVtkMPR3DView  *wxMPRWidget::GetWxvtkmpr3Dview_BB()
6121 {
6122         return _wxvtkmpr3Dview_BB;
6123 }
6124 //----------------------------------------------------------------------------
6125 wxVtkBaseView *wxMPRWidget::GetWxVtkBaseView(int page, int id)
6126 {
6127         wxVtkBaseView *result=NULL;
6128         if (page==0)
6129         {
6130                 if ((id>=0) &&(id<=3)){
6131                         result=_vtkmpr2Dview[id];
6132                 }
6133                 if (id==3)
6134                 {
6135                         result=_vtkplane2Dview;
6136                 }
6137         }
6138         return result;
6139 }
6140 //----------------------------------------------------------------------------
6141 wxVtkMPR2DView *wxMPRWidget::GetWxvtkMPR2Dview(int direction)
6142 {
6143         return _vtkmpr2Dview[direction];
6144 }
6145
6146 //----------------------------------------------------------------------------
6147 //----------------------------------------------------------------------------
6148 //----------------------------------------------------------------------------
6149 wxMPRWidget2::wxMPRWidget2(wxWindow* parent,marImageData *marimagedata,double voxelSize)
6150 : wxMPRWidget(parent,marimagedata,voxelSize)
6151 {
6152 }
6153 //----------------------------------------------------------------------------
6154 wxMPRWidget2::~wxMPRWidget2()
6155 {
6156 }
6157 //----------------------------------------------------------------------------
6158 void wxMPRWidget2::OnRefreshView(wxCommandEvent & event) // Virtual
6159 {
6160         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
6161     this->GetParent()->ProcessEvent(newevent1);
6162 }
6163
6164
6165 //----------------------------------------------------------------------------
6166 //----------------------------------------------------------------------------
6167 //----------------------------------------------------------------------------
6168 figureCuttingModel::figureCuttingModel()
6169 {
6170         _inversModel    = vtkTransform::New();
6171         _matrixModel    = vtkTransform::New();
6172         _matrixVisual   = vtkTransform::New();
6173
6174         _spcX=1;
6175         _spcY=1;
6176         _spcZ=1;
6177 }
6178 //----------------------------------------------------------------------------
6179 figureCuttingModel::~figureCuttingModel() // virtual
6180 {
6181         _inversModel->Delete();
6182 }
6183 //----------------------------------------------------------------------------
6184 void figureCuttingModel::SetPosition(double x,double y, double z)
6185 {
6186         _px=x;
6187         _py=y;
6188         _pz=z;
6189 }
6190 //----------------------------------------------------------------------------
6191 void figureCuttingModel::SetScale(double sx,double sy, double sz)
6192 {
6193         _sx=sx;
6194         _sy=sy;
6195         _sz=sz;
6196 }
6197 //----------------------------------------------------------------------------
6198 void figureCuttingModel::SetRotation(double alfa,double beta, double teta)
6199 {
6200         _alfa=alfa;
6201         _beta=beta;
6202         _teta=teta;
6203 }
6204
6205 //----------------------------------------------------------------------------
6206 void figureCuttingModel::CalculeMatrix()
6207 {
6208         _matrixModel->Identity();
6209         _matrixModel->Translate(_px,_py,_pz);
6210         _matrixModel->RotateY(_beta);
6211         _matrixModel->RotateX(_alfa);
6212         _matrixModel->RotateY(_teta);
6213         _matrixModel->Scale(_sx,_sy,_sz);
6214
6215         _matrixVisual->Identity();
6216         _matrixVisual->Translate( _px*_spcX  ,  _py*_spcY  ,  _pz*_spcZ  );
6217         _matrixVisual->RotateY(_beta);
6218         _matrixVisual->RotateX(_alfa);
6219         _matrixVisual->RotateY(_teta);
6220         _matrixVisual->Scale( _sx*_spcX  ,  _sy*_spcY  ,  _sz*_spcZ  );
6221
6222 }
6223
6224
6225 //----------------------------------------------------------------------------
6226 void figureCuttingModel::CalculeInversMatrix()
6227 {
6228         _inversModel->Identity ();
6229         _inversModel->Concatenate ( _matrixModel );
6230         _inversModel->Inverse();
6231 }
6232 //----------------------------------------------------------------------------
6233 bool figureCuttingModel::IfPointInside(double x, double y, double z) // virtual
6234 {
6235         return true;
6236 }
6237
6238 //----------------------------------------------------------------------------
6239 vtkTransform *figureCuttingModel::GetVtkTransform()
6240 {
6241         return _matrixVisual;
6242 }
6243
6244 //----------------------------------------------------------------------------
6245 //void figureCuttingModel::SetVtkTransform(vtkTransform *matrix)
6246 //{
6247 //      _matrixModel = matrix;
6248 //}
6249
6250 //----------------------------------------------------------------------------
6251 double figureCuttingModel::GetTheoricVolume() // virtual
6252 {
6253         return 0;
6254 }
6255
6256 //----------------------------------------------------------------------------
6257 double figureCuttingModel::GetPositionX()
6258 {
6259         return _px;
6260 }
6261 //----------------------------------------------------------------------------
6262 double figureCuttingModel::GetPositionY()
6263 {
6264         return _py;
6265 }
6266 //----------------------------------------------------------------------------
6267 double figureCuttingModel::GetPositionZ()
6268 {
6269         return _pz;
6270 }
6271 //----------------------------------------------------------------------------
6272 double figureCuttingModel::GetScaleX()
6273 {
6274         return _sx;
6275 }
6276 //----------------------------------------------------------------------------
6277 double figureCuttingModel::GetScaleY()
6278 {
6279         return _sy;
6280 }
6281 //----------------------------------------------------------------------------
6282 double figureCuttingModel::GetScaleZ()
6283 {
6284         return _sz;
6285 }
6286 //----------------------------------------------------------------------------
6287 double figureCuttingModel::GetAngleAlfa()
6288 {
6289         return _alfa;
6290 }
6291 //----------------------------------------------------------------------------
6292 double figureCuttingModel::GetAngleBeta()
6293 {
6294         return _beta;
6295 }
6296 //----------------------------------------------------------------------------
6297 double figureCuttingModel::GetAngleTeta()
6298 {
6299         return _teta;
6300 }
6301 //----------------------------------------------------------------------------
6302 char *figureCuttingModel::GetName() // virtual
6303 {
6304         return "--";
6305 }
6306
6307 //----------------------------------------------------------------------------
6308 void figureCuttingModel::SetSpacing(double spcX,double spcY, double spcZ)
6309 {
6310         _spcX = spcX;
6311         _spcY = spcY;
6312         _spcZ = spcZ;
6313 }
6314
6315 //----------------------------------------------------------------------------
6316
6317
6318 //----------------------------------------------------------------------------
6319 //----------------------------------------------------------------------------
6320 //----------------------------------------------------------------------------
6321 figureCuttingSphereModel::figureCuttingSphereModel()
6322 {
6323 }
6324 //----------------------------------------------------------------------------
6325 figureCuttingSphereModel::~figureCuttingSphereModel() // virtual
6326 {
6327 }
6328 //----------------------------------------------------------------------------
6329 bool figureCuttingSphereModel::IfPointInside(double x, double y, double z) // virtual
6330 {
6331         double in[4],out[4];
6332         in[0]=x;
6333         in[1]=y;
6334         in[2]=z;
6335         in[3]=1;
6336         _inversModel->MultiplyPoint (in, out);
6337
6338         bool result=false;
6339         if (sqrt( out[0]*out[0] + out[1]*out[1] + out[2]*out[2] )<0.5 )
6340         {
6341                 result=true;
6342         }
6343         return result;
6344 }
6345 //----------------------------------------------------------------------------
6346 double figureCuttingSphereModel::GetTheoricVolume() // virtual
6347 {
6348         double piTMP=3.14159265;
6349         return (4.0/3.0) * piTMP * (_sx/2)*(_sy/2)*(_sz/2);
6350 }
6351 //----------------------------------------------------------------------------
6352 char *figureCuttingSphereModel::GetName() // virtual
6353 {
6354         return "Sphere";
6355 }
6356
6357
6358 //----------------------------------------------------------------------------
6359 //----------------------------------------------------------------------------
6360 //----------------------------------------------------------------------------
6361 figureCuttingCubeModel::figureCuttingCubeModel()
6362 {
6363 }
6364 //----------------------------------------------------------------------------
6365 figureCuttingCubeModel::~figureCuttingCubeModel()  // virtual
6366 {
6367 }
6368 //----------------------------------------------------------------------------
6369 bool figureCuttingCubeModel::IfPointInside(double x, double y, double z) // virtual
6370 {
6371         double in[4],out[4];
6372         in[0]=x;
6373         in[1]=y;
6374         in[2]=z;
6375         in[3]=1;
6376         _inversModel->MultiplyPoint (in, out);
6377
6378         bool result=false;
6379         if ((out[0]>-0.5) && (out[0]<0.5) && (out[1]>-0.5) && (out[1]<0.5)  && (out[2]>-0.5) && (out[2]<0.5)  )
6380         {
6381                 result=true;
6382         }
6383         return result;
6384 }
6385 //----------------------------------------------------------------------------
6386 double figureCuttingCubeModel::GetTheoricVolume() // virtual
6387 {
6388         return _sx * _sy * _sz;
6389 }
6390
6391 //----------------------------------------------------------------------------
6392 char *figureCuttingCubeModel::GetName() // virtual
6393 {
6394         return "Cube";
6395 }
6396
6397 //----------------------------------------------------------------------------
6398 //----------------------------------------------------------------------------
6399 //----------------------------------------------------------------------------
6400
6401 figureCuttingCylinderModel::figureCuttingCylinderModel()
6402 {
6403 }
6404 //----------------------------------------------------------------------------
6405 figureCuttingCylinderModel::~figureCuttingCylinderModel()  // virtual
6406 {
6407 }
6408 //----------------------------------------------------------------------------
6409 bool figureCuttingCylinderModel::IfPointInside(double x, double y, double z) // virtual
6410 {
6411         double in[4],out[4];
6412         in[0]=x;
6413         in[1]=y;
6414         in[2]=z;
6415         in[3]=1;
6416         _inversModel->MultiplyPoint (in, out);
6417
6418         bool result=false;
6419         if ((sqrt( out[0]*out[0] + out[2]*out[2] )<0.5 )  && (out[1]>-0.5) && (out[1]<0.5)  )
6420         {
6421                 result=true;
6422         }
6423         return result;
6424 }
6425 //----------------------------------------------------------------------------
6426 double figureCuttingCylinderModel::GetTheoricVolume() // virtual
6427 {
6428         double piTMP=3.14159265;
6429         return piTMP*(_sx/2)*(_sz/2)*_sy;
6430 }
6431 //----------------------------------------------------------------------------
6432 char *figureCuttingCylinderModel::GetName() // virtual
6433 {
6434         return "Cylinder";
6435 }
6436 //----------------------------------------------------------------------------
6437
6438
6439
6440 // EOF - wxMPRWidget.cxx
6441
6442
6443
6444