src2/creaImageIOWxViewer.cpp

   1
   2 #include <creaImageIOWxViewer.h>
   3 #include <creaImageIOSystem.h>
   4 #include <fstream>
   5 #include <vtkCamera.h>
   6 #include <vtkRenderer.h>
   7 #include <vtkImageData.h>
   8
   9 #include <creaMessageManager.h>
  10 #include <stdio.h>
  11 #include <time.h>
  12
  13 using namespace crea;
  14
  15 namespace creaImageIO
  16 {
  17
  18   //=====================================================================
  19
  20   //=====================================================================
  21   class WxViewerPlayer: public wxThread
  22   {
  23   public:
  24     WxViewerPlayer(WxViewer* v) :
  25       mWxViewer(v)
  26     {}
  27
  28     void* Entry();
  29     //    void SetImagesToPlay(std::vector<vtkImageData*> im);
  30     //    void ShowImage(vtkImageData* v);
  31     //    void StartIterator();
  32     void  OnExit();
  33
  34   private:
  35     //std::vector<vtkImageData*> mImagesToPlay;
  36     //vtkImageViewer2* mViewer;
  37     /// Associated wxvtk interactor
  38     //crea::creawxVTKRenderWindowInteractor  *mInteractor;
  39     //std::vector<vtkImageData*>::iterator i;
  40     WxViewer* mWxViewer;
  41
  42     //    int mx1,mx2,my1,my2,mz1,mz2;
  43     //    double mspx,mspy,mspz;
  44   };
  45
  46   //=====================================================================
  47
  48
  49
  50
  51
  52   //=====================================================================
  53   // CTor
  54   WxViewer::WxViewer(wxWindow *parent,
  55                      wxWindowID id,
  56                      wxString title,
  57                      const wxPoint& pos,
  58                      const wxSize& size)
  59     :   wxPanel( parent,
  60                  id,
  61                  pos,
  62                  size)
  63   {
  64     wxMutexLocker lock(mMutex);
  65     GimmickDebugMessage(1,"WxViewer::WxViewer"
  66                         <<std::endl);
  67
  68     mNeedRefresh = false;
  69     mLastImageShown = NULL;
  70
  71     wxBoxSizer *topsizer = new wxBoxSizer(wxVERTICAL);
  72
  73
  74     // previewer
  75
  76     mInteractor = new crea::creawxVTKRenderWindowInteractor(this,-1);
  77     mInteractor->UseCaptureMouseOn();
  78
  79     mViewer     = vtkImageViewer2::New();
  80     mViewer->SetupInteractor ( mInteractor );
  81
  82     mCurrent = 0;
  83
  84           mPlayer = 0;
  85
  86     topsizer-> Add( mInteractor ,1,wxGROW  ,0);
  87     SetSizer( topsizer );
  88     Layout();
  89   }
  90   //=====================================================================
  91
  92   //=====================================================================
  93   /// Destructor
  94   WxViewer::~WxViewer()
  95   {
  96     wxMutexLocker lock(mMutex);
  97     GimmickDebugMessage(1,"WxViewer::~WxViewer"
  98                         <<std::endl);
  99     SetMovieSize(0);
 100     // TO DO : desallocate cleanly
 101     //    delete mPlayer;
 102     //    delete mInteractor;
 103   }
 104   //=====================================================================
 105
 106
 107   //================================================================
 108
 109   void WxViewer::SetImage(int i, vtkImageData* im)
 110   {
 111     wxMutexLocker lock(mMutex);
 112         if(images.size()>0)
 113         {
 114                 GimmickDebugMessage(5,"WxViewer::SetImage "<<i+1<<"/"<<images.size()
 115                         <<std::endl);
 116                 if (i<images.size())
 117                 {
 118                 //      if (images[i]!=0) images[i]->UnRegister(NULL);
 119                 images[i] = im;
 120                 //      if (im!=0) im->Register(NULL);
 121                 }
 122
 123         }
 124
 125   }
 126
 127   //================================================================
 128   void WxViewer::SetImageVector(std::vector<ImagePointerHolder*>& pointers)
 129   {
 130         wxMutexLocker lock(mMutex);
 131         GimmickMessage(1,"WxViewer::SetImageVector"<<std::endl);
 132         imagePointers=pointers;
 133   }
 134
 135
 136   //================================================================
 137
 138   bool WxViewer::ImagesEmpty()
 139   {
 140     wxMutexLocker lock(mMutex);
 141     return images.empty();
 142   }
 143   //================================================================
 144
 145   //================================================================
 146
 147   void WxViewer::SetMovieSize(unsigned int si)
 148   {
 149     wxMutexLocker lock(mMutex);
 150     GimmickDebugMessage(5,"WxViewer::SetMovieSize("<<(int)si<<")"
 151                         <<std::endl);
 152     for (unsigned int i=0;i<images.size();++i)
 153       {
 154         if (images[i]!=0)
 155           {
 156             //      images[i]->UnRegister(NULL);
 157           }
 158       }
 159     images.clear();
 160     for (unsigned int i=0;i<si;++i) images.push_back(0);
 161     mCurrent = 0;
 162   }
 163   //================================================================
 164
 165   //================================================================
 166
 167   void WxViewer::ShowNextImage()
 168   {
 169         wxMutexLocker lock(mMutex);
 170
 171
 172     GimmickMessage(10,"WxViewer::ShowNextImage() "
 173                    <<mCurrent+1<<"/"
 174                    <<images.size()<<std::endl);
 175
 176     if(imagePointers.size()>0)
 177         {
 178                 if (mCurrent<imagePointers.size())
 179                 {
 180                         ImagePointerHolder* iph=imagePointers[mCurrent];
 181                         vtkImageData* currIm=iph->Get();
 182                         ShowImage(currIm);
 183                         if ( currIm != mLastImageShown )
 184                         {
 185                                 mNeedRefresh = true;
 186                                 mLastImageShown = currIm;
 187                         }
 188                 mCurrent++;
 189             }
 190                 else
 191                 {
 192                         mCurrent = 0;
 193                         ImagePointerHolder* iph=imagePointers[mCurrent];
 194                         vtkImageData* currIm=iph->Get();
 195                         ShowImage(currIm);
 196                         if ( currIm != mLastImageShown )
 197                         {
 198                                 mNeedRefresh = true;
 199                                 mLastImageShown = currIm;
 200                         }
 201                         mCurrent++;
 202                 }
 203         }
 204   }
 205   //================================================================
 206
 207
 208
 209
 210   //=====================================================================
 211   void WxViewer::ShowImage(vtkImageData* im)
 212   {
 213
 214     GimmickDebugMessage(5,"WxViewer::ShowImage"
 215                         <<std::endl);
 216     if (im==0) return;
 217
 218     mViewer->SetInput(im);
 219
 220     mViewer->SetSlice( 0 );
 221
 222     int x1,x2,y1,y2,z1,z2;
 223     double spx,spy,spz;
 224     im->Update();
 225
 226     im->GetSpacing(spx,spy,spz);
 227     im->GetExtent (x1,x2,y1,y2,z1,z2);
 228
 229     if ((x1!=mx1) ||
 230         (x2!=mx2) ||
 231         (y1!=my1) ||
 232         (y2!=my2) ||
 233         (z1!=mz1) ||
 234         (z2!=mz2) ||
 235         (spx!=mspx) ||
 236         (spy!=mspy) ||
 237         (spz!=mspz)
 238         )
 239       {
 240         mx1 = x1;
 241         mx2 = x2;
 242         my1 = y1;
 243         my2 = y2;
 244         mz1 = z1;
 245         mz2 = z2;
 246         mspx = spx;
 247         mspy = spy;
 248         mspz = spz;
 249
 250         double *range = im->GetScalarRange();
 251          mViewer->SetColorWindow(range[1] - range[0]);
 252          mViewer->SetColorLevel(0.5 * (range[1] + range[0]));
 253
 254          mViewer->GetRenderer()->ResetCamera();
 255         double bounds[6];
 256
 257
 258          mViewer->GetRenderer()->ComputeVisiblePropBounds(bounds);
 259
 260
 261          mViewer->GetRenderer()->ResetCameraClippingRange(bounds);
 262
 263
 264       }
 265
 266    //::wxWakeUpIdle();
 267
 268   }
 269   //================================================================
 270
 271   //==================================================
 272   void WxViewer::OnInternalIdle()
 273   {
 274     //    mInteractor->Refresh();
 275         if(images.size()>0)
 276         {
 277 //       mInteractor->Render();
 278         }
 279     //mViewer->Render();
 280   }
 281
 282    //================================================================
 283   bool WxViewer::RefreshIfNecessary()
 284   {
 285     if (mNeedRefresh)
 286       {
 287         GimmickMessage(1,"WxViewer : Refreshing"<<std::endl);
 288
 289         mInteractor->Render();
 290         mNeedRefresh = false;
 291         return true;
 292       }
 293     return false;
 294   }
 295   //==================================================
 296   void WxViewer::StopPlayer()
 297   {
 298           wxMutexLocker lock(mMutex);
 299           if (mPlayer==0) return;
 300           mPlayer->Delete();
 301           mPlayer=0;
 302   }
 303
 304   //==================================================
 305   void WxViewer::StartPlayer()
 306         {
 307         //      wxMutexLocker lock(mMutex);
 308                 if (mPlayer != 0) return;
 309                 mPlayer = new WxViewerPlayer(this);
 310                 mPlayer->Create();
 311                 mPlayer->Run();
 312         }
 313
 314
 315
 316
 317
 318   //  BEGIN_EVENT_TABLE(WxGimmickFrame, wxDialog)
 319   //    END_EVENT_TABLE()
 320   //================================================================
 321
 322 //========================================================================
 323 //========================================================================
 324 //========================================================================
 325 //========================================================================
 326 //========================================================================
 327 //========================================================================
 328 //========================================================================
 329 //========================================================================
 330
 331   void*  WxViewerPlayer::Entry()
 332   {
 333
 334     GimmickMessage(1,"WxViewerPlayer::Entry()"<<std::endl);
 335
 336         while(!TestDestroy())
 337             {
 338
 339                         mWxViewer->ShowNextImage();
 340                         ::wxWakeUpIdle();
 341                         clock_t endwait;
 342                         endwait = clock () + 0.2 * CLOCKS_PER_SEC ;
 343                         while (clock() < endwait) {}
 344
 345       }
 346     return 0;
 347   }
 348
 349   //=====================================================================
 350
 351   //=====================================================================
 352   void WxViewerPlayer::OnExit()
 353   {
 354     GimmickMessage(1,"WxViewerPlayer::OnExit() "<<std::endl);
 355   }
 356
 357
 358 } // EO namespace creaImageIO
 359