packages/wxvtk/src/wxvtkImageViewer2.cxx

   1 /*=========================================================================
   2
   3   Program:   Visualization Toolkit
   4   Module:    $RCSfile: wxvtkImageViewer2.cxx,v $
   5
   6   Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
   7   All rights reserved.
   8   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
   9
  10      This software is distributed WITHOUT ANY WARRANTY; without even
  11      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  12      PURPOSE.  See the above copyright notice for more information.
  13
  14 =========================================================================*/
  15 #include "wxvtkImageViewer2.h"
  16
  17 #include "vtkCamera.h"
  18 #include "vtkCommand.h"
  19 #include "vtkImageActor.h"
  20 #include "vtkImageData.h"
  21 #include "vtkImageData.h"
  22 #include "vtkImageMapToWindowLevelColors.h"
  23 #include "vtkInteractorStyleImage.h"
  24 #include "vtkObjectFactory.h"
  25 #include "vtkRenderWindow.h"
  26 #include "vtkRenderWindowInteractor.h"
  27 #include "vtkRenderer.h"
  28
  29 vtkCxxRevisionMacro(wxvtkImageViewer2, "$Revision: 1.7 $");
  30 vtkStandardNewMacro(wxvtkImageViewer2);
  31
  32 //----------------------------------------------------------------------------
  33 wxvtkImageViewer2::wxvtkImageViewer2()
  34 {
  35   this->RenderWindow    = NULL;
  36   this->Renderer        = NULL;
  37   this->ImageActor      = vtkImageActor::New();
  38   this->WindowLevel     = vtkImageMapToWindowLevelColors::New();
  39   this->Interactor      = NULL;
  40   this->InteractorStyle = NULL;
  41
  42   this->Slice = 0;
  43   this->FirstRender = 1;
  44   this->SliceOrientation = wxvtkImageViewer2::SLICE_ORIENTATION_XY;
  45
  46   // Setup the pipeline
  47
  48   vtkRenderWindow *renwin = vtkRenderWindow::New();
  49   this->SetRenderWindow(renwin);
  50   renwin->Delete();
  51
  52   vtkRenderer *ren = vtkRenderer::New();
  53   this->SetRenderer(ren);
  54   ren->Delete();
  55
  56   this->InstallPipeline();
  57 }
  58
  59 //----------------------------------------------------------------------------
  60 wxvtkImageViewer2::~wxvtkImageViewer2()
  61 {
  62   if (this->WindowLevel)
  63     {
  64     this->WindowLevel->Delete();
  65     this->WindowLevel = NULL;
  66     }
  67
  68   if (this->ImageActor)
  69     {
  70     this->ImageActor->Delete();
  71     this->ImageActor = NULL;
  72     }
  73
  74   if (this->Renderer)
  75     {
  76     this->Renderer->Delete();
  77     this->Renderer = NULL;
  78     }
  79
  80   if (this->RenderWindow)
  81     {
  82     this->RenderWindow->Delete();
  83     this->RenderWindow = NULL;
  84     }
  85
  86   if (this->Interactor)
  87     {
  88     this->Interactor->Delete();
  89     this->Interactor = NULL;
  90     }
  91
  92   if (this->InteractorStyle)
  93     {
  94     this->InteractorStyle->Delete();
  95     this->InteractorStyle = NULL;
  96     }
  97 }
  98
  99 //----------------------------------------------------------------------------
 100 void wxvtkImageViewer2::SetupInteractor(vtkRenderWindowInteractor *arg)
 101 {
 102   if (this->Interactor == arg)
 103     {
 104     return;
 105     }
 106
 107   this->UnInstallPipeline();
 108
 109   if (this->Interactor)
 110     {
 111     this->Interactor->UnRegister(this);
 112     }
 113
 114   this->Interactor = arg;
 115
 116   if (this->Interactor)
 117     {
 118     this->Interactor->Register(this);
 119     }
 120
 121   this->InstallPipeline();
 122
 123   if (this->Renderer)
 124     {
 125     this->Renderer->GetActiveCamera()->ParallelProjectionOn();
 126     }
 127 }
 128
 129 //----------------------------------------------------------------------------
 130 void wxvtkImageViewer2::SetRenderWindow(vtkRenderWindow *arg)
 131 {
 132   if (this->RenderWindow == arg)
 133     {
 134     return;
 135     }
 136
 137   this->UnInstallPipeline();
 138
 139   if (this->RenderWindow)
 140     {
 141     this->RenderWindow->UnRegister(this);
 142     }
 143
 144   this->RenderWindow = arg;
 145
 146   if (this->RenderWindow)
 147     {
 148     this->RenderWindow->Register(this);
 149     }
 150
 151   this->InstallPipeline();
 152 }
 153
 154 //----------------------------------------------------------------------------
 155 void wxvtkImageViewer2::SetRenderer(vtkRenderer *arg)
 156 {
 157   if (this->Renderer == arg)
 158     {
 159     return;
 160     }
 161
 162   this->UnInstallPipeline();
 163
 164   if (this->Renderer)
 165     {
 166     this->Renderer->UnRegister(this);
 167     }
 168
 169   this->Renderer = arg;
 170
 171   if (this->Renderer)
 172     {
 173     this->Renderer->Register(this);
 174     }
 175
 176   this->InstallPipeline();
 177   this->UpdateOrientation();
 178 }
 179
 180 //----------------------------------------------------------------------------
 181 void wxvtkImageViewer2::SetSize(int a,int b)
 182 {
 183   this->RenderWindow->SetSize(a, b);
 184 }
 185
 186 //----------------------------------------------------------------------------
 187 int* wxvtkImageViewer2::GetSize()
 188 {
 189   return this->RenderWindow->GetSize();
 190 }
 191
 192 //----------------------------------------------------------------------------
 193 void wxvtkImageViewer2::GetSliceRange(int &min, int &max)
 194 {
 195   vtkImageData *input = this->GetInput();
 196   if (input)
 197     {
 198     input->UpdateInformation();
 199     int *w_ext = input->GetWholeExtent();
 200     min = w_ext[this->SliceOrientation * 2];
 201     max = w_ext[this->SliceOrientation * 2 + 1];
 202     }
 203 }
 204
 205 //----------------------------------------------------------------------------
 206 int* wxvtkImageViewer2::GetSliceRange()
 207 {
 208   vtkImageData *input = this->GetInput();
 209   if (input)
 210     {
 211     input->UpdateInformation();
 212     return input->GetWholeExtent() + this->SliceOrientation * 2;
 213     }
 214   return NULL;
 215 }
 216
 217 //----------------------------------------------------------------------------
 218 int wxvtkImageViewer2::GetSliceMin()
 219 {
 220   int *range = this->GetSliceRange();
 221   if (range)
 222     {
 223     return range[0];
 224     }
 225   return 0;
 226 }
 227
 228 //----------------------------------------------------------------------------
 229 int wxvtkImageViewer2::GetSliceMax()
 230 {
 231   int *range = this->GetSliceRange();
 232   if (range)
 233     {
 234     return range[1];
 235     }
 236   return 0;
 237 }
 238
 239 //----------------------------------------------------------------------------
 240 void wxvtkImageViewer2::SetSlice(int slice)
 241 {
 242   int *range = this->GetSliceRange();
 243   if (range)
 244     {
 245     if (slice < range[0])
 246       {
 247       slice = range[0];
 248       }
 249     else if (slice > range[1])
 250       {
 251       slice = range[1];
 252       }
 253     }
 254
 255   if (this->Slice == slice)
 256     {
 257     return;
 258     }
 259
 260   this->Slice = slice;
 261   this->Modified();
 262
 263   this->UpdateDisplayExtent();
 264   this->Render();
 265 }
 266
 267 //----------------------------------------------------------------------------
 268 void wxvtkImageViewer2::SetSliceOrientation(int orientation)
 269 {
 270   if (orientation < wxvtkImageViewer2::SLICE_ORIENTATION_YZ ||
 271       orientation > wxvtkImageViewer2::SLICE_ORIENTATION_XY)
 272     {
 273     vtkErrorMacro("Error - invalid slice orientation " << orientation);
 274     return;
 275     }
 276
 277   if (this->SliceOrientation == orientation)
 278     {
 279     return;
 280     }
 281
 282   this->SliceOrientation = orientation;
 283
 284   // Update the viewer
 285
 286   int *range = this->GetSliceRange();
 287   if (range)
 288     {
 289     this->Slice = static_cast<int>((range[0] + range[1]) * 0.5);
 290     }
 291
 292   this->UpdateOrientation();
 293   this->UpdateDisplayExtent();
 294
 295   if (this->Renderer && this->GetInput())
 296     {
 297     double scale = this->Renderer->GetActiveCamera()->GetParallelScale();
 298     this->Renderer->ResetCamera();
 299     this->Renderer->GetActiveCamera()->SetParallelScale(scale);
 300     }
 301
 302   this->Render();
 303 }
 304
 305 //----------------------------------------------------------------------------
 306 void wxvtkImageViewer2::UpdateOrientation()
 307 {
 308   // Set the camera position
 309
 310   vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
 311   if (cam)
 312     {
 313
 314 // EED 21 mars FLIP problem  ..PLOP..
 315     switch (this->SliceOrientation)
 316         {
 317                 case wxvtkImageViewer2::SLICE_ORIENTATION_YZ:
 318                           cam->SetViewUp(0,0,1);
 319                           cam->SetPosition(1,0,0); // -1 if medical ?
 320                           cam->SetFocalPoint(0,0,0);
 321                         break;
 322
 323                 case wxvtkImageViewer2::SLICE_ORIENTATION_XZ:
 324                         cam->SetViewUp(0,0,1);
 325                         cam->SetPosition(0,-1,0); // 1 if medical ?
 326                         cam->SetFocalPoint(0,0,0);
 327                         break;
 328
 329                 case wxvtkImageViewer2::SLICE_ORIENTATION_XY:
 330                           cam->SetViewUp(0,-1,0);
 331                           cam->SetPosition(0,0,-1);
 332                           cam->SetFocalPoint(0,0,0);
 333                         break;
 334       }
 335
 336 /*
 337                 switch (this->SliceOrientation)
 338                 {
 339                         case wxvtkImageViewer2::SLICE_ORIENTATION_YZ:
 340                                 cam->SetViewUp(0,0,1);
 341                                 cam->SetPosition(1,0,0); // -1 if medical ?
 342                                 cam->SetFocalPoint(0,0,0);
 343                                 break;
 344
 345                         case wxvtkImageViewer2::SLICE_ORIENTATION_XZ:
 346                                 cam->SetViewUp(0,0,1);
 347                                 cam->SetPosition(0,-1,0); // 1 if medical ?
 348                                 cam->SetFocalPoint(0,0,0);
 349                                 break;
 350
 351                         case wxvtkImageViewer2::SLICE_ORIENTATION_XY:
 352                                 cam->SetViewUp(0,1,0);
 353                                 cam->SetPosition(0,0,1); // -1 if medical ?
 354                                 cam->SetFocalPoint(0,0,0);
 355                                 break;
 356
 357
 358                 }
 359 */
 360
 361     }
 362 }
 363
 364 //----------------------------------------------------------------------------
 365 void wxvtkImageViewer2::UpdateDisplayExtent()
 366 {
 367   vtkImageData *input = this->GetInput();
 368   if (!input || !this->ImageActor)
 369     {
 370     return;
 371     }
 372
 373   //  std::cout << "--- wxvtkImageViewer2::UpdateDisplayExtent()"<<std::endl;
 374   input->UpdateInformation();
 375   int *w_ext = input->GetWholeExtent();
 376
 377   //    std::cout << "ext = "
 378   //    <<w_ext[0]<<" - "<<w_ext[1]<<" ; "
 379   //            <<w_ext[2]<<" - "<<w_ext[3]<<" ; "
 380   //            <<w_ext[4]<<" - "<<w_ext[5]
 381   //            <<std::endl;
 382       // Is the slice in range ? If not, fix it
 383
 384   int slice_min = w_ext[this->SliceOrientation * 2];
 385   int slice_max = w_ext[this->SliceOrientation * 2 + 1];
 386   if (this->Slice < slice_min || this->Slice > slice_max)
 387     {
 388     this->Slice = static_cast<int>((slice_min + slice_max) * 0.5);
 389     }
 390
 391   // Set the image actor
 392
 393   switch (this->SliceOrientation)
 394     {
 395     case wxvtkImageViewer2::SLICE_ORIENTATION_XY:
 396       this->ImageActor->SetDisplayExtent(
 397         w_ext[0], w_ext[1], w_ext[2], w_ext[3], this->Slice, this->Slice);
 398       break;
 399
 400     case wxvtkImageViewer2::SLICE_ORIENTATION_XZ:
 401       this->ImageActor->SetDisplayExtent(
 402         w_ext[0], w_ext[1], this->Slice, this->Slice, w_ext[4], w_ext[5]);
 403       break;
 404
 405     case wxvtkImageViewer2::SLICE_ORIENTATION_YZ:
 406       this->ImageActor->SetDisplayExtent(
 407         this->Slice, this->Slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5]);
 408       break;
 409     }
 410
 411   // Figure out the correct clipping range
 412
 413   if (this->Renderer)
 414     {
 415     if (this->InteractorStyle &&
 416         this->InteractorStyle->GetAutoAdjustCameraClippingRange())
 417       {
 418       this->Renderer->ResetCameraClippingRange();
 419       }
 420     else
 421       {
 422       vtkCamera *cam = this->Renderer->GetActiveCamera();
 423       if (cam)
 424         {
 425         double bounds[6];
 426         this->ImageActor->GetBounds(bounds);
 427         double spos = bounds[this->SliceOrientation * 2];
 428         double cpos = cam->GetPosition()[this->SliceOrientation];
 429         double range = fabs(spos - cpos);
 430         double *spacing = input->GetSpacing();
 431         double avg_spacing =
 432           //(spacing[0] + spacing[1] + spacing[2]) / 3.0;
 433           spacing[2]; // JPR??
 434         cam->SetClippingRange(
 435           range - avg_spacing * 3.0, range + avg_spacing * 3.0);
 436         }
 437       }
 438     }
 439 }
 440
 441 //----------------------------------------------------------------------------
 442 void wxvtkImageViewer2::SetPosition(int a,int b)
 443 {
 444   this->RenderWindow->SetPosition(a, b);
 445 }
 446
 447 //----------------------------------------------------------------------------
 448 int* wxvtkImageViewer2::GetPosition()
 449 {
 450   return this->RenderWindow->GetPosition();
 451 }
 452
 453 //----------------------------------------------------------------------------
 454 void wxvtkImageViewer2::SetDisplayId(void *a)
 455 {
 456   this->RenderWindow->SetDisplayId(a);
 457 }
 458
 459 //----------------------------------------------------------------------------
 460 void wxvtkImageViewer2::SetWindowId(void *a)
 461 {
 462   this->RenderWindow->SetWindowId(a);
 463 }
 464
 465 //----------------------------------------------------------------------------
 466 void wxvtkImageViewer2::SetParentId(void *a)
 467 {
 468   this->RenderWindow->SetParentId(a);
 469 }
 470
 471 //----------------------------------------------------------------------------
 472 double wxvtkImageViewer2::GetColorWindow()
 473 {
 474   return this->WindowLevel->GetWindow();
 475 }
 476
 477 //----------------------------------------------------------------------------
 478 double wxvtkImageViewer2::GetColorLevel()
 479 {
 480   return this->WindowLevel->GetLevel();
 481 }
 482
 483 //----------------------------------------------------------------------------
 484 void wxvtkImageViewer2::SetColorWindow(double s)
 485 {
 486   this->WindowLevel->SetWindow(s);
 487 }
 488
 489 //----------------------------------------------------------------------------
 490 void wxvtkImageViewer2::SetColorLevel(double s)
 491 {
 492   this->WindowLevel->SetLevel(s);
 493 }
 494
 495 //----------------------------------------------------------------------------
 496 class wxvtkImageViewer2Callback : public vtkCommand
 497 {
 498 public:
 499   static wxvtkImageViewer2Callback *New() { return new wxvtkImageViewer2Callback; }
 500
 501   void Execute(vtkObject *caller,
 502                unsigned long event,
 503                void *vtkNotUsed(callData))
 504     {
 505       if (this->IV->GetInput() == NULL)
 506         {
 507         return;
 508         }
 509
 510       // Reset
 511
 512       if (event == vtkCommand::ResetWindowLevelEvent)
 513         {
 514         this->IV->GetInput()->UpdateInformation();
 515         this->IV->GetInput()->SetUpdateExtent
 516           (this->IV->GetInput()->GetWholeExtent());
 517         this->IV->GetInput()->Update();
 518         double *range = this->IV->GetInput()->GetScalarRange();
 519         this->IV->SetColorWindow(range[1] - range[0]);
 520         this->IV->SetColorLevel(0.5 * (range[1] + range[0]));
 521         this->IV->Render();
 522         return;
 523         }
 524
 525       // Start
 526
 527       if (event == vtkCommand::StartWindowLevelEvent)
 528         {
 529         this->InitialWindow = this->IV->GetColorWindow();
 530         this->InitialLevel = this->IV->GetColorLevel();
 531         return;
 532         }
 533
 534       // Adjust the window level here
 535
 536       vtkInteractorStyleImage *isi =
 537         static_cast<vtkInteractorStyleImage *>(caller);
 538
 539       int *size = this->IV->GetRenderWindow()->GetSize();
 540       double window = this->InitialWindow;
 541       double level = this->InitialLevel;
 542
 543       // Compute normalized delta
 544
 545       double dx = 4.0 *
 546         (isi->GetWindowLevelCurrentPosition()[0] -
 547          isi->GetWindowLevelStartPosition()[0]) / size[0];
 548       double dy = 4.0 *
 549         (isi->GetWindowLevelStartPosition()[1] -
 550          isi->GetWindowLevelCurrentPosition()[1]) / size[1];
 551
 552       // Scale by current values
 553
 554       if (fabs(window) > 0.01)
 555         {
 556         dx = dx * window;
 557         }
 558       else
 559         {
 560         dx = dx * (window < 0 ? -0.01 : 0.01);
 561         }
 562       if (fabs(level) > 0.01)
 563         {
 564         dy = dy * level;
 565         }
 566       else
 567         {
 568         dy = dy * (level < 0 ? -0.01 : 0.01);
 569         }
 570
 571       // Abs so that direction does not flip
 572
 573       if (window < 0.0)
 574         {
 575         dx = -1*dx;
 576         }
 577       if (level < 0.0)
 578         {
 579         dy = -1*dy;
 580         }
 581
 582       // Compute new window level
 583
 584       double newWindow = dx + window;
 585       double newLevel;
 586       newLevel = level - dy;
 587
 588       // Stay away from zero and really
 589
 590       if (fabs(newWindow) < 0.01)
 591         {
 592         newWindow = 0.01*(newWindow < 0 ? -1 : 1);
 593         }
 594       if (fabs(newLevel) < 0.01)
 595         {
 596         newLevel = 0.01*(newLevel < 0 ? -1 : 1);
 597         }
 598
 599       this->IV->SetColorWindow(newWindow);
 600       this->IV->SetColorLevel(newLevel);
 601       this->IV->Render();
 602     }
 603
 604   wxvtkImageViewer2 *IV;
 605   double InitialWindow;
 606   double InitialLevel;
 607 };
 608
 609 //----------------------------------------------------------------------------
 610 void wxvtkImageViewer2::InstallPipeline()
 611 {
 612   if (this->RenderWindow && this->Renderer)
 613     {
 614     this->RenderWindow->AddRenderer(this->Renderer);
 615     }
 616
 617   if (this->Interactor)
 618     {
 619     if (!this->InteractorStyle)
 620       {
 621       this->InteractorStyle = vtkInteractorStyleImage::New();
 622       wxvtkImageViewer2Callback *cbk = wxvtkImageViewer2Callback::New();
 623       cbk->IV = this;
 624       this->InteractorStyle->AddObserver(
 625         vtkCommand::WindowLevelEvent, cbk);
 626       this->InteractorStyle->AddObserver(
 627         vtkCommand::StartWindowLevelEvent, cbk);
 628       this->InteractorStyle->AddObserver(
 629         vtkCommand::ResetWindowLevelEvent, cbk);
 630       cbk->Delete();
 631       }
 632
 633     this->Interactor->SetInteractorStyle(this->InteractorStyle);
 634     this->Interactor->SetRenderWindow(this->RenderWindow);
 635     }
 636
 637   if (this->Renderer && this->ImageActor)
 638     {
 639     this->Renderer->AddViewProp(this->ImageActor);
 640     }
 641
 642   if (this->ImageActor && this->WindowLevel)
 643     {
 644     this->ImageActor->SetInput(this->WindowLevel->GetOutput());
 645     }
 646 }
 647
 648 //----------------------------------------------------------------------------
 649 void wxvtkImageViewer2::UnInstallPipeline()
 650 {
 651   if (this->ImageActor)
 652     {
 653     this->ImageActor->SetInput(NULL);
 654     }
 655
 656   if (this->Renderer && this->ImageActor)
 657     {
 658     this->Renderer->RemoveViewProp(this->ImageActor);
 659     }
 660
 661   if (this->RenderWindow && this->Renderer)
 662     {
 663     this->RenderWindow->RemoveRenderer(this->Renderer);
 664     }
 665
 666   if (this->Interactor)
 667     {
 668     this->Interactor->SetInteractorStyle(NULL);
 669     this->Interactor->SetRenderWindow(NULL);
 670     }
 671 }
 672
 673 //----------------------------------------------------------------------------
 674 void wxvtkImageViewer2::Render()
 675 {
 676   if (this->FirstRender)
 677     {
 678     // Initialize the size if not set yet
 679
 680     vtkImageData *input = this->GetInput();
 681     if (this->RenderWindow->GetSize()[0] == 0 &&
 682         input)
 683       {
 684
 685       input->UpdateInformation();
 686       int *w_ext = input->GetWholeExtent();
 687       int xs = 0, ys = 0;
 688
 689       //        std::cout << "wxvtkImageViewer2::Render ext = "
 690       //        <<w_ext[0]<<" - "<<w_ext[1]<<" ; "
 691       //                <<w_ext[2]<<" - "<<w_ext[3]<<" ; "
 692       //                <<w_ext[4]<<" - "<<w_ext[5]
 693       //                <<std::endl;
 694
 695       switch (this->SliceOrientation)
 696         {
 697         case wxvtkImageViewer2::SLICE_ORIENTATION_XY:
 698         default:
 699           xs = w_ext[1] - w_ext[0] + 1;
 700           ys = w_ext[3] - w_ext[2] + 1;
 701           //      std::cout << "SLICE_ORIENTATION_XY" << std::endl;
 702           break;
 703
 704         case wxvtkImageViewer2::SLICE_ORIENTATION_XZ:
 705           xs = w_ext[1] - w_ext[0] + 1;
 706           ys = w_ext[5] - w_ext[4] + 1;
 707           //      std::cout << "SLICE_ORIENTATION_XZ" << std::endl;
 708           break;
 709
 710         case wxvtkImageViewer2::SLICE_ORIENTATION_YZ:
 711           xs = w_ext[3] - w_ext[2] + 1;
 712           ys = w_ext[5] - w_ext[4] + 1;
 713           //      std::cout << "SLICE_ORIENTATION_YZ" << std::endl;
 714           break;
 715         }
 716
 717       // if it would be smaller than 150 by 100 then limit to 150 by 100
 718       this->RenderWindow->SetSize(
 719         xs < 150 ? 150 : xs, ys < 100 ? 100 : ys);
 720
 721       //      std::cout << "wxvtkImageViewer2::Render() : "<<xs<<"-"<<ys<<std::endl;
 722       if (this->Renderer)
 723         {
 724         this->Renderer->ResetCamera();
 725         this->Renderer->GetActiveCamera()->SetParallelScale(
 726           xs < 150 ? 75 : (xs - 1 ) / 2.0);
 727         }
 728       this->FirstRender = 0;
 729
 730       }
 731     }
 732   if (this->GetInput())
 733     {
 734     this->RenderWindow->Render();
 735     }
 736 }
 737
 738 //----------------------------------------------------------------------------
 739 const char* wxvtkImageViewer2::GetWindowName()
 740 {
 741   return this->RenderWindow->GetWindowName();
 742 }
 743
 744 //----------------------------------------------------------------------------
 745 void wxvtkImageViewer2::SetOffScreenRendering(int i)
 746 {
 747   this->RenderWindow->SetOffScreenRendering(i);
 748 }
 749
 750 //----------------------------------------------------------------------------
 751 int wxvtkImageViewer2::GetOffScreenRendering()
 752 {
 753   return this->RenderWindow->GetOffScreenRendering();
 754 }
 755
 756 //----------------------------------------------------------------------------
 757 void wxvtkImageViewer2::SetInput(vtkImageData *in)
 758 {
 759   //  std::cout << "### wxvtkImageViewer2::SetInput"<<std::endl;
 760   this->WindowLevel->SetInput(in);
 761   this->UpdateDisplayExtent();
 762   // LG 03/12/08
 763   //  FirstRender = 1;
 764 }
 765 //----------------------------------------------------------------------------
 766 vtkImageData* wxvtkImageViewer2::GetInput()
 767 {
 768   return vtkImageData::SafeDownCast(this->WindowLevel->GetInput());
 769 }
 770
 771 //----------------------------------------------------------------------------
 772 void wxvtkImageViewer2::SetInputConnection(vtkAlgorithmOutput* input)
 773 {
 774   this->WindowLevel->SetInputConnection(input);
 775   this->UpdateDisplayExtent();
 776 }
 777
 778 //----------------------------------------------------------------------------
 779 #ifndef VTK_LEGACY_REMOVE
 780 int wxvtkImageViewer2::GetWholeZMin()
 781 {
 782   VTK_LEGACY_REPLACED_BODY(wxvtkImageViewer2::GetWholeZMin, "VTK 5.0",
 783                            wxvtkImageViewer2::GetSliceMin);
 784   return this->GetSliceMin();
 785 }
 786 int wxvtkImageViewer2::GetWholeZMax()
 787 {
 788   VTK_LEGACY_REPLACED_BODY(wxvtkImageViewer2::GetWholeZMax, "VTK 5.0",
 789                            wxvtkImageViewer2::GetSliceMax);
 790   return this->GetSliceMax();
 791 }
 792 int wxvtkImageViewer2::GetZSlice()
 793 {
 794   VTK_LEGACY_REPLACED_BODY(wxvtkImageViewer2::GetZSlice, "VTK 5.0",
 795                            wxvtkImageViewer2::GetSlice);
 796   return this->GetSlice();
 797 }
 798 void wxvtkImageViewer2::SetZSlice(int s)
 799 {
 800   VTK_LEGACY_REPLACED_BODY(wxvtkImageViewer2::SetZSlice, "VTK 5.0",
 801                            wxvtkImageViewer2::SetSlice);
 802   this->SetSlice(s);
 803 }
 804 #endif
 805
 806 //----------------------------------------------------------------------------
 807 void wxvtkImageViewer2::PrintSelf(ostream& os, vtkIndent indent)
 808 {
 809   this->Superclass::PrintSelf(os, indent);
 810
 811   os << indent << "RenderWindow:\n";
 812   this->RenderWindow->PrintSelf(os,indent.GetNextIndent());
 813   os << indent << "Renderer:\n";
 814   this->Renderer->PrintSelf(os,indent.GetNextIndent());
 815   os << indent << "ImageActor:\n";
 816   this->ImageActor->PrintSelf(os,indent.GetNextIndent());
 817   os << indent << "WindowLevel:\n" << endl;
 818   this->WindowLevel->PrintSelf(os,indent.GetNextIndent());
 819   os << indent << "Slice: " << this->Slice << endl;
 820   os << indent << "SliceOrientation: " << this->SliceOrientation << endl;
 821   os << indent << "InteractorStyle: " << endl;
 822   if (this->InteractorStyle)
 823     {
 824     os << "\n";
 825     this->InteractorStyle->PrintSelf(os,indent.GetNextIndent());
 826     }
 827   else
 828     {
 829     os << "None";
 830     }
 831 }