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

   1 #include <vtkRenderer.h>
   2 #include <vtkRenderWindowInteractor.h>
   3 #include <vtkRenderWindow.h>
   4 #include <vtkObjectFactory.h>
   5 #include <vtkCamera.h>
   6 #include <vtkProperty.h>
   7 #include <vtkActor.h>
   8 #include <vtkInteractorStyleTrackballCamera.h>
   9 #include <vtkInteractorStyleSwitch.h>
  10 #include <vtkImageActor.h>
  11 #include <vtkTextProperty.h>
  12 #include <vtkImageMapToWindowLevelColors.h>
  13
  14 #include "wxVtkBaseView.h"
  15
  16
  17 vtkStandardNewMacro(vtkInteractorStyleBaseView);
  18 vtkStandardNewMacro(vtkInteractorStyleBaseView2D);
  19 vtkStandardNewMacro(vtkInteractorStyleBaseView3D);
  20
  21
  22
  23 //-------------------------------------------------------------------
  24 //-------------------------------------------------------------------
  25 //-------------------------------------------------------------------
  26 vtkImageViewer2_XYZ::vtkImageViewer2_XYZ()
  27 {
  28         _vtkimageviewer2=  vtkImageViewer2::New();
  29 }
  30 //-------------------------------------------------------------------
  31 vtkImageViewer2_XYZ::~vtkImageViewer2_XYZ()
  32 {
  33         _vtkimageviewer2->Delete();
  34 }
  35 //-------------------------------------------------------------------
  36 void vtkImageViewer2_XYZ::SetExtentDimension(int x1,int x2,
  37                                                                                          int y1,int y2,
  38                                                                                          int z1,int z2)
  39 {
  40         _x1=x1;
  41         _x2=x2;
  42         _y1=y1;
  43         _y2=y2;
  44         _z1=z1;
  45         _z2=z2;
  46 }
  47 //-------------------------------------------------------------------
  48 void vtkImageViewer2_XYZ::SetXSlice(int slice)
  49 {
  50         vtkImageActor *imageActor = _vtkimageviewer2->GetImageActor();
  51         imageActor->SetDisplayExtent(slice, slice, _y1, _y2, _z1, _z2 );
  52 }
  53 //-------------------------------------------------------------------
  54 void vtkImageViewer2_XYZ::SetYSlice(int slice)
  55 {
  56         vtkImageActor *imageActor = _vtkimageviewer2->GetImageActor();
  57         imageActor->SetDisplayExtent(_x1, _x2, slice, slice, _z1, _z2 );
  58 }
  59 //-------------------------------------------------------------------
  60 void vtkImageViewer2_XYZ::SetZSlice(int slice)
  61 {
  62 #if (VTK_MAJOR_VERSION >= 5)
  63 //              _vtkimageviewer2->SetSlice( slice );
  64         vtkImageActor *imageActor = _vtkimageviewer2->GetImageActor();
  65         imageActor->SetDisplayExtent(_x1, _x2, _y1, _y2, slice, slice );
  66 #else
  67                 _vtkimageviewer2->SetZSlice( slice );
  68 #endif
  69
  70
  71 }
  72 //-------------------------------------------------------------------
  73 int vtkImageViewer2_XYZ::GetXSlice()
  74 {
  75         vtkImageActor *imageActor = _vtkimageviewer2->GetImageActor();
  76         return imageActor->GetDisplayExtent()[0];
  77 }
  78 //-------------------------------------------------------------------
  79 int vtkImageViewer2_XYZ::GetYSlice()
  80 {
  81         vtkImageActor *imageActor = _vtkimageviewer2->GetImageActor();
  82         return imageActor->GetDisplayExtent()[2];
  83 }
  84 //-------------------------------------------------------------------
  85 int vtkImageViewer2_XYZ::GetZSlice()
  86 {
  87
  88          int result;
  89 #if (VTK_MAJOR_VERSION >= 5)
  90                 result= _vtkimageviewer2->GetSlice( );
  91 #else
  92                 result= _vtkimageviewer2->GetZSlice( );
  93 #endif
  94
  95
  96         return result;
  97 }
  98 //-------------------------------------------------------------------
  99 vtkImageViewer2 *vtkImageViewer2_XYZ::GetVtkImageViewer2()
 100 {
 101         return _vtkimageviewer2;
 102 }
 103
 104
 105 //-------------------------------------------------------------------
 106 //-------------------------------------------------------------------
 107 //-------------------------------------------------------------------
 108
 109
 110
 111 BEGIN_EVENT_TABLE( wxVTKRenderWindowInteractorPlus, wxVTKRenderWindowInteractor )
 112     EVT_LEFT_DCLICK( wxVTKRenderWindowInteractorPlus::OnLeftDClick )
 113     EVT_RIGHT_DCLICK( wxVTKRenderWindowInteractorPlus::OnRightDClick )
 114     EVT_MIDDLE_DCLICK( wxVTKRenderWindowInteractorPlus::OnMiddleDClick )
 115         EVT_MOUSEWHEEL( wxVTKRenderWindowInteractorPlus::OnMouseWheel )
 116 END_EVENT_TABLE( );
 117
 118 //-------------------------------------------------------------------
 119 wxVTKRenderWindowInteractorPlus::wxVTKRenderWindowInteractorPlus()
 120 : wxVTKRenderWindowInteractor()
 121 {
 122 }
 123
 124
 125 //-------------------------------------------------------------------
 126 wxVTKRenderWindowInteractorPlus::wxVTKRenderWindowInteractorPlus(wxWindow *parent, wxVtkBaseView *wxvtkbaseview)
 127 : wxVTKRenderWindowInteractor(parent, -1)
 128 {
 129         _wxvtkbaseview = wxvtkbaseview;
 130 }
 131
 132 //-------------------------------------------------------------------
 133 wxVTKRenderWindowInteractorPlus::~wxVTKRenderWindowInteractorPlus()
 134 {
 135 }
 136
 137 //---------------------------------------------------------------------------
 138 wxVTKRenderWindowInteractorPlus * wxVTKRenderWindowInteractorPlus::New()
 139 {
 140   // we don't make use of the objectfactory, because we're not registered
 141   return new wxVTKRenderWindowInteractorPlus;
 142 }
 143
 144 //-------------------------------------------------------------------
 145 void wxVTKRenderWindowInteractorPlus::OnLeftDClick( wxMouseEvent& event )
 146 {
 147         _wxvtkbaseview->GetInteractorStyleBaseView()->OnLeftDClick();
 148 }
 149 //-------------------------------------------------------------------
 150 void wxVTKRenderWindowInteractorPlus::OnRightDClick( wxMouseEvent& event )
 151 {
 152         _wxvtkbaseview->GetInteractorStyleBaseView()->OnRightDClick();
 153 }
 154 //-------------------------------------------------------------------
 155 void wxVTKRenderWindowInteractorPlus::OnMiddleDClick( wxMouseEvent& event )
 156 {
 157         _wxvtkbaseview->GetInteractorStyleBaseView()->OnMiddleDClick();
 158 }
 159 //-------------------------------------------------------------------
 160 void wxVTKRenderWindowInteractorPlus::OnMouseWheel( wxMouseEvent& event )
 161 {
 162         _wxvtkbaseview->GetInteractorStyleBaseView()->OnMouseWheel();
 163 }
 164
 165
 166
 167 //-------------------------------------------------------------------
 168 //-------------------------------------------------------------------
 169 //-------------------------------------------------------------------
 170 wxVtkBaseView::wxVtkBaseView()
 171 {
 172         _parent                         = NULL;
 173         _iren                           = NULL;
 174         _interactorStyle        = NULL;
 175 }
 176
 177 //-------------------------------------------------------------------
 178
 179 wxVtkBaseView::wxVtkBaseView(wxWindow *parent)
 180 {
 181         _parent                         = parent;
 182         _iren                           = new wxVTKRenderWindowInteractorPlus(_parent,this);
 183 //      _iren->UseCaptureMouseOn();
 184 //      _iren                           = new wxVTKRenderWindowInteractor(_parent,-1);
 185         _interactorStyle        = NULL;
 186
 187
 188 }
 189
 190 //-------------------------------------------------------------------
 191 wxVtkBaseView::~wxVtkBaseView()
 192 {
 193  //     _iren -> Delete();
 194 }
 195 //-------------------------------------------------------------------
 196 wxVTKRenderWindowInteractor* wxVtkBaseView::GetWxVTKRenderWindowInteractor()
 197 {
 198    return _iren;
 199 }
 200 //-------------------------------------------------------------------
 201 void wxVtkBaseView::Configure()  // virtual
 202 {
 203 }
 204 //-------------------------------------------------------------------
 205 void wxVtkBaseView::Refresh()  // virtual
 206 {
 207 // EED 10 Oct 2007
 208
 209         #if defined(WIN32)
 210                 _iren->Refresh(false);
 211         #else
 212                 _iren->Render();
 213                 //_iren->Refresh();
 214         #endif
 215
 216 }
 217 //-------------------------------------------------------------------
 218 void wxVtkBaseView::RefreshView()  // virtual
 219 {
 220 // EED 10 Oct 2007
 221
 222         #if defined(WIN32)
 223                 GetRenWin()->Render();
 224         #else
 225                 //GetRenWin()->Render();
 226         #endif
 227
 228 }
 229 //---------------------------------------------------------------------------
 230 vtkRenderer* wxVtkBaseView::GetRenderer()       // virtual
 231 {
 232         return NULL;
 233 }
 234 //---------------------------------------------------------------------------
 235 vtkRenderWindow* wxVtkBaseView::GetRenWin()             // virtual
 236 {
 237         return _iren->GetRenderWindow();
 238 }
 239
 240 //----------------------------------------------------------------------------
 241
 242 void wxVtkBaseView::TransfromeCoordScreenToWorld(double &X, double &Y, double &Z, int type) // virtual
 243 {
 244         GetRenderer()->SetDisplayPoint((int)X, (int)Y, (int)Z);
 245         GetRenderer()->DisplayToWorld();
 246         double fP[4];
 247         GetRenderer()->GetWorldPoint( fP );
 248         if ( fP[3] ){
 249                 fP[0] /= fP[3];
 250                 fP[1] /= fP[3];
 251                 fP[2] /= fP[3];
 252         }
 253
 254 // EEDx5
 255         this->GetInteractorStyleBaseView()->GetWxVtk2DBaseView()->TransformCoordinate_spacing_ViewToModel( fP[0] , fP[1] , fP[2] );
 256
 257         if (type!=0)
 258         {
 259                 X=fP[0];
 260         }
 261         if (type!=1)
 262         {
 263                 Y=fP[1];
 264         }
 265         if (type!=2)
 266         {
 267                 Z=fP[2];
 268         }
 269 }
 270
 271 //---------------------------------------------------------------------------
 272
 273 vtkInteractorStyleBaseView*     wxVtkBaseView::GetInteractorStyleBaseView()
 274 {
 275         return _interactorStyle;
 276 }
 277
 278 //---------------------------------------------------------------------------
 279
 280 void wxVtkBaseView::SetInteractorStyleBaseView( vtkInteractorStyleBaseView*     interactorStyle)
 281 {
 282         _interactorStyle = interactorStyle;
 283 }
 284
 285 //---------------------------------------------------------------------------
 286
 287 void wxVtkBaseView::GetSpacing(double spc[3])  // virtual
 288 {
 289         spc[0]=1;
 290         spc[1]=1;
 291         spc[2]=1;
 292 }
 293
 294
 295 //---------------------------------------------------------------------------
 296 //---------------------------------------------------------------------------
 297 //---------------------------------------------------------------------------
 298
 299 InteractorStyleMaracas::InteractorStyleMaracas()
 300 {
 301         _active                                         = true;
 302         _vtkInteractorStyleBaseView     = NULL;
 303 }
 304 //---------------------------------------------------------------------------
 305 InteractorStyleMaracas::~InteractorStyleMaracas()
 306 {
 307 }
 308
 309 // ----------------------------------------------------------------------------
 310 InteractorStyleMaracas * InteractorStyleMaracas :: Clone()  // virtual
 311 {
 312         InteractorStyleMaracas * clone = new InteractorStyleMaracas();
 313         CopyAttributesTo(clone);
 314         return clone;
 315 }
 316
 317 // ---------------------------------------------------------------------------
 318
 319 void InteractorStyleMaracas::CopyAttributesTo( InteractorStyleMaracas * cloneObject)
 320 {
 321         // Fathers object
 322         //<FATHERCLASS>::CopyAttributesTo(cloneObject);
 323
 324         cloneObject->SetActive(  this->GetActive() );
 325 }
 326
 327
 328 //---------------------------------------------------------------------------
 329 bool InteractorStyleMaracas::OnChar()
 330 {
 331         return true;
 332 }
 333 //---------------------------------------------------------------------------
 334 bool InteractorStyleMaracas::OnMouseMove()
 335 {
 336         return true;
 337 }
 338 //---------------------------------------------------------------------------
 339 bool InteractorStyleMaracas::OnLeftButtonDown()
 340 {
 341         return true;
 342 }
 343 //---------------------------------------------------------------------------
 344 bool InteractorStyleMaracas::OnLeftButtonUp()
 345 {
 346         return true;
 347 }
 348 //---------------------------------------------------------------------------
 349 bool  InteractorStyleMaracas::OnLeftDClick()
 350 {
 351         return true;
 352 }
 353 //---------------------------------------------------------------------------
 354 bool InteractorStyleMaracas::OnMiddleButtonDown()
 355 {
 356         return true;
 357 }
 358 //---------------------------------------------------------------------------
 359 bool InteractorStyleMaracas::OnMiddleButtonUp()
 360 {
 361         return true;
 362 }
 363 //---------------------------------------------------------------------------
 364 bool InteractorStyleMaracas::OnMiddleDClick()
 365 {
 366         return true;
 367 }
 368 //---------------------------------------------------------------------------
 369 bool InteractorStyleMaracas::OnRightButtonDown()
 370 {
 371         return true;
 372 }
 373 //---------------------------------------------------------------------------
 374 bool InteractorStyleMaracas::OnRightButtonUp()
 375 {
 376         return true;
 377 }
 378 //---------------------------------------------------------------------------
 379 bool InteractorStyleMaracas::OnRightDClick()
 380 {
 381         return true;
 382 }
 383 //---------------------------------------------------------------------------
 384 bool InteractorStyleMaracas::OnMouseWheel()
 385 {
 386         return true;
 387 }
 388
 389 //---------------------------------------------------------------------------
 390 void InteractorStyleMaracas::SetVtkInteractorStyleBaseView(vtkInteractorStyleBaseView* vtkInteractorStyleBaseView)
 391 {
 392         _vtkInteractorStyleBaseView = vtkInteractorStyleBaseView;
 393 }
 394
 395 //---------------------------------------------------------------------------
 396 void InteractorStyleMaracas::RemoveVtkInteractorStyleBaseView()
 397 {
 398         _vtkInteractorStyleBaseView = NULL;
 399 }
 400 //---------------------------------------------------------------------------
 401 void InteractorStyleMaracas::SetActive(bool active)
 402 {
 403         _active = active;
 404 }
 405 //---------------------------------------------------------------------------
 406 bool InteractorStyleMaracas::GetActive()
 407 {
 408         return _active;
 409 }
 410
 411
 412
 413 //-------------------------------------------------------------------
 414 //-------------------------------------------------------------------
 415 //-------------------------------------------------------------------
 416
 417 manualInteractorWindowLevel::manualInteractorWindowLevel()
 418 {
 419         _stateWindowLevel       =       false;
 420         _backPx                         =       0;
 421         _backPy                         =       0;
 422         _backWindow                     =       -1;
 423         _backLevel                      =       -1;
 424 }
 425
 426 //-------------------------------------------------------------------
 427
 428 manualInteractorWindowLevel::~manualInteractorWindowLevel()
 429 {
 430 }
 431
 432 //-------------------------------------------------------------------
 433
 434 bool manualInteractorWindowLevel::OnMouseMove()                 // virtual
 435 {
 436
 437         if (_stateWindowLevel==true)
 438         {
 439                 int tmpPx,tmpPy;
 440                 wxVTKRenderWindowInteractor *wxVTKiren;
 441                 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
 442                 wxVTKiren->GetEventPosition( tmpPx , tmpPy );
 443                 int colorWin=_backWindow - 2*( _backPx - tmpPx );
 444                 int colorLev=_backLevel  + 2*( _backPy - tmpPy );
 445
 446                 if (colorWin<0)
 447                 {
 448                         colorWin=0;
 449                 }
 450                 if (colorWin>100000)
 451                 {
 452                         colorWin=100000;
 453                 }
 454
 455                 if (colorLev<0)
 456                 {
 457                         colorLev=0;
 458                 }
 459                 if (colorLev>100000)
 460                 {
 461                         colorLev=100000;
 462                 }
 463                 vtkImageViewer2 *vtkimageviewer2;
 464                 vtkimageviewer2=_vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->_imageViewer2XYZ->GetVtkImageViewer2();
 465                 vtkimageviewer2->SetColorWindow(colorWin);
 466                 vtkimageviewer2->SetColorLevel(colorLev);
 467 //              vtkimageviewer2->Render();
 468         }
 469         return true;
 470 }
 471
 472 //-------------------------------------------------------------------
 473
 474 bool manualInteractorWindowLevel::OnMiddleButtonDown()  // virtual
 475 {
 476         if ((_vtkInteractorStyleBaseView->GetInteractor()->GetControlKey()==0) &&
 477                 (_vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey()==0) ){
 478
 479                 _stateWindowLevel       = true;
 480                 wxVTKRenderWindowInteractor *wxVTKiren;
 481                 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
 482                 wxVTKiren->GetEventPosition( _backPx , _backPy );
 483
 484                 _backWindow = (int)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->_imageViewer2XYZ->GetVtkImageViewer2()->GetColorWindow());
 485                 _backLevel  = (int)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->_imageViewer2XYZ->GetVtkImageViewer2()->GetColorLevel());
 486         }
 487         return true;
 488 }
 489
 490 //-------------------------------------------------------------------
 491
 492 bool manualInteractorWindowLevel::OnMiddleButtonUp()            // virtual
 493 {
 494         if (_stateWindowLevel==true)
 495         {
 496                 _stateWindowLevel=false;
 497         }
 498         return true;
 499 }
 500
 501
 502
 503 //---------------------------------------------------------------------------
 504 //---------------------------------------------------------------------------
 505 //---------------------------------------------------------------------------
 506
 507 vtkInteractorScrollZ::vtkInteractorScrollZ()
 508 {
 509         _stateFordware=false;
 510 }
 511 //---------------------------------------------------------------------------
 512 vtkInteractorScrollZ::~vtkInteractorScrollZ()
 513 {
 514 }
 515 //---------------------------------------------------------------------------
 516 bool vtkInteractorScrollZ::OnRightButtonDown()
 517 {
 518         vtkRenderWindowInteractor *interactor = _vtkInteractorStyleBaseView->GetInteractor();
 519         if ((interactor->GetControlKey()==0) && (interactor->GetShiftKey()==0) ){
 520                 _stateFordware  = true;
 521                 _fordwareX      = interactor->GetEventPosition()[0];
 522                 _fordwareY      = interactor->GetEventPosition()[1];
 523                 _sliceZ         = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetActualSlice();
 524         }
 525         return true;
 526 }
 527 //---------------------------------------------------------------------------
 528 bool vtkInteractorScrollZ::OnRightButtonUp()
 529 {
 530         _stateFordware=false;
 531         return true;
 532 }
 533 //---------------------------------------------------------------------------
 534 bool vtkInteractorScrollZ::OnMouseMove ()
 535 {
 536         if (_stateFordware==true){
 537             //int fx = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];  // JPRx
 538         int fy = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
 539                 int delta = (_fordwareY - fy)/3;
 540                 _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->SetActualSlice( _sliceZ + delta);
 541
 542                 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
 543
 544         //      wxCommandEvent newevent(wxEVT_COMMAND_MENU_SELECTED,12121);
 545         //      _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent);
 546
 547                 //_wxvtk2Dbaseview->Refresh();
 548         }
 549         return true;
 550 }
 551
 552
 553
 554
 555
 556 //---------------------------------------------------------------------------
 557 //---------------------------------------------------------------------------
 558 //---------------------------------------------------------------------------
 559
 560 vtkInteractorStyleBaseView::vtkInteractorStyleBaseView()
 561 {
 562         _refresh_waiting                = false;
 563         _parent_refresh_waiting = false;
 564         _blockRefresh                   = false;
 565 }
 566 //---------------------------------------------------------------------------
 567 vtkInteractorStyleBaseView::~vtkInteractorStyleBaseView()
 568 {
 569 }
 570 //---------------------------------------------------------------------------
 571 void vtkInteractorStyleBaseView::OnMouseMove() // virtual
 572 {
 573         CallLstInteractorStyleMaracas(3);
 574 }
 575 //---------------------------------------------------------------------------
 576 void vtkInteractorStyleBaseView::OnLeftButtonDown()  // virtual
 577 {
 578         CallLstInteractorStyleMaracas(4);
 579 }
 580 //---------------------------------------------------------------------------
 581 void vtkInteractorStyleBaseView::OnLeftButtonUp() // virtual
 582 {
 583         CallLstInteractorStyleMaracas(5);
 584 }
 585
 586 //---------------------------------------------------------------------------
 587 void vtkInteractorStyleBaseView::OnLeftDClick()  // virtual
 588 {
 589         CallLstInteractorStyleMaracas( 11 );
 590 }
 591
 592 //---------------------------------------------------------------------------
 593 void vtkInteractorStyleBaseView::OnMiddleButtonDown()  // virtual
 594 {
 595         CallLstInteractorStyleMaracas(6);
 596 }
 597 //---------------------------------------------------------------------------
 598 void vtkInteractorStyleBaseView::OnMiddleButtonUp() // virtual
 599 {
 600         CallLstInteractorStyleMaracas(7);
 601 }
 602 //---------------------------------------------------------------------------
 603 void vtkInteractorStyleBaseView::OnMiddleDClick()  // virtual
 604 {
 605         CallLstInteractorStyleMaracas( 13 );
 606 }
 607
 608 //---------------------------------------------------------------------------
 609 void vtkInteractorStyleBaseView::OnRightButtonDown() // virtual
 610 {
 611         CallLstInteractorStyleMaracas(1);
 612 }
 613 //---------------------------------------------------------------------------
 614 void vtkInteractorStyleBaseView::OnRightButtonUp() // virtual
 615 {
 616         CallLstInteractorStyleMaracas(2);
 617 }
 618 //---------------------------------------------------------------------------
 619 void vtkInteractorStyleBaseView::OnRightDClick()  // virtual
 620 {
 621         CallLstInteractorStyleMaracas( 12 );
 622 }
 623 //---------------------------------------------------------------------------
 624 void vtkInteractorStyleBaseView::OnMouseWheel()  // virtual
 625 {
 626         CallLstInteractorStyleMaracas( 14 );
 627 }
 628 //---------------------------------------------------------------------------
 629 void vtkInteractorStyleBaseView::AddInteractorStyleMaracas(InteractorStyleMaracas* interactorStyleMaracas)
 630 {
 631         interactorStyleMaracas->SetVtkInteractorStyleBaseView(this);
 632         _lstInteractorStyleMaracas.push_back(interactorStyleMaracas);
 633 }
 634 //---------------------------------------------------------------------------
 635 void  vtkInteractorStyleBaseView::RemoveInteractorStyleMaracas(InteractorStyleMaracas* interactorStyleMaracas)
 636 {
 637         interactorStyleMaracas->RemoveVtkInteractorStyleBaseView();
 638         int i, size = _lstInteractorStyleMaracas.size();
 639         std::vector< InteractorStyleMaracas* >::iterator iter = _lstInteractorStyleMaracas.begin();
 640         bool removed = false;
 641         for (i=0; !removed && i<size; i++)
 642         {
 643                 if ( _lstInteractorStyleMaracas[i] == interactorStyleMaracas )
 644                 {
 645                         _lstInteractorStyleMaracas.erase(iter);
 646                         removed = true;
 647                 }
 648                 iter++;
 649         }
 650 }
 651 //---------------------------------------------------------------------------
 652 void vtkInteractorStyleBaseView::InsertInteractorStyleMaracas(int pos, InteractorStyleMaracas* interactorStyleMaracas)
 653 {
 654         interactorStyleMaracas->SetVtkInteractorStyleBaseView(this);
 655         _lstInteractorStyleMaracas.insert(_lstInteractorStyleMaracas.begin()+pos,interactorStyleMaracas);
 656 }
 657 //---------------------------------------------------------------------------
 658 void vtkInteractorStyleBaseView::CallLstInteractorStyleMaracas(int type)
 659 {
 660
 661         InteractorStyleMaracas *intStyMar;
 662
 663         int i,size=_lstInteractorStyleMaracas.size();
 664
 665 //EED Borrame
 666 //FILE *ff = fopen("c:/temp/wxVtkBaseView_SceneManagerStadistics.txt","a+");
 667 //fprintf(ff,"EED vtkInteractorStyleBaseView::CallLstInteractorStyleMaracas \n" );
 668 //for (i=0;i<size;i++)
 669 //{
 670 //fprintf(ff,"    %p\n" , _lstInteractorStyleMaracas[i] );
 671 //}
 672 //fclose(ff);
 673
 674
 675
 676         for (i=0;i<size;i++)
 677         {
 678                 intStyMar = _lstInteractorStyleMaracas[i];
 679                 if (intStyMar->GetActive()==true){
 680                         if (type ==1)
 681                         {  // OnRightButtonDown
 682                                 if (intStyMar->OnRightButtonDown()==false)
 683                                 {
 684                                         i=size;
 685                                 }
 686                         }
 687                         if (type ==2)
 688                         {  // OnRightButtonUp
 689                                 if (intStyMar->OnRightButtonUp()==false)
 690                                 {
 691                                         i=size;
 692                                 }
 693                         }
 694                         if (type==3)
 695                         {  // OnMouseMouve
 696                                 if (intStyMar->OnMouseMove()==false)
 697                                 {
 698                                         i=size;
 699                                 }
 700                         }
 701                         if (type==4)
 702                         {  // OnLeftButtonDown
 703                                 if (intStyMar->OnLeftButtonDown()==false)
 704                                 {
 705                                         i=size;
 706                                 }
 707                         }
 708                         if (type==5)
 709                         {  // OnLeftButtonUp
 710                                 if (intStyMar->OnLeftButtonUp()==false)
 711                                 {
 712                                         i=size;
 713                                 }
 714                         }
 715                         if (type==6)
 716                         {  // OnMiddleButtonDown
 717                                 if (intStyMar->OnMiddleButtonDown()==false)
 718                                 {
 719                                         i=size;
 720                                 }
 721                         }
 722                         if (type==7)
 723                         {  // OnMiddleButtonUp
 724                                 if (intStyMar->OnMiddleButtonUp()==false)
 725                                 {
 726                                         i=size;
 727                                 }
 728                         }
 729                         if (type==10)
 730                         {  // OnMiddleButtonUp
 731                                 if (intStyMar->OnChar()==false)
 732                                 {
 733                                         i=size;
 734                                 }
 735                         }
 736                         if (type==11)
 737                         {  // OnLeftDClick
 738                                 if (intStyMar->OnLeftDClick()==false)
 739                                 {
 740                                         i=size;
 741                                 }
 742                         }
 743                         if (type==12)
 744                         {  // OnRightDClick
 745                                 if (intStyMar->OnRightDClick()==false)
 746                                 {
 747                                         i=size;
 748                                 }
 749                         }
 750                         if (type==13)
 751                         {  // OnMiddleDClick
 752                                 if (intStyMar-> OnMiddleDClick()==false)
 753                                 {
 754                                         i=size;
 755                                 }
 756                         }
 757                         if (type==14)
 758                         {  // OnMouseWheel
 759                                 if (intStyMar->OnMouseWheel()==false)
 760                                 {
 761                                         i=size;
 762                                 }
 763                         }
 764                 } // if active
 765         } // for
 766
 767         EvaluateToRefresh();
 768 }
 769 //---------------------------------------------------------------------------
 770 void  vtkInteractorStyleBaseView::OnChar()  // virtual
 771 {
 772 //      char a=GetInteractor()->GetKeyCode();
 773         CallLstInteractorStyleMaracas(10);
 774 }
 775 //---------------------------------------------------------------------------
 776 void vtkInteractorStyleBaseView::TransformCoordinate(double &X, double &Y, double &Z)
 777 {
 778     vtkImageViewer2 *imageViewer = GetWxVtk2DBaseView()->_imageViewer2XYZ->GetVtkImageViewer2();
 779
 780         imageViewer->GetRenderer()->SetDisplayPoint((int)X, (int)Y, (int)Z);
 781         imageViewer->GetRenderer()->DisplayToWorld();
 782         double fP[4];
 783         imageViewer->GetRenderer()->GetWorldPoint( fP );
 784
 785         if ( fP[3] ){
 786                 fP[0] /= fP[3];
 787                 fP[1] /= fP[3];
 788                 fP[2] /= fP[3];
 789         }
 790
 791 // EEDx5
 792         GetWxVtk2DBaseView()->TransformCoordinate_spacing_ViewToModel(fP[0],fP[1],fP[2]);
 793
 794         X=fP[0];
 795         Y=fP[1];
 796         Z=fP[2];
 797 }
 798 //---------------------------------------------------------------------------
 799 void vtkInteractorStyleBaseView::SetwxVtkBaseView(wxVtkBaseView *wxvtkbaseview)
 800 {
 801         _wxvtkbaseview = wxvtkbaseview;
 802 }
 803 //---------------------------------------------------------------------------
 804 wxVtk2DBaseView* vtkInteractorStyleBaseView::GetWxVtk2DBaseView()
 805 {
 806         return (wxVtk2DBaseView*)_wxvtkbaseview;
 807 }
 808 //---------------------------------------------------------------------------
 809 wxVtk3DBaseView* vtkInteractorStyleBaseView::GetWxVtk3DBaseView()
 810 {
 811         return (wxVtk3DBaseView*)_wxvtkbaseview;
 812 }
 813 //---------------------------------------------------------------------------
 814 void vtkInteractorStyleBaseView::SetActiveAllInteractors(bool ok)
 815 {
 816         InteractorStyleMaracas *intStyMar;
 817         int i,size=_lstInteractorStyleMaracas.size();
 818         for (i=0;i<size;i++)
 819         {
 820                 intStyMar = _lstInteractorStyleMaracas[i];
 821                 intStyMar->SetActive(ok);
 822         }
 823
 824 }
 825 //---------------------------------------------------------------------------
 826 void vtkInteractorStyleBaseView::SetRefresh_waiting()
 827 {
 828         _refresh_waiting=true;
 829 }
 830 //---------------------------------------------------------------------------
 831 bool vtkInteractorStyleBaseView::GetRefresh_waiting()
 832 {
 833         return _refresh_waiting;
 834 }
 835 //---------------------------------------------------------------------------
 836 void vtkInteractorStyleBaseView::SetParent_refresh_waiting()
 837 {
 838         _parent_refresh_waiting=true;
 839 }
 840 //---------------------------------------------------------------------------
 841 bool vtkInteractorStyleBaseView::GetParent_refresh_waiting()
 842 {
 843         return _parent_refresh_waiting;
 844 }
 845 //---------------------------------------------------------------------------
 846 void vtkInteractorStyleBaseView::EvaluateToRefresh()
 847 {
 848
 849         if  ( _blockRefresh==false )
 850         {
 851                 if ( (_refresh_waiting==true) && (_parent_refresh_waiting==false))
 852                 {
 853                         _refresh_waiting                = false;
 854                         this->_wxvtkbaseview->Refresh();
 855                 }
 856                 if (_parent_refresh_waiting==true)
 857                 {
 858                         _parent_refresh_waiting = false;
 859                         wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121);  // Refresh
 860                         this->_wxvtkbaseview->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
 861                 }
 862         }
 863 }
 864 //---------------------------------------------------------------------------
 865 void vtkInteractorStyleBaseView::BlockRefresh()
 866 {
 867         _blockRefresh=true;
 868 }
 869 //---------------------------------------------------------------------------
 870 void vtkInteractorStyleBaseView::UnBlockRefresh()
 871 {
 872         _blockRefresh=false;
 873 }
 874
 875 //---------------------------------------------------------------------------
 876 //---------------------------------------------------------------------------
 877 //---------------------------------------------------------------------------
 878
 879
 880
 881 //---------------------------------------------------------------------------
 882 vtkInteractorStyleBaseView2D::vtkInteractorStyleBaseView2D()
 883 {
 884         _manualinteractorwindowlevel= new manualInteractorWindowLevel();
 885         AddInteractorStyleMaracas( _manualinteractorwindowlevel );
 886
 887         _vtkInteractorScrollZ = new vtkInteractorScrollZ();
 888         AddInteractorStyleMaracas(_vtkInteractorScrollZ);
 889
 890 }
 891 //---------------------------------------------------------------------------
 892 vtkInteractorStyleBaseView2D::~vtkInteractorStyleBaseView2D()
 893 {
 894 }
 895
 896 //---------------------------------------------------------------------------
 897 void  vtkInteractorStyleBaseView2D::OnRightButtonDown()  // virtual
 898 {
 899         vtkInteractorStyleBaseView::OnRightButtonDown();
 900
 901         if ((GetInteractor()->GetControlKey()==1) && (GetInteractor()->GetShiftKey()==0) ){
 902                 this->vtkInteractorStyleImage::OnRightButtonDown();
 903         }
 904
 905 }
 906
 907 //---------------------------------------------------------------------------
 908 void  vtkInteractorStyleBaseView2D::OnRightButtonUp()  // virtual
 909 {
 910         vtkInteractorStyleBaseView::OnRightButtonUp();
 911         this->vtkInteractorStyleImage::OnRightButtonUp();
 912 }
 913 //---------------------------------------------------------------------------
 914 void  vtkInteractorStyleBaseView2D::OnMouseMove () // virtual
 915 {
 916         vtkInteractorStyleBaseView::OnMouseMove();
 917         this->vtkInteractorStyleImage::OnMouseMove();
 918 }
 919 //---------------------------------------------------------------------------
 920 void  vtkInteractorStyleBaseView2D::OnLeftButtonDown() // virtual
 921 {
 922         vtkInteractorStyleBaseView::OnLeftButtonDown();
 923
 924         if ((GetInteractor()->GetControlKey()==0) && (GetInteractor()->GetShiftKey()==1) )
 925         {
 926                 this->vtkInteractorStyleImage::OnLeftButtonDown();
 927         }
 928 }
 929 //---------------------------------------------------------------------------
 930 void  vtkInteractorStyleBaseView2D::OnLeftButtonUp () // virtual
 931 {
 932         vtkInteractorStyleBaseView::OnLeftButtonUp();
 933
 934         this->vtkInteractorStyleImage::OnLeftButtonUp();
 935 }
 936 //---------------------------------------------------------------------------
 937 void  vtkInteractorStyleBaseView2D::OnMiddleButtonDown () // virtual
 938 {
 939         vtkInteractorStyleBaseView::OnMiddleButtonDown();
 940
 941         if ((GetInteractor()->GetControlKey()==1) || (GetInteractor()->GetShiftKey()==1) )
 942         {
 943                 this->vtkInteractorStyleImage::OnLeftButtonDown();
 944         }
 945 }
 946 //---------------------------------------------------------------------------
 947 void vtkInteractorStyleBaseView2D::OnMiddleButtonUp () // virtual
 948 {
 949         vtkInteractorStyleBaseView::OnMiddleButtonUp();
 950
 951         if ((GetInteractor()->GetControlKey()==1) || (GetInteractor()->GetShiftKey()==1) )
 952         {
 953                 this->vtkInteractorStyleImage::OnLeftButtonUp();
 954         }
 955 }
 956
 957
 958
 959 //-------------------------------------------------------------------
 960 //-------------------------------------------------------------------
 961 //-------------------------------------------------------------------
 962
 963
 964 //---------------------------------------------------------------------------
 965 vtkInteractorStyleBaseView3D::vtkInteractorStyleBaseView3D(){
 966 }
 967 //---------------------------------------------------------------------------
 968 vtkInteractorStyleBaseView3D::~vtkInteractorStyleBaseView3D(){
 969 }
 970 //---------------------------------------------------------------------------
 971 void  vtkInteractorStyleBaseView3D::OnRightButtonDown ()
 972 {
 973         vtkInteractorStyleBaseView::OnRightButtonDown();
 974
 975 /*
 976                 if (GetInteractor()->GetControlKey()==1 ){
 977                         this->vtkInteractorStyleTrackballCamera::OnRightButtonDown();
 978                 }
 979 */
 980   this->FindPokedRenderer(this->Interactor->GetEventPosition()[0],
 981                           this->Interactor->GetEventPosition()[1]);
 982
 983   if (this->CurrentRenderer == NULL)
 984     {
 985     return;
 986     }
 987
 988   if (this->Interactor->GetControlKey()) {
 989       this->StartDolly();
 990   }
 991
 992 }
 993 //---------------------------------------------------------------------------
 994 void  vtkInteractorStyleBaseView3D::OnRightButtonUp ()
 995 {
 996         vtkInteractorStyleBaseView::OnRightButtonUp();
 997
 998 /*
 999                 if (GetInteractor()->GetControlKey()==1 ){
1000                         this->vtkInteractorStyleTrackballCamera::OnRightButtonUp();
1001                 }
1002 */
1003
1004
1005   switch (this->State)
1006     {
1007     case VTKIS_DOLLY:
1008       this->EndDolly();
1009       break;
1010     }
1011 }
1012 //---------------------------------------------------------------------------
1013 void  vtkInteractorStyleBaseView3D::OnMouseMove ()
1014 {
1015         vtkInteractorStyleBaseView::OnMouseMove();
1016
1017 //              this->vtkInteractorStyleTrackballCamera::OnMouseMove();
1018
1019  // int x = this->Interactor->GetEventPosition()[0]; // JPRx
1020  // int y = this->Interactor->GetEventPosition()[1]; // JPRx
1021
1022
1023  // vtkRenderWindowInteractor *rwi = this->Interactor;
1024
1025  // int lx =  rwi->GetLastEventPosition()[0]; // JPRx
1026  // int ly =  rwi->GetLastEventPosition()[1]; // JPRx
1027  // int dx = rwi->GetEventPosition()[0] ; // JPRx
1028  // int dy = rwi->GetEventPosition()[1] ; // JPRx
1029
1030
1031   switch (this->State)
1032     {
1033     case VTKIS_ROTATE:
1034  //     this->FindPokedRenderer(x, y);
1035       this->Rotate();
1036  //     this->InvokeEvent(vtkCommand::InteractionEvent, NULL);
1037       break;
1038
1039     case VTKIS_PAN:
1040  //     this->FindPokedRenderer(x, y);
1041       this->Pan();
1042  //     this->InvokeEvent(vtkCommand::InteractionEvent, NULL);
1043       break;
1044
1045     case VTKIS_DOLLY:
1046  //     this->FindPokedRenderer(x, y);
1047       this->Dolly();
1048  //     this->InvokeEvent(vtkCommand::InteractionEvent, NULL);
1049       break;
1050
1051     case VTKIS_SPIN:
1052  //     this->FindPokedRenderer(x, y);
1053       this->Spin();
1054  //     this->InvokeEvent(vtkCommand::InteractionEvent, NULL);
1055       break;
1056     }
1057
1058
1059
1060 }
1061 //---------------------------------------------------------------------------
1062 void  vtkInteractorStyleBaseView3D::OnLeftButtonDown ()
1063 {
1064         vtkInteractorStyleBaseView::OnLeftButtonDown();
1065 /*
1066                 if (GetInteractor()->GetControlKey()==1 ){
1067                         this->vtkInteractorStyleTrackballCamera::OnMiddleButtonDown();
1068                 } else {
1069                         this->vtkInteractorStyleTrackballCamera::OnLeftButtonDown();
1070                 }
1071 */
1072
1073
1074   this->FindPokedRenderer(this->Interactor->GetEventPosition()[0],
1075                           this->Interactor->GetEventPosition()[1]);
1076   if (this->CurrentRenderer == NULL)
1077     {
1078     return;
1079     }
1080
1081   if (this->Interactor->GetControlKey()) {
1082       this->StartPan();
1083   } else {
1084       this->StartRotate();
1085   }
1086
1087  /*
1088   if (this->Interactor->GetShiftKey())
1089     {
1090     if (this->Interactor->GetControlKey())
1091       {
1092       this->StartDolly();
1093       }
1094     else
1095       {
1096       this->StartPan();
1097       }
1098     }
1099   else
1100     {
1101     if (this->Interactor->GetControlKey())
1102       {
1103       this->StartSpin();
1104       }
1105     else
1106       {
1107       this->StartRotate();
1108       }
1109     }
1110 */
1111
1112
1113 }
1114 //---------------------------------------------------------------------------
1115 void  vtkInteractorStyleBaseView3D::OnLeftButtonUp ()
1116 {
1117         vtkInteractorStyleBaseView::OnLeftButtonUp();
1118
1119 /*
1120                 if (GetInteractor()->GetControlKey()==1 ){
1121                         this->vtkInteractorStyleTrackballCamera::OnMiddleButtonUp();
1122                 } else {
1123                         this->vtkInteractorStyleTrackballCamera::OnLeftButtonUp();
1124                 }
1125 */
1126   switch (this->State)
1127     {
1128
1129     case VTKIS_PAN:
1130       this->EndPan();
1131       break;
1132
1133     case VTKIS_ROTATE:
1134       this->EndRotate();
1135       break;
1136     }
1137 }
1138 //---------------------------------------------------------------------------
1139 void  vtkInteractorStyleBaseView3D::OnMiddleButtonDown ()
1140 {
1141         vtkInteractorStyleBaseView::OnMiddleButtonDown();
1142         //              this->vtkInteractorStyleTrackballCamera::OnMiddleButtonDown();
1143 }
1144 //---------------------------------------------------------------------------
1145 void  vtkInteractorStyleBaseView3D::OnMiddleButtonUp ()
1146 {
1147         vtkInteractorStyleBaseView::OnMiddleButtonUp();
1148
1149         //              this->vtkInteractorStyleTrackballCamera::OnMiddleButtonUp();
1150 }
1151
1152
1153 //-------------------------------------------------------------------
1154 //-------------------------------------------------------------------
1155 //-------------------------------------------------------------------
1156
1157 vtkInfoTextImage::vtkInfoTextImage()
1158 {
1159         _vtkText_WindowLevel    = NULL;
1160         _vtkText_ColorLevel             = NULL;
1161         _vtkText_position               = NULL;
1162         _vtkText_pixelIntensity = NULL;
1163         _marimagedata                   = NULL;
1164 }
1165
1166 //-------------------------------------------------------------------
1167
1168 vtkInfoTextImage::~vtkInfoTextImage()
1169 {
1170 }
1171
1172 //-------------------------------------------------------------------
1173
1174 void vtkInfoTextImage::Configure()
1175 {
1176         _vtkText_WindowLevel    = Create_Text_Label( 10 , 55 );
1177         _vtkText_ColorLevel             = Create_Text_Label( 10 , 40 );
1178         _vtkText_position               = Create_Text_Label( 10 , 25 );
1179         _vtkText_pixelIntensity = Create_Text_Label( 10 , 10 );
1180 }
1181
1182
1183 //-------------------------------------------------------------------
1184
1185 void vtkInfoTextImage::SetMarImageData(marImageData *marimagedata)
1186 {
1187         _marimagedata=marimagedata;
1188 }
1189
1190 //-------------------------------------------------------------------
1191
1192 void vtkInfoTextImage::SetWxVtk2DBaseView(wxVtk2DBaseView *wxvtk2Dbaseview)
1193 {
1194         _wxvtk2Dbaseview=wxvtk2Dbaseview;
1195 }
1196
1197 //-------------------------------------------------------------------
1198
1199 vtkTextActor *vtkInfoTextImage::Create_Text_Label(int px, int py )
1200 {
1201         // Text Window Level
1202         vtkTextActor *textActor = vtkTextActor::New();
1203         textActor->SetDisplayPosition(px, py);
1204         textActor->SetInput("0");
1205
1206         // Set coordinates to match the old vtkScaledTextActor default value
1207         textActor->GetPosition2Coordinate()->SetCoordinateSystemToNormalizedViewport();
1208         textActor->GetPosition2Coordinate()->SetValue( 0.2 , 0.2 );
1209
1210         vtkTextProperty *tprop = textActor->GetTextProperty();
1211         tprop->SetFontSize(14);
1212         tprop->SetFontFamilyToArial();
1213         tprop->SetColor(1, 1, 0);
1214         _wxvtk2Dbaseview->GetRenderer()->AddActor2D(textActor);
1215
1216         return textActor;
1217 }
1218
1219 //-------------------------------------------------------------------
1220
1221 void vtkInfoTextImage::PutWindowLevel()
1222 {
1223         int value = (int)( _wxvtk2Dbaseview->_imageViewer2XYZ->GetVtkImageViewer2()->GetWindowLevel()->GetWindow() );
1224         char zTzxt[20];
1225         char resultText[50];
1226
1227         strcpy(resultText,"w:");
1228
1229
1230         //ltoa ( (long)value , zTzxt , 10 );
1231         sprintf(zTzxt,"%d",value);
1232
1233         strcat(resultText,zTzxt);
1234         _vtkText_WindowLevel            -> SetInput(resultText);
1235 }
1236
1237 //-------------------------------------------------------------------
1238
1239 void vtkInfoTextImage::PutColorLevel()
1240 {
1241         int value = (int)(_wxvtk2Dbaseview->_imageViewer2XYZ->GetVtkImageViewer2()->GetWindowLevel()->GetLevel());
1242         char zTzxt[20];
1243         char resultText[50];
1244
1245         strcpy(resultText,"c:");
1246
1247 //      itoa (value,zTzxt,10);
1248         sprintf(zTzxt,"%d",value);
1249
1250         strcat(resultText,zTzxt);
1251         _vtkText_ColorLevel             -> SetInput(resultText);
1252 }
1253
1254 //-------------------------------------------------------------------
1255
1256 void vtkInfoTextImage::PutPosition(int xx,int yy, int zz)
1257 {
1258
1259 //EEDx7
1260 //      double spa[3];
1261 //      _imagedata->GetSpacing(spa);
1262 //      xx=xx*(1/spa[0]);
1263 //      yy=yy*(1/spa[1]);
1264
1265
1266         char zTzxt[50];
1267         char resultText[50];
1268         strcpy(resultText,"p: ");
1269 //      itoa ((int)xx,zTzxt,10);
1270         sprintf(zTzxt,"%d",xx);
1271
1272         strcat(resultText,zTzxt);
1273         strcat(resultText," , ");
1274
1275 //      itoa ((int)yy,zTzxt,10);
1276         sprintf(zTzxt,"%d",yy);
1277
1278         strcat(resultText,zTzxt);
1279         strcat(resultText," , ");
1280
1281 //      itoa ((int)zz,zTzxt,10);
1282         sprintf(zTzxt,"%d",zz);
1283
1284         strcat(resultText,zTzxt);
1285
1286
1287
1288         int nX = _marimagedata->GetXOriginal(xx);
1289         int nY = _marimagedata->GetYOriginal(yy);
1290         int nZ = _marimagedata->GetZOriginal(zz);
1291
1292         strcat(resultText,"   (");
1293 //      ltoa ((int)nX,zTzxt,10);
1294         sprintf(zTzxt,"%d",nX);
1295
1296         strcat(resultText,zTzxt);
1297         strcat(resultText,",");
1298
1299 //      ltoa ((int)nY,zTzxt,10);
1300         sprintf(zTzxt,"%d",nY);
1301
1302         strcat(resultText,zTzxt);
1303         strcat(resultText,",");
1304
1305 //      ltoa ((int)nZ,zTzxt,10);
1306         sprintf(zTzxt,"%d",nZ);
1307
1308         strcat(resultText,zTzxt);
1309         strcat(resultText,")");
1310
1311
1312
1313
1314         _vtkText_position               -> SetInput(resultText);
1315 }
1316
1317 //-------------------------------------------------------------------
1318
1319 void vtkInfoTextImage::PutPixelIntensity(int xx, int yy, int zz)
1320 {
1321
1322 //EEDx2
1323         bool ok=true;
1324
1325         int dim[3];
1326         double spa[3];
1327         vtkImageData *imagedata = _marimagedata->GetImageData();
1328         imagedata->GetDimensions(dim);
1329         imagedata->GetSpacing(spa);
1330
1331 // EEDx7
1332 //      xx=xx*(1/spa[0]);
1333 //      yy=yy*(1/spa[1]);
1334 //      zz=xx*spa[2];
1335
1336         if ( (xx<0) || (xx>=dim[0]) || (yy<0) || (yy>=dim[1]) || (zz<0) || (zz>=dim[2]) )
1337         {
1338                 ok=false;
1339         }
1340
1341
1342         char zTzxt[20];
1343         char resultText[50];
1344         strcpy(resultText,"NG: ");
1345         if (ok==true) {
1346                 unsigned short *pOrg=(unsigned short*)imagedata->GetScalarPointer ((int)xx,(int)yy,(int)zz);
1347 //              itoa (*pOrg,zTzxt,10);
1348                 int tmp=*pOrg;
1349                 sprintf(zTzxt,"%d",tmp);
1350
1351         } else {
1352                 strcpy(zTzxt,"---");
1353         }
1354         strcat(resultText,zTzxt);
1355         _vtkText_pixelIntensity -> SetInput(resultText);
1356 }
1357
1358
1359
1360 //-------------------------------------------------------------------
1361 //-------------------------------------------------------------------
1362 //-------------------------------------------------------------------
1363
1364 vtkInfoTextImageInteractor::vtkInfoTextImageInteractor()
1365 {
1366 }
1367
1368 //-------------------------------------------------------------------
1369 vtkInfoTextImageInteractor::~vtkInfoTextImageInteractor()
1370 {
1371 }
1372
1373 //-------------------------------------------------------------------
1374
1375 void vtkInfoTextImageInteractor::SetModelVtkInfoTextImage(vtkInfoTextImage *vtkinfotextimage)
1376 {
1377         _vtkinfotextimage       = vtkinfotextimage;
1378 }
1379
1380 //-------------------------------------------------------------------
1381 bool vtkInfoTextImageInteractor::OnMouseMove()
1382 {
1383         int X,Y;
1384         wxVTKRenderWindowInteractor *wxVTKiren;
1385         wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
1386         wxVTKiren->GetEventPosition(X,Y);
1387
1388         int z = (int)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetVtkBaseData()->GetZ());
1389         double xx=X,yy=Y,zz=z;
1390         _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->TransfromeCoordScreenToWorld(xx,yy,zz);
1391
1392         GetVtkInfoTextImage()->PutWindowLevel();
1393         GetVtkInfoTextImage()->PutColorLevel();
1394         GetVtkInfoTextImage()->PutPosition( (int)xx , (int)yy , (int)zz );
1395         GetVtkInfoTextImage()->PutPixelIntensity( (int)xx , (int)yy , (int)zz );
1396
1397         this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
1398         return true;
1399 }
1400
1401 //-------------------------------------------------------------------
1402 vtkInfoTextImage *vtkInfoTextImageInteractor::GetVtkInfoTextImage()
1403 {
1404         return _vtkinfotextimage;
1405 }
1406
1407
1408 //-------------------------------------------------------------------
1409 //-------------------------------------------------------------------
1410 //-------------------------------------------------------------------
1411
1412
1413 wxVtk2DBaseView::wxVtk2DBaseView(wxWindow *parent)
1414 :wxVtkBaseView(parent)
1415 {
1416         _imageViewer2XYZ        = NULL;
1417         _vtkIinfoTextImage      = NULL;
1418 }
1419
1420 //-------------------------------------------------------------------
1421 wxVtk2DBaseView::~wxVtk2DBaseView()
1422 {
1423         if (_imageViewer2XYZ!=NULL) {
1424                 delete _imageViewer2XYZ;
1425         }
1426
1427         if (_imageViewer2XYZ!=NULL) {
1428                 delete _vtkIinfoTextImage;
1429         }
1430
1431 }
1432
1433 //-------------------------------------------------------------------
1434 void wxVtk2DBaseView::TransformCoordinate_spacing_ViewToModel(double &X,double &Y, double &Z) //        virtual
1435 {
1436 //EEDx5
1437         double spc[3];
1438 //      GetVtkBaseData()->GetImageData()->GetSpacing(spc);
1439         this->_imageViewer2XYZ->GetVtkImageViewer2()->GetInput()->GetSpacing(spc);
1440
1441         X = X / spc[0];
1442         Y = Y / spc[1];
1443         Z = Z / spc[2];
1444
1445 }
1446
1447 //-------------------------------------------------------------------
1448 void wxVtk2DBaseView::TransformCoordinate_spacing_ModelToView(double &X,double &Y, double &Z) //        virtual
1449 {
1450 //EEDx5
1451         double spc[3];
1452 //      GetVtkBaseData()->GetImageData()->GetSpacing(spc);
1453         this->_imageViewer2XYZ->GetVtkImageViewer2()->GetInput()->GetSpacing(spc);
1454
1455         X=X*spc[0];
1456         Y=Y*spc[1];
1457         Z=Z*spc[2];
1458
1459 }
1460
1461 //-------------------------------------------------------------------
1462 void wxVtk2DBaseView::ResetView()
1463 {
1464         double spx,spy,spz;
1465         int x1,x2,y1,y2,z1,z2;
1466         wxVtkBaseView::Configure();
1467
1468         wxVTKRenderWindowInteractor *iren = GetWxVTKRenderWindowInteractor();
1469         vtkImageData *imageData = GetVtkBaseData()->GetImageData();
1470         imageData->UpdateInformation();
1471         imageData->SetUpdateExtent( imageData->GetWholeExtent());
1472         imageData->Update();
1473
1474         _imageViewer2XYZ->GetVtkImageViewer2()->SetInput(imageData );
1475         imageData->GetSpacing (spx,spy,spz);
1476         imageData->GetExtent (x1,x2,y1,y2,z1,z2);
1477         _imageViewer2XYZ -> SetExtentDimension(x1,x2,y1,y2,z1,z2);
1478         _imageViewer2XYZ -> GetVtkImageViewer2()->SetupInteractor ( iren );
1479
1480 printf("EED wxVtk2DBaseView::ResetView podemos 01\n ");
1481         _imageViewer2XYZ->GetVtkImageViewer2()->Render();
1482 printf("EED wxVtk2DBaseView::ResetView podemos 02\n ");
1483
1484         SetInteractorStyleImage( vtkInteractorStyleBaseView2D::New() );
1485
1486 }
1487
1488
1489 //-------------------------------------------------------------------
1490 void wxVtk2DBaseView::Configure(bool okimage)
1491 {
1492         double spx,spy,spz;
1493         int x1,x2,y1,y2,z1,z2;
1494         wxVtkBaseView::Configure();
1495
1496 // EED 17 Oct 2007
1497                         if (_imageViewer2XYZ==NULL)
1498                         {
1499                                 _imageViewer2XYZ = new vtkImageViewer2_XYZ();
1500                                 wxVTKRenderWindowInteractor *iren = GetWxVTKRenderWindowInteractor();
1501                                 _imageViewer2XYZ -> GetVtkImageViewer2()->SetupInteractor ( iren );
1502                                 SetInteractorStyleImage( vtkInteractorStyleBaseView2D::New() );
1503                         }
1504
1505
1506         vtkImageData *imageData = GetVtkBaseData()->GetMarImageData()->GetImageData();
1507         if (imageData!=NULL){
1508                 imageData->UpdateInformation();
1509                 imageData->SetUpdateExtent( imageData->GetWholeExtent());
1510                 imageData->Update();
1511                 if (okimage==true){
1512                         imageData->GetSpacing (spx,spy,spz);
1513                         imageData->GetExtent (x1,x2,y1,y2,z1,z2);
1514
1515
1516                         _imageViewer2XYZ->GetVtkImageViewer2()->SetInput(imageData );
1517                         _imageViewer2XYZ->SetExtentDimension(x1,x2,y1,y2,z1,z2);
1518                         double range[2];
1519                           imageData->GetScalarRange(range);
1520                           if (range[1]<20000){
1521                                  _imageViewer2XYZ->GetVtkImageViewer2()->SetColorWindow( (range[1]-range[0])/2 );
1522                                  _imageViewer2XYZ->GetVtkImageViewer2()->SetColorLevel( (range[1]+range[0])/4 );
1523                           } else {
1524                                  _imageViewer2XYZ->GetVtkImageViewer2()->SetColorWindow( 1000 );
1525                                  _imageViewer2XYZ->GetVtkImageViewer2()->SetColorLevel( 500 );
1526                           }
1527 // EED 31 Janvier 2007
1528 //vtkImageActor *vtkimageactor = _imageViewer2XYZ->GetVtkImageViewer2()->GetImageActor ();
1529 //vtkimageactor->InterpolateOff ();
1530 //vtkLookupTable * _collookup = vtkLookupTable::New( );
1531 //_collookup->SetNumberOfColors( 256 );
1532 //_collookup->SetTableRange( 0 , 255 );
1533 //_collookup->Build( );
1534 //_collookup->SetTableValue( 0  , 1 , 0 , 0 , 1 );
1535 //_collookup->SetTableValue(128 , 0 , 0 , 1 , 1 );
1536 //_collookup->SetTableValue(255 , 0 , 1 , 0 , 1 );
1537 //_imageViewer2XYZ->GetVtkImageViewer2()->GetWindowLevel ()->SetLookupTable(_collookup );
1538
1539
1540 // EED 17 Oct 2007
1541 //                      SetInteractorStyleImage( vtkInteractorStyleBaseView2D::New() );
1542
1543
1544                         vtkImageViewer2 *IV2=_imageViewer2XYZ->GetVtkImageViewer2();
1545                         vtkCamera *camera = IV2->GetRenderer()->GetActiveCamera();
1546                         camera->SetViewUp               ( spx*0                 , -spy*1                        , spz*0         );
1547                         camera->SetPosition             ( spx*(x1+x2)/2 , spy*(y1+y2)/2 , -spz*10000    );
1548                         camera->SetFocalPoint   ( spx*(x1+x2)/2 , spy*(y1+y2)/2 , spz*0         );
1549                         camera->SetClippingRange( 0.01                  , 1000000 );
1550                         camera->ComputeViewPlaneNormal();
1551                         camera->SetParallelScale( spx*(x2-x1)/3.0 );
1552
1553                         // text information over the graphic window
1554                         _vtkIinfoTextImage                              = new vtkInfoTextImage();
1555                         _vtkIinfoTextImageInteractor    = new vtkInfoTextImageInteractor();
1556                         _vtkIinfoTextImage->SetWxVtk2DBaseView(this);
1557                         _vtkIinfoTextImage->SetMarImageData( GetVtkBaseData()->GetMarImageData() );
1558                         _vtkIinfoTextImageInteractor->SetModelVtkInfoTextImage(_vtkIinfoTextImage);
1559                         _vtkIinfoTextImage->Configure();
1560                         this->GetInteractorStyleBaseView()->AddInteractorStyleMaracas(_vtkIinfoTextImageInteractor);
1561                 } // okimage
1562         } // imageData
1563
1564 }
1565
1566 //-------------------------------------------------------------------
1567
1568 int     wxVtk2DBaseView::GetActualSlice()  // virtual
1569 {
1570         return (int)(_vtkbasedata->GetZ());
1571 }
1572
1573 //-------------------------------------------------------------------
1574 void wxVtk2DBaseView::SetActualSlice(int slice)  // Virtual
1575 {
1576         _vtkbasedata->SetZ(slice);
1577 }
1578
1579 //-------------------------------------------------------------------
1580
1581 vtkBaseData *wxVtk2DBaseView::GetVtkBaseData()
1582 {
1583         return _vtkbasedata;
1584 }
1585
1586 //-------------------------------------------------------------------
1587
1588 void wxVtk2DBaseView::SetVtkBaseData(vtkBaseData *vtkbasedata)
1589 {
1590         _vtkbasedata=vtkbasedata;
1591 }
1592
1593 //-------------------------------------------------------------------
1594
1595 void wxVtk2DBaseView::Refresh()
1596 {
1597         int z = (int)(GetVtkBaseData()->GetZ());
1598         _imageViewer2XYZ->SetZSlice( z );
1599
1600         wxVtkBaseView::Refresh();
1601 }
1602
1603 //-------------------------------------------------------------------
1604
1605 void wxVtk2DBaseView::SetInteractorStyleImage(vtkInteractorStyleBaseView *interactorstylebaseview)
1606 {
1607         SetInteractorStyleBaseView(interactorstylebaseview);
1608
1609         wxVTKRenderWindowInteractor *iren = GetWxVTKRenderWindowInteractor();
1610         interactorstylebaseview->SetInteractor ( iren );
1611         iren->SetInteractorStyle(interactorstylebaseview);
1612         interactorstylebaseview->SetwxVtkBaseView(this);
1613
1614         vtkMaracasImageViewer2Callback *cbk = vtkMaracasImageViewer2Callback::New();
1615         cbk->IV = _imageViewer2XYZ->GetVtkImageViewer2();
1616         interactorstylebaseview->AddObserver( vtkCommand::WindowLevelEvent, cbk );
1617         interactorstylebaseview->AddObserver( vtkCommand::StartWindowLevelEvent, cbk );
1618         interactorstylebaseview->AddObserver( vtkCommand::ResetWindowLevelEvent, cbk );
1619         cbk->Delete();
1620 }
1621
1622 //---------------------------------------------------------------------------
1623 vtkRenderer* wxVtk2DBaseView::GetRenderer()     // virtual
1624 {
1625         return  _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer();
1626 }
1627 //---------------------------------------------------------------------------
1628 vtkRenderWindow* wxVtk2DBaseView::GetRenWin()           // virtual
1629 {
1630         return  _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderWindow();
1631 }
1632
1633 //-------------------------------------------------------------------
1634
1635 void wxVtk2DBaseView::GetSpacing(double spc[3])  // virtual
1636 {
1637         vtkImageData *imageData = GetVtkBaseData()->GetImageData();
1638         imageData->GetSpacing(spc);
1639 }
1640
1641 //-------------------------------------------------------------------
1642 //-------------------------------------------------------------------
1643 //-------------------------------------------------------------------
1644
1645
1646
1647
1648 wxVtk3DBaseView::wxVtk3DBaseView(wxWindow *parent)
1649 :wxVtkBaseView( parent )
1650 {
1651         _configure      = false;
1652         _aRenderer      = NULL;
1653         _renWin         = NULL;
1654         _aCamera        = NULL;
1655 }
1656 //-------------------------------------------------------------------
1657 wxVtk3DBaseView::~wxVtk3DBaseView()
1658 {
1659         if (_aCamera!=NULL)             { _aCamera              -> Delete(); }
1660         if (_aRenderer!=NULL)   { _aRenderer    -> Delete(); }
1661         if (_renWin!=NULL)              { _renWin               -> Delete(); }
1662 }
1663 //-------------------------------------------------------------------
1664 vtkCamera* wxVtk3DBaseView::GetCamera()
1665 {
1666         return _aCamera;
1667 }
1668 //-------------------------------------------------------------------
1669 vtkRenderer* wxVtk3DBaseView::GetRenderer()  // virtual
1670 {
1671         return _aRenderer;
1672 }
1673 //-------------------------------------------------------------------
1674 vtkRenderWindow* wxVtk3DBaseView::GetRenWin()  // virtual
1675 {
1676         return _renWin;
1677 }
1678 //-------------------------------------------------------------------
1679 void wxVtk3DBaseView::Refresh()
1680 {
1681 //      _renWin->Render();
1682         vtkRenderWindowInteractor *vri = GetWxVTKRenderWindowInteractor();
1683         vri->vtkRenderWindowInteractor::Render();
1684 }
1685 //-------------------------------------------------------------------
1686 void wxVtk3DBaseView::Configure()
1687 {
1688         if (_configure==false)
1689         {
1690                 _configure=true;
1691                 wxVtkBaseView::Configure();
1692                 _aRenderer      = vtkRenderer::New();
1693                 _renWin         = vtkRenderWindow::New();
1694                 _renWin->AddRenderer(_aRenderer);
1695
1696
1697 //       _renWin->SetStereoCapableWindow(1);
1698 // //      //renderwindow->SetStereoTypeToCrystalEyes();
1699 //       _renWin->SetStereoTypeToRedBlue();
1700 //       _renWin->SetStereoRender(1);
1701
1702                 GetWxVTKRenderWindowInteractor()->SetRenderWindow(_renWin);
1703
1704
1705 // EED Borrame
1706 //              vtkInteractorStyle3DMaracas *interactorStyle3DMaracas = vtkInteractorStyle3DMaracas::New();
1707                 vtkInteractorStyleBaseView3D *interactorStyleBaseView3D = vtkInteractorStyleBaseView3D::New();
1708
1709                 SetInteractorStyleBaseView( interactorStyleBaseView3D );
1710                 interactorStyleBaseView3D->SetInteractor (  GetWxVTKRenderWindowInteractor() );
1711                 GetWxVTKRenderWindowInteractor()->SetInteractorStyle( interactorStyleBaseView3D );
1712                 interactorStyleBaseView3D->SetwxVtkBaseView(this);
1713
1714
1715 /* EED Borrame
1716   vtkInteractorStyleSwitch *iss = dynamic_cast<vtkInteractorStyleSwitch*>(_iren->GetInteractorStyle());
1717   iss->SetCurrentStyleToTrackballCamera();
1718 */
1719
1720                 // It is convenient to create an initial view of the data. The
1721                 // FocalPoint and Position form a vector direction. Later on
1722                 // (ResetCamera() method) this vector is used to position the camera
1723                 // to look at the data in this direction.
1724                 _aCamera = vtkCamera::New();
1725                 _aCamera->SetViewUp (0, 0, -1);
1726                 _aCamera->SetPosition (0, 1, 0);
1727                 _aCamera->SetFocalPoint (0, 0, 0);
1728                 _aCamera->ComputeViewPlaneNormal();
1729         }
1730 }
1731 //-------------------------------------------------------------------
1732 //EED 27 sep 2006
1733 void wxVtk3DBaseView::GetSpacing(double spc[3])
1734 {
1735         spc[0]=1;
1736         spc[1]=1;
1737         spc[2]=1;
1738 }