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_CurrentActor(0), m_rActors(rActors) {
  49     m_rActors[0]->SetVisibility(1);
  50     for (unsigned int i = 1; i < m_rActors.size(); i++) {
  51       m_rActors[i]->SetVisibility(0);
  52     }
  53   }
  54
  55   ~CueAnimator() {
  56    }
  57
  58   void SetFps(double fps) {
  59     m_Fps = fps;
  60   }
  61
  62   void StartCue(vtkAnimationCue::AnimationCueInfo *vtkNotUsed(info),
  63                 vtkRenderer *ren)
  64     {
  65       //std::cout << "StartCue" << std::endl;
  66     }
  67
  68   void Tick(vtkAnimationCue::AnimationCueInfo *info,
  69             vtkRenderer *ren)
  70     {
  71       //std::cout << "Tick AT:" << info->AnimationTime << " DT:" << info->DeltaTime << " CT:" << info->ClockTime << std::endl;
  72
  73       m_rActors[m_CurrentActor]->SetVisibility(0);
  74
  75       int step = round(m_Fps * info->AnimationTime);
  76       int actor = step % m_rActors.size();
  77
  78       //if (actor != m_CurrentActor) std::cout << "Showing frame: " << m_CurrentActor << std::endl;
  79       m_CurrentActor = actor;
  80       m_rActors[m_CurrentActor]->SetVisibility(1);
  81
  82       ren->Render();
  83     }
  84
  85   void EndCue(vtkAnimationCue::AnimationCueInfo *info,
  86               vtkRenderer *ren)
  87     {
  88       //std::cout << "EndCue" << std::endl;
  89     }
  90
  91 protected:
  92
  93   double m_Fps;
  94   clock_t m_LastTick;
  95   double m_TotalTicks;
  96   int m_CurrentActor;
  97   std::vector<ActorType>& m_rActors;
  98 };
  99
 100 class vtkAnimationCueObserver : public vtkCommand
 101 {
 102 public:
 103   static vtkAnimationCueObserver *New()
 104     {
 105       return new vtkAnimationCueObserver;
 106     }
 107
 108   virtual void Execute(vtkObject *vtkNotUsed(caller),
 109                        unsigned long event,
 110                        void *calldata)
 111     {
 112       if(this->Animator!=0 && this->Renderer!=0)
 113         {
 114         vtkAnimationCue::AnimationCueInfo *info=
 115           static_cast<vtkAnimationCue::AnimationCueInfo *>(calldata);
 116         switch(event)
 117           {
 118           case vtkCommand::StartAnimationCueEvent:
 119             this->Animator->StartCue(info,this->Renderer);
 120             break;
 121           case vtkCommand::EndAnimationCueEvent:
 122             this->Animator->EndCue(info,this->Renderer);
 123             break;
 124           case vtkCommand::AnimationCueTickEvent:
 125             this->Animator->Tick(info,this->Renderer);
 126             break;
 127           }
 128         }
 129       if(this->RenWin!=0)
 130         {
 131         this->RenWin->Render();
 132         }
 133     }
 134
 135   vtkRenderer *Renderer;
 136   vtkRenderWindow *RenWin;
 137   CueAnimator *Animator;
 138
 139 protected:
 140   vtkAnimationCueObserver()
 141     {
 142       this->Renderer=0;
 143       this->Animator=0;
 144       this->RenWin=0;
 145     }
 146 };
 147
 148 class vtkWindowObserver : public vtkCommand
 149 {
 150 public:
 151   static vtkWindowObserver *New()
 152     {
 153       return new vtkWindowObserver;
 154     }
 155
 156   virtual void Execute(vtkObject *caller,
 157                        unsigned long event,
 158                        void *calldata)
 159     {
 160       vtkRenderWindowInteractor *isi = dynamic_cast<vtkRenderWindowInteractor *>(caller);
 161       //std::cout << "Execute" << std::endl;
 162       switch (event)
 163       {
 164         case vtkCommand::KeyPressEvent:
 165         {
 166           std::string key = isi->GetKeySym();
 167           //std::cout << key[0] << std::endl;
 168           switch (key[0])
 169           {
 170             case 'P':
 171             case 'p':
 172               if (this->m_Scene)
 173                 this->m_Scene->Play();
 174               break;
 175
 176             case 'M':
 177             case 'm':
 178               if (this->m_Scene)
 179                 this->m_Scene->Stop();
 180               break;
 181
 182             default:
 183               break;
 184           }
 185         }
 186
 187         default:
 188           break;
 189
 190       }
 191
 192     }
 193
 194     vtkAnimationScene* m_Scene;
 195
 196   protected:
 197
 198     vtkWindowObserver() : m_Scene(0) {}
 199 };
 200
 201 int main(int argc, char** argv)
 202 {
 203   if (argc == 0)
 204     std::cout << "Usage: clitkMeshViewer FILE1 FILE2 ... [--animate]" << std::endl;
 205
 206   run(argc, argv);
 207
 208   return EXIT_SUCCESS;
 209 }
 210
 211 void run(int argc, char** argv)
 212 {
 213   std::vector<ObjReaderType> objs;
 214   std::vector<MapperType> mappers;
 215   std::vector<ActorType> actors;
 216
 217   int nfiles = argc;
 218   std::string animate = argv[argc-1];
 219   if (animate == "--animate")
 220     nfiles = argc-1;
 221
 222   vtkSmartPointer<vtkRenderer> aRenderer = vtkRenderer::New();
 223   for (int i = 1; i < nfiles; i++) {
 224     std::string file = argv[i];
 225
 226     //std::cout << "Reading " << file << std::endl;
 227
 228     vtkSmartPointer<vtkOBJReader> preader = vtkOBJReader::New();
 229     preader->SetFileName(file.c_str());
 230     preader->Update();
 231     objs.push_back(preader);
 232
 233     vtkSmartPointer<vtkPolyDataMapper> skinMapper = vtkPolyDataMapper::New();
 234     skinMapper->SetInputConnection(preader->GetOutputPort());
 235     skinMapper->ScalarVisibilityOff();
 236     mappers.push_back(skinMapper);
 237
 238     vtkSmartPointer<vtkActor> skin = vtkActor::New();
 239     skin->SetMapper(skinMapper);
 240     actors.push_back(skin);
 241
 242     aRenderer->AddActor(skin);
 243   }
 244
 245   vtkSmartPointer<vtkCamera> aCamera = vtkCamera::New();
 246   aCamera->SetViewUp (0, 0, -1);
 247   aCamera->SetPosition (0, 1, 0);
 248   aCamera->SetFocalPoint (0, 0, 0);
 249   aCamera->ComputeViewPlaneNormal();
 250   aCamera->Dolly(1.5);
 251
 252   aRenderer->SetActiveCamera(aCamera);
 253   aRenderer->ResetCamera ();
 254   aRenderer->SetBackground(0,0,0);
 255   aRenderer->ResetCameraClippingRange ();
 256
 257   vtkSmartPointer<vtkRenderWindow> renWin = vtkRenderWindow::New();
 258   renWin->AddRenderer(aRenderer);
 259   renWin->SetSize(640, 480);
 260
 261   vtkSmartPointer<vtkRenderWindowInteractor> iren = vtkRenderWindowInteractor::New();
 262   iren->SetRenderWindow(renWin);
 263   iren->Initialize();
 264
 265   vtkSmartPointer<vtkAnimationScene> scene;
 266   vtkSmartPointer<vtkAnimationCue> cue1;
 267   vtkSmartPointer<vtkAnimationCueObserver> anim_observer;
 268   vtkSmartPointer<vtkWindowObserver> window_observer;
 269   CueAnimator animator(actors);
 270
 271   double fps = 4;
 272   animator.SetFps(fps);
 273
 274   if (animate == "--animate") {
 275     // Create an Animation Scene
 276     scene=vtkAnimationScene::New();
 277     scene->SetModeToRealTime();
 278
 279     scene->SetLoop(1);
 280     scene->SetTimeModeToRelative();
 281     scene->SetStartTime(0);
 282     scene->SetEndTime(actors.size()/fps);
 283
 284     // Create an Animation Cue.
 285     cue1=vtkAnimationCue::New();
 286     cue1->SetTimeModeToRelative();
 287     cue1->SetStartTime(0);
 288     cue1->SetEndTime(actors.size()/fps);
 289     scene->AddCue(cue1);
 290
 291     // Create Cue anim_observer.
 292     anim_observer=vtkAnimationCueObserver::New();
 293     anim_observer->Renderer=aRenderer;
 294     anim_observer->Animator=&animator;
 295     anim_observer->RenWin=renWin;
 296     cue1->AddObserver(vtkCommand::StartAnimationCueEvent,anim_observer);
 297     cue1->AddObserver(vtkCommand::EndAnimationCueEvent,anim_observer);
 298     cue1->AddObserver(vtkCommand::AnimationCueTickEvent,anim_observer);
 299
 300     window_observer = vtkWindowObserver::New();
 301     window_observer->m_Scene = scene;
 302     iren->AddObserver(vtkCommand::KeyPressEvent, window_observer);
 303
 304   }
 305
 306   iren->Start();
 307 }
 308
 309