tools/clitkMeshViewer.cxx

   1 /*=========================================================================
   2   Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
   3
   4   Authors belong to:
   5   - University of LYON              http://www.universite-lyon.fr/
   6   - Léon Bérard cancer center       http://www.centreleonberard.fr
   7   - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
   8
   9   This software is distributed WITHOUT ANY WARRANTY; without even
  10   the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  11   PURPOSE.  See the copyright notices for more information.
  12
  13   It is distributed under dual licence
  14
  15   - BSD        See included LICENSE.txt file
  16   - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  17 ===========================================================================*/
  18
  19 #include "vtkOBJReader.h"
  20 #include "vtkPolyDataMapper.h"
  21 #include "vtkRenderer.h"
  22 #include "vtkRenderWindow.h"
  23 #include "vtkActor.h"
  24 #include "vtkCamera.h"
  25 #include "vtkRenderWindowInteractor.h"
  26 #include "vtkSmartPointer.h"
  27 #include "vtkCommand.h"
  28 #include "vtkAnimationCue.h"
  29 #include "vtkAnimationScene.h"
  30 #include "vtkProperty.h"
  31 #include "vtkInteractorStyle.h"
  32
  33 #include <string>
  34 #include <iostream>
  35 #include <vector>
  36
  37 typedef vtkSmartPointer<vtkOBJReader> ObjReaderType;
  38 typedef vtkSmartPointer<vtkPolyDataMapper> MapperType;
  39 typedef vtkSmartPointer<vtkActor> ActorType;
  40
  41
  42 void run(int argc, char** argv);
  43
  44 // Adapted from vtkAnimationCue example...
  45 class CueAnimator
  46 {
  47 public:
  48   CueAnimator(std::vector<ActorType>& rActors) : m_Fps(1), m_LastTick(0), m_CurrentActor(0), m_rActors(rActors) {
  49   }
  50
  51   ~CueAnimator() {
  52    }
  53
  54   void SetFps(double fps) {
  55     m_Fps = fps;
  56   }
  57
  58   void StartCue(vtkAnimationCue::AnimationCueInfo *vtkNotUsed(info),
  59                 vtkRenderer *ren)
  60     {
  61       std::cout << "StartCue" << std::endl;
  62       m_LastTick = 0;
  63       m_rActors[0]->SetVisibility(1);
  64
  65       for (unsigned int i = 1; i < m_rActors.size(); i++) {
  66         m_rActors[i]->SetVisibility(0);
  67       }
  68
  69     }
  70
  71   void Tick(vtkAnimationCue::AnimationCueInfo *info,
  72             vtkRenderer *ren)
  73     {
  74       std::cout << "Tick AT:" << info->AnimationTime << " DT:" << info->DeltaTime << " CT:" << info->ClockTime << std::endl;
  75       if (info->AnimationTime - m_LastTick < 1/m_Fps)
  76         return;
  77
  78       m_LastTick = info->AnimationTime;
  79
  80       m_rActors[m_CurrentActor]->SetVisibility(0);
  81
  82       ++m_CurrentActor;
  83       m_CurrentActor %= m_rActors.size();
  84
  85       m_rActors[m_CurrentActor]->SetVisibility(1);
  86
  87       ren->Render();
  88     }
  89
  90   void EndCue(vtkAnimationCue::AnimationCueInfo *vtkNotUsed(info),
  91               vtkRenderer *ren)
  92     {
  93       std::cout << "EndCue" << std::endl;
  94     }
  95
  96 protected:
  97
  98   double m_Fps;
  99   double m_LastTick;
 100   int m_CurrentActor;
 101   std::vector<ActorType>& m_rActors;
 102 };
 103
 104 class vtkAnimationCueObserver : public vtkCommand
 105 {
 106 public:
 107   static vtkAnimationCueObserver *New()
 108     {
 109       return new vtkAnimationCueObserver;
 110     }
 111
 112   virtual void Execute(vtkObject *vtkNotUsed(caller),
 113                        unsigned long event,
 114                        void *calldata)
 115     {
 116       if(this->Animator!=0 && this->Renderer!=0)
 117         {
 118         vtkAnimationCue::AnimationCueInfo *info=
 119           static_cast<vtkAnimationCue::AnimationCueInfo *>(calldata);
 120         switch(event)
 121           {
 122           case vtkCommand::StartAnimationCueEvent:
 123             this->Animator->StartCue(info,this->Renderer);
 124             break;
 125           case vtkCommand::EndAnimationCueEvent:
 126             this->Animator->EndCue(info,this->Renderer);
 127             break;
 128           case vtkCommand::AnimationCueTickEvent:
 129             this->Animator->Tick(info,this->Renderer);
 130             break;
 131           }
 132         }
 133       if(this->RenWin!=0)
 134         {
 135         this->RenWin->Render();
 136         }
 137     }
 138
 139   vtkRenderer *Renderer;
 140   vtkRenderWindow *RenWin;
 141   CueAnimator *Animator;
 142
 143 protected:
 144   vtkAnimationCueObserver()
 145     {
 146       this->Renderer=0;
 147       this->Animator=0;
 148       this->RenWin=0;
 149     }
 150 };
 151
 152 class vtkWindowObserver : public vtkCommand
 153 {
 154 public:
 155   static vtkWindowObserver *New()
 156     {
 157       return new vtkWindowObserver;
 158     }
 159
 160   virtual void Execute(vtkObject *caller,
 161                        unsigned long event,
 162                        void *calldata)
 163     {
 164       vtkRenderWindowInteractor *isi = dynamic_cast<vtkRenderWindowInteractor *>(caller);
 165       std::cout << "Execute" << std::endl;
 166       switch (event)
 167       {
 168         case vtkCommand::KeyPressEvent:
 169         {
 170           std::string key = isi->GetKeySym();
 171           std::cout << key[0] << std::endl;
 172           switch (key[0])
 173           {
 174             case 'P':
 175             case 'p':
 176               if (this->m_Scene)
 177                 this->m_Scene->Play();
 178               break;
 179
 180             case 'M':
 181             case 'm':
 182               if (this->m_Scene)
 183                 this->m_Scene->Stop();
 184               break;
 185
 186             default:
 187               break;
 188           }
 189         }
 190
 191         default:
 192           break;
 193
 194       }
 195
 196     }
 197
 198     vtkAnimationScene* m_Scene;
 199
 200   protected:
 201
 202     vtkWindowObserver() : m_Scene(0) {}
 203 };
 204
 205 int main(int argc, char** argv)
 206 {
 207   if (argc == 0)
 208     std::cout << "Usage: clitkMeshViewer FILE1 FILE2 ..." << std::endl;
 209
 210   run(argc, argv);
 211
 212   return EXIT_SUCCESS;
 213 }
 214
 215 void run(int argc, char** argv)
 216 {
 217   std::vector<ObjReaderType> objs;
 218   std::vector<MapperType> mappers;
 219   std::vector<ActorType> actors;
 220
 221   int nfiles = argc;
 222   std::string animate = argv[argc-1];
 223   if (animate == "--animate")
 224     nfiles = argc-1;
 225
 226   vtkSmartPointer<vtkRenderer> aRenderer = vtkRenderer::New();
 227   for (int i = 1; i < nfiles; i++) {
 228     std::string file = argv[i];
 229
 230     std::cout << "Reading " << file << std::endl;
 231
 232     vtkSmartPointer<vtkOBJReader> preader = vtkOBJReader::New();
 233     preader->SetFileName(file.c_str());
 234     preader->Update();
 235     objs.push_back(preader);
 236
 237     vtkSmartPointer<vtkPolyDataMapper> skinMapper = vtkPolyDataMapper::New();
 238     skinMapper->SetInputConnection(preader->GetOutputPort());
 239     skinMapper->ScalarVisibilityOff();
 240     mappers.push_back(skinMapper);
 241
 242     vtkSmartPointer<vtkActor> skin = vtkActor::New();
 243     skin->SetMapper(skinMapper);
 244     actors.push_back(skin);
 245
 246     aRenderer->AddActor(skin);
 247   }
 248
 249   vtkSmartPointer<vtkCamera> aCamera = vtkCamera::New();
 250   aCamera->SetViewUp (0, 0, -1);
 251   aCamera->SetPosition (0, 1, 0);
 252   aCamera->SetFocalPoint (0, 0, 0);
 253   aCamera->ComputeViewPlaneNormal();
 254   aCamera->Dolly(1.5);
 255
 256   aRenderer->SetActiveCamera(aCamera);
 257   aRenderer->ResetCamera ();
 258   aRenderer->SetBackground(0,0,0);
 259   aRenderer->ResetCameraClippingRange ();
 260
 261   vtkSmartPointer<vtkRenderWindow> renWin = vtkRenderWindow::New();
 262   renWin->AddRenderer(aRenderer);
 263   renWin->SetSize(640, 480);
 264
 265   vtkSmartPointer<vtkRenderWindowInteractor> iren = vtkRenderWindowInteractor::New();
 266   iren->SetRenderWindow(renWin);
 267   iren->Initialize();
 268
 269   vtkSmartPointer<vtkAnimationScene> scene;
 270   vtkSmartPointer<vtkAnimationCue> cue1;
 271   vtkSmartPointer<vtkAnimationCueObserver> anim_observer;
 272   vtkSmartPointer<vtkWindowObserver> window_observer;
 273   CueAnimator animator(actors);
 274
 275   double fps = 5;
 276   animator.SetFps(fps);
 277
 278   if (animate == "--animate") {
 279     // Create an Animation Scene
 280     scene=vtkAnimationScene::New();
 281     scene->SetModeToRealTime();
 282
 283     scene->SetLoop(1);
 284     scene->SetTimeModeToRelative();
 285     scene->SetStartTime(0);
 286     scene->SetEndTime(actors.size()/fps);
 287
 288     // Create an Animation Cue.
 289     cue1=vtkAnimationCue::New();
 290     cue1->SetTimeModeToRelative();
 291     cue1->SetStartTime(0);
 292     cue1->SetEndTime(actors.size()/fps);
 293     scene->AddCue(cue1);
 294
 295     // Create Cue anim_observer.
 296     anim_observer=vtkAnimationCueObserver::New();
 297     anim_observer->Renderer=aRenderer;
 298     anim_observer->Animator=&animator;
 299     anim_observer->RenWin=renWin;
 300     cue1->AddObserver(vtkCommand::StartAnimationCueEvent,anim_observer);
 301     cue1->AddObserver(vtkCommand::EndAnimationCueEvent,anim_observer);
 302     cue1->AddObserver(vtkCommand::AnimationCueTickEvent,anim_observer);
 303
 304     window_observer = vtkWindowObserver::New();
 305     window_observer->m_Scene = scene;
 306     iren->AddObserver(vtkCommand::KeyPressEvent, window_observer);
 307
 308   }
 309
 310   iren->Start();
 311 }
 312
 313