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 = new WxViewerPlayer(this); //images, mViewer, mInteractor, this);
  85
  86         mPlayer->Create();
  87         mPlayer->Run();
  88
  89     topsizer-> Add( mInteractor ,1,wxGROW  ,0);
  90     SetSizer( topsizer );
  91     Layout();
  92   }
  93   //=====================================================================
  94
  95   //=====================================================================
  96   /// Destructor
  97   WxViewer::~WxViewer()
  98   {
  99     wxMutexLocker lock(mMutex);
 100     GimmickDebugMessage(1,"WxViewer::~WxViewer"
 101                         <<std::endl);
 102     SetMovieSize(0);
 103     // TO DO : desallocate cleanly
 104     //    delete mPlayer;
 105     //    delete mInteractor;
 106   }
 107   //=====================================================================
 108
 109
 110   //================================================================
 111
 112   void WxViewer::SetImage(int i, vtkImageData* im)
 113   {
 114     wxMutexLocker lock(mMutex);
 115         if(images.size()>0)
 116         {
 117                 GimmickDebugMessage(5,"WxViewer::SetImage "<<i+1<<"/"<<images.size()
 118                         <<std::endl);
 119                 if (i<images.size())
 120                 {
 121                 //      if (images[i]!=0) images[i]->UnRegister(NULL);
 122                 images[i] = im;
 123                 //      if (im!=0) im->Register(NULL);
 124                 }
 125
 126         }
 127
 128   }
 129
 130   //================================================================
 131
 132
 133
 134   //================================================================
 135
 136   bool WxViewer::ImagesEmpty()
 137   {
 138     wxMutexLocker lock(mMutex);
 139     return images.empty();
 140   }
 141   //================================================================
 142
 143   //================================================================
 144
 145   void WxViewer::SetMovieSize(unsigned int si)
 146   {
 147     wxMutexLocker lock(mMutex);
 148     GimmickDebugMessage(5,"WxViewer::SetMovieSize("<<(int)si<<")"
 149                         <<std::endl);
 150     for (unsigned int i=0;i<images.size();++i)
 151       {
 152         if (images[i]!=0)
 153           {
 154             //      images[i]->UnRegister(NULL);
 155           }
 156       }
 157     images.clear();
 158     for (unsigned int i=0;i<si;++i) images.push_back(0);
 159     mCurrent = 0;
 160   }
 161   //================================================================
 162
 163   //================================================================
 164
 165   void WxViewer::ShowNextImage()
 166   {
 167     wxMutexLocker lock(mMutex);
 168     /*
 169     GimmickMessage(1,"WxViewer::ShowNextImage() "
 170                    <<mCurrent+1<<"/"
 171                    <<images.size()<<std::endl);
 172     */
 173
 174     if (mCurrent<images.size())
 175       {
 176         ShowImage(images[mCurrent]);
 177         if ( images[mCurrent] != mLastImageShown ) mNeedRefresh = true;
 178         mLastImageShown = images[mCurrent];
 179       }
 180     mCurrent++;
 181     if (mCurrent >= images.size()) mCurrent = 0;
 182   }
 183   //================================================================
 184
 185
 186
 187
 188   //=====================================================================
 189   void WxViewer::ShowImage(vtkImageData* im)
 190   {
 191     GimmickDebugMessage(5,"WxViewer::ShowImage"
 192                         <<std::endl);
 193     if (im==0) return;
 194
 195     mViewer->SetInput(im);
 196     mViewer->SetSlice( 0 );
 197
 198     int x1,x2,y1,y2,z1,z2;
 199     double spx,spy,spz;
 200     im->Update();
 201
 202     im->GetSpacing(spx,spy,spz);
 203     im->GetExtent (x1,x2,y1,y2,z1,z2);
 204     /*
 205     std::cout << "-----------------------------"<<std::endl;
 206     std::cout << x1 << "-"<<x2<<std::endl;
 207     std::cout << y1 << "-"<<y2<<std::endl;
 208     std::cout << z1 << "-"<<z2<<std::endl;
 209     std::cout << spx << "-"<<spy<<"-"<<spz<<std::endl;
 210     */
 211
 212     if ((x1!=mx1) ||
 213         (x2!=mx2) ||
 214         (y1!=my1) ||
 215         (y2!=my2) ||
 216         (z1!=mz1) ||
 217         (z2!=mz2) ||
 218         (spx!=mspx) ||
 219         (spy!=mspy) ||
 220         (spz!=mspz)
 221         )
 222       {
 223         mx1 = x1;
 224         mx2 = x2;
 225         my1 = y1;
 226         my2 = y2;
 227         mz1 = z1;
 228         mz2 = z2;
 229         mspx = spx;
 230         mspy = spy;
 231         mspz = spz;
 232
 233         double *range = im->GetScalarRange();
 234          mViewer->SetColorWindow(range[1] - range[0]);
 235          mViewer->SetColorLevel(0.5 * (range[1] + range[0]));
 236
 237          mViewer->GetRenderer()->ResetCamera();
 238         double bounds[6];
 239
 240
 241          mViewer->GetRenderer()->ComputeVisiblePropBounds(bounds);
 242
 243          /*
 244         std::cout <<"bounds : "<<bounds[0]<<","
 245 <<bounds[1]<<","
 246 <<bounds[2]<<","
 247 <<bounds[3]<<","
 248 <<bounds[4]<<","
 249                   <<bounds[5]<<std::endl;
 250          */
 251
 252          mViewer->GetRenderer()->ResetCameraClippingRange(bounds);
 253         /*
 254         vtkCamera *camera = mViewer->GetRenderer()->GetActiveCamera();
 255
 256         camera->SetViewUp ( spx*0, -spy*1, spz*0);
 257         camera->SetPosition( spx*(x1+x2)/2, spy*(y1+y2)/2, spz*10000000);
 258         camera->SetFocalPoint   ( spx*(x1+x2)/2 , spy*(y1+y2)/2 , spz*0);
 259
 260         camera->ComputeViewPlaneNormal();
 261         camera->SetParallelScale(  spx*(x2-x1)/2.0 );
 262
 263         camera->Roll ( 180 );
 264         */
 265
 266       }
 267
 268     //  mInteractor->Refresh();
 269     //mInteractor->Render();
 270     //    mViewer->Render();
 271
 272    //::wxWakeUpIdle();
 273   }
 274   //================================================================
 275
 276   //==================================================
 277   void WxViewer::OnInternalIdle()
 278   {
 279     //    mInteractor->Refresh();
 280         if(images.size()>0)
 281         {
 282 //       mInteractor->Render();
 283         }
 284     //mViewer->Render();
 285   }
 286
 287    //================================================================
 288   bool WxViewer::RefreshIfNecessary()
 289   {
 290     if (mNeedRefresh)
 291       {
 292         GimmickMessage(1,"WxViewer : Refreshing"<<std::endl);
 293         mInteractor->Render();
 294         //      mViewer->Render();
 295         //      Refresh();
 296         mNeedRefresh = false;
 297         return true;
 298       }
 299     return false;
 300   }
 301   //==================================================
 302   void WxViewer::StopPlayer()
 303   {
 304     mPlayer->Delete();
 305   }
 306
 307
 308
 309   //  BEGIN_EVENT_TABLE(WxGimmickFrame, wxDialog)
 310   //    END_EVENT_TABLE()
 311   //================================================================
 312
 313 //========================================================================
 314 //========================================================================
 315 //========================================================================
 316 //========================================================================
 317 //========================================================================
 318 //========================================================================
 319 //========================================================================
 320 //========================================================================
 321
 322   void*  WxViewerPlayer::Entry()
 323   {
 324
 325     GimmickMessage(1,"WxViewerPlayer::Entry()"<<std::endl);
 326
 327     while(true)
 328       {
 329                 if(!TestDestroy())
 330             {
 331                         mWxViewer->ShowNextImage();
 332                         //                      mWxViewer->Refresh();
 333                         ::wxWakeUpIdle();
 334                         clock_t endwait;
 335                         endwait = clock () + 0.2 * CLOCKS_PER_SEC ;
 336                         while (clock() < endwait) {}
 337                 }
 338                 else
 339                 {
 340                         break;
 341                 }
 342         /*
 343         for(i=mImagesToPlay.begin();i!=mImagesToPlay.end();++i)
 344           {
 345             if(i!=mImagesToPlay.end())
 346               {
 347
 348                 GimmickMessage(1,"ThreadedMovie next image"<<std::endl);
 349
 350                 ShowImage(*i);
 351                 mParent->Refresh();
 352                 endwait = clock () + 0.2 * CLOCKS_PER_SEC ;
 353                 while (clock() < endwait) {}
 354
 355
 356           }
 357         */
 358       }
 359     return 0;
 360   }
 361
 362   //=====================================================================
 363
 364   //=====================================================================
 365   void WxViewerPlayer::OnExit()
 366   {
 367     GimmickMessage(1,"WxViewerPlayer::OnExit() "<<std::endl);
 368   }
 369
 370
 371 } // EO namespace creaImageIO
 372