creaImageIOWxViewer.cpp

Go to the documentation of this file.

#include <creaImageIOWxViewer.h>
#include <creaImageIOSystem.h>
#include <fstream>
#include <vtkCamera.h>
#include <vtkRenderer.h>
#include <vtkImageData.h>
#include <creawxVTKRenderWindowInteractor.h>
#include <creaMessageManager.h>
#include <stdio.h>
#include <time.h>


using namespace crea;

namespace creaImageIO
{
  
  //=====================================================================

  //=====================================================================
  class WxViewerPlayer: public wxThread
  {
  public:
    WxViewerPlayer(WxViewer* v) :
      mWxViewer(v)
    {}
    
    void* Entry();
    void  OnExit();
        
  private:

    WxViewer* mWxViewer;
  };
  
  //=====================================================================



  

  //=====================================================================
  // CTor
  WxViewer::WxViewer(wxWindow *parent, 
                     wxWindowID id,
                     wxString title,
                     const wxPoint& pos,
                     const wxSize& size)
    :   wxPanel( parent, 
                 id, 
                 pos,
                 size)
  {
    wxMutexLocker lock(mMutex);
    GimmickDebugMessage(6,"WxViewer::WxViewer"
                        <<std::endl);

    mNeedRefresh = false;
    mLastImageShown = NULL;
        
        // previewer    
    mInteractor = new crea::creawxVTKRenderWindowInteractor(this,-1);
    mInteractor->UseCaptureMouseOn();   
 
    mViewer     = vtkImageViewer2::New();
    mViewer->SetupInteractor ( mInteractor );
    
    mCurrent = 0;
        mPlayer = 0;

        // Grid to place checkbox and slider 
        mflexSizer = new wxFlexGridSizer(1,2,1,1);
        //Slider
        mslide = new wxSlider(this,-1,0,0,1, wxDefaultPosition, wxSize(400,40), wxSL_HORIZONTAL | wxSL_LABELS);
        Connect( mslide->GetId(), wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &WxViewer::OnSlide ); 
        //CheckBox
        mcheck = new wxCheckBox(this,5123,crea::std2wx("Cine Loop"));
        Connect( mcheck->GetId(), wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &WxViewer::OnCineLoop ); 
        mcheck->SetValue(false);
        mflexSizer->Add(mcheck,0, wxFIXED_MINSIZE);
        mflexSizer-> Add( mslide,1,wxALIGN_CENTER | wxFIXED_MINSIZE );

        // Sizer for Previewer and GridSizer
        mtopSizer = new wxBoxSizer(wxVERTICAL);
        mtopSizer->Add(mflexSizer,0);
    mtopSizer-> Add( mInteractor ,1,wxGROW,0);
        SetSizer(mtopSizer,true);
        
        Update();  
    Layout(); 
  }
  //=====================================================================

  //=====================================================================
  WxViewer::~WxViewer()
  {
    wxMutexLocker lock(mMutex);
    GimmickDebugMessage(6,"WxViewer::~WxViewer"
                        <<std::endl);
    // TO DO : desallocate cleanly
        if(mPlayer)
        {
                mPlayer->Pause();
                mPlayer->Delete();
                mPlayer = 0;
        }
        delete mInteractor;
        //delete mslide;
        //delete mflexSizer;
  }
  //=====================================================================

  //================================================================
   void WxViewer::SetImageVector(std::vector<boost::shared_ptr<ImagePointerHolder> >& pointers)
  {
        wxMutexLocker lock(mMutex);
        GimmickDebugMessage(6,"WxViewer::SetImageVector"<<std::endl);
        imagePointers=pointers;
        
        mslide->SetMax(pointers.size());
        mslide->SetMin(1);
        // Refresh don't work, TO MODIFY
        mslide->Refresh();
        mslide->ClearTicks();
        mslide->Hide();
        mslide->Show();
        StartPlayer();
  }

  //================================================================

  void WxViewer::ShowNextImage()
  {
         
        
          mMutex.Unlock();
        wxMutexLocker lock(mMutex);
            
    GimmickMessage(2,"WxViewer::ShowNextImage() "
                   <<mCurrent+1<<"/"
                   <<imagePointers.size()<<std::endl);
    
    if(imagePointers.size()>0)
        {
                if (mCurrent<imagePointers.size()) 
                {
                        boost::shared_ptr<ImagePointerHolder> iph = imagePointers[mCurrent];
                        //ImagePointerHolder* iph= imagePointers[mCurrent];
                        vtkImageData* currIm=iph->Get();
                        ShowImage(currIm);
                        if ( currIm != mLastImageShown ) 
                        {
                                mNeedRefresh = true;
                                mLastImageShown = currIm;
                        }
                mCurrent++;
            }
                else
                {
                        mCurrent = 0;
                        //ImagePointerHolder* iph=imagePointers[mCurrent];
                        boost::shared_ptr<ImagePointerHolder> iph = imagePointers[mCurrent];
                        vtkImageData* currIm=iph->Get();
                        ShowImage(currIm);
                        if ( currIm != mLastImageShown ) 
                        {
                                mNeedRefresh = true;
                                mLastImageShown = currIm;
                        }
                        mCurrent++;
                }
        }
  }
  //================================================================

  //=====================================================================
  void WxViewer::ShowImage(vtkImageData* im)
  {
    GimmickDebugMessage(6,"WxViewer::ShowImage"
                        <<std::endl);
    if (im==0) return;

    mViewer->SetInput(im);

    mViewer->SetSlice( 0 );

    int x1,x2,y1,y2,z1,z2;
    double spx,spy,spz;
    im->Update();

//std::cout << "in WxViewer::ShowImage PrintSelf() =";
//im->PrintSelf(std::cout, vtkIndent(2));

    im->GetSpacing(spx,spy,spz);
    //im->GetExtent (x1,x2,y1,y2,z1,z2);  // JPR
    im->GetWholeExtent (x1,x2,y1,y2,z1,z2); 
/*       
std::cout << "in WxViewer::ShowImage GetWholeExtent ext =";
        std::cout << "   [x1]=" << x1;
        std::cout << "   [x2]=" << x2;
        std::cout << "   [y1]=" << y1;
        std::cout << "   [y2]=" << y2;
        std::cout << "   [z1]=" << z1;
        std::cout << "   [z2]=" << z2;
std::cout << std::endl; 
*/   
    if ((x1!=mx1) ||
        (x2!=mx2) ||
        (y1!=my1) ||
        (y2!=my2) ||
        (z1!=mz1) ||
        (z2!=mz2) ||
        (spx!=mspx) ||
        (spy!=mspy) ||
        (spz!=mspz) 
        )
      {
        mx1 = x1;
        mx2 = x2;
        my1 = y1;
        my2 = y2;
        mz1 = z1;
        mz2 = z2;
        mspx = spx;
        mspy = spy;
        mspz = spz;

        double *range = im->GetScalarRange();
        mViewer->SetColorWindow(range[1] - range[0]);
        mViewer->SetColorLevel(0.5 * (range[1] + range[0]));

        mViewer->GetRenderer()->ResetCamera();
        double bounds[6];

        mViewer->GetRenderer()->ComputeVisiblePropBounds(bounds);

        mViewer->GetRenderer()->ResetCameraClippingRange(bounds);
        mViewer->GetRenderer()->SetBackground(0.1,0.1,0.2);  
      }
  } 
  //================================================================
  
  //================================================================
  bool WxViewer::RefreshIfNecessary()
  {
    if (mNeedRefresh)
      {
        GimmickDebugMessage(10,"WxViewer : Refreshing"<<std::endl);

        mInteractor->Render();
        mNeedRefresh = false;
        return true;
      }
    return false;
  }
  //================================================================
  
  //==================================================
  void WxViewer::StopPlayer()
  {
          wxMutexLocker lock(mMutex);
          if (mPlayer==0 ) return;
          mPlayer->Delete();  
          mPlayer=0;
          mMutex.Unlock();
  }
  //================================================================
  
  //==================================================
  void WxViewer::StartPlayer()
        {
                if(mcheck->IsChecked())
                {
                        //      wxMutexLocker lock(mMutex);
                        if (mPlayer != 0) return;
                        mPlayer = new WxViewerPlayer(this);
                        mPlayer->Create();
                        mPlayer->Run();  
                }
                else
                {
                        ShowNextImage();
                }
        }

  //================================================================
  
  //==================================================

    void WxViewer::OnCineLoop(wxCommandEvent &Event)
        {
                if(!mcheck->IsChecked())
                {
                        mPlayer->Pause();
                        mPlayer->Delete();
                        mPlayer = 0;
                }
                StartPlayer();
        }
        
 //================================================================
  
  //==================================================
        
        void WxViewer::OnSlide(wxCommandEvent &Event)
         {
                 mCurrent = mslide->GetValue() -1;
                 StartPlayer();
         }
         //================================================================
  
  //==================================================

         void WxViewer::SetValue()
         {
                 mslide->SetValue(mCurrent);
         }

  //  BEGIN_EVENT_TABLE(WxGimmickFrame, wxDialog)
  //    END_EVENT_TABLE()
  //================================================================

//========================================================================
//========================================================================
//========================================================================
//========================================================================
//========================================================================
//========================================================================
//========================================================================
//========================================================================

  void*  WxViewerPlayer::Entry()
  {
          
    GimmickDebugMessage(6,"WxViewerPlayer::Entry()"<<std::endl);
        
        while(!TestDestroy())
            { 
                        
                        mWxViewer->ShowNextImage();
                        mWxViewer->SetValue();
                        ::wxWakeUpIdle();
                        clock_t endwait;
                        endwait = clock () + 0.2 * CLOCKS_PER_SEC ;
                        while (clock() < endwait ) {}
                        
      }
    return 0;
  }

  //=====================================================================

  //=====================================================================
  void WxViewerPlayer::OnExit()
  {
    GimmickDebugMessage(6,"WxViewerPlayer::OnExit() "<<std::endl);
  }

 
} // EO namespace creaImageIO