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