biaspmdcam2shm.cpp

/* 
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <iostream>
#include <VideoSource/VideoSource_PMD.hh>
#include <Utils/Param.hh>
#include <fstream>
#include <VideoSource/VideoShMFeederPMD.hh>
#include <signal.h>
#include "wx/wx.h"
#include <Gui/StringConv.hh>
#include <Base/Debug/Exception.hh>

using namespace BIAS;
using namespace std;


/** \cond HIDDEN_SYMBOLS
    @file
    @ingroup g_tools
    @brief Opens a PMD camera and writes images to a shared memory object, see biaspmdcam2shm.cpp
    @author MIP
*/
class MyApp : public wxApp
{
  virtual bool OnInit();
};


class MyFrame: public wxFrame
{
public:
  
  MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size);
  
  void OnQuit(wxCommandEvent& event);
  void OnAbout(wxCommandEvent& event);
  void OnFrequency(wxScrollEvent& event);
  void OnIntegrationTime(wxScrollEvent& event);
  void OnTimer(wxTimerEvent& event);
  void OnGetFrequency(wxCommandEvent& event);
  void OnGetIntegrationTime(wxCommandEvent& event);

  DECLARE_EVENT_TABLE()
protected:
  wxButton *QuitButton_;
  wxSlider *SliderFrequency_;
  wxSlider *SliderIntegrationTime_; 
  wxTimer      Timer_;

  VideoSource_PMD Cam_;
  Camera<unsigned char> GrabImage_;
  Camera<float> DepthImage_;
  Camera<float> ModCoeffImage_;
  std::string ShmName_;
  const string ShmPrefix_;
  
  BIAS::VideoShMFeederPMD* pShmFeeder_;
  int framecount_;
};


enum
{
  ID_Quit = 1,
  ID_About,
  ID_MANUAL_EXPOSURE,
  ID_SLIDER_FREQUENCY,
  ID_SLIDER_INTEGRATIONTIME,
  //ID_SLIDER_EXPOSURE,
  ID_BUTTON_QUIT,
  ID_BUTTON_WB,
  ID_CANVAS,
  ID_TIMER = 1001
};


BEGIN_EVENT_TABLE(MyFrame, wxFrame)
  EVT_MENU(ID_Quit, MyFrame::OnQuit)
  EVT_MENU(ID_About, MyFrame::OnAbout)
  EVT_COMMAND_SCROLL(ID_SLIDER_FREQUENCY, MyFrame::OnFrequency)
  EVT_COMMAND_SCROLL(ID_SLIDER_INTEGRATIONTIME, MyFrame::OnIntegrationTime)
  EVT_BUTTON(ID_BUTTON_QUIT, MyFrame::OnQuit)
  EVT_TIMER(ID_TIMER, MyFrame::OnTimer)
END_EVENT_TABLE()

IMPLEMENT_APP(MyApp)


bool MyApp::OnInit()
{
  MyFrame *frame = 
      new MyFrame( wxT("PMDCamToShm"), wxPoint(0,700), wxSize(250,300) );
  frame->Show(TRUE);
  SetTopWindow(frame);
  return TRUE;
}


MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
  : wxFrame((wxFrame *)NULL, -1, title, pos, size)
{
  wxMenu *menuFile = new wxMenu;

  menuFile->Append( ID_About, wxT("&About...") );
  menuFile->AppendSeparator();
  menuFile->Append( ID_Quit, wxT("E&xit") );

  wxMenuBar *menuBar = new wxMenuBar;
  menuBar->Append( menuFile, wxT("&File") );

  SetMenuBar( menuBar );

  wxSizer *Sizer = new wxBoxSizer( wxVERTICAL );

  wxStaticText *FrequencyLabel = 
    new wxStaticText(this, -1, AsciiToWx("Modulation Frequency[MHz] "));
  SliderFrequency_ = 
    new wxSlider(this, ID_SLIDER_FREQUENCY, 20, 0, 60, wxDefaultPosition, 
                 wxDefaultSize,wxSL_LABELS | wxSL_HORIZONTAL, wxDefaultValidator, 
                 AsciiToWx("slider_frequency"));
  
  wxStaticText *TimeLabel = 
    new wxStaticText(this, -1, AsciiToWx("Integration Time [us]"));
  SliderIntegrationTime_ = 
    new wxSlider(this, ID_SLIDER_INTEGRATIONTIME, 20000, 0, 80000, wxDefaultPosition, 
                 wxDefaultSize, wxSL_LABELS | wxSL_HORIZONTAL, wxDefaultValidator, 
                 AsciiToWx("slider_integrationtime"));

  QuitButton_ = 
    new wxButton(this, ID_BUTTON_QUIT, AsciiToWx("Quit"), wxDefaultPosition,
                 wxDefaultSize, 0, wxDefaultValidator, 
                 AsciiToWx("button"));

  

  Sizer->Add(FrequencyLabel, 0, wxCENTER|wxTOP|wxRIGHT|wxLEFT, 10);
  Sizer->Add(SliderFrequency_, 0, wxCENTER|wxALL|wxEXPAND, 10);
  Sizer->Add(TimeLabel, 0, wxCENTER|wxTOP|wxRIGHT|wxLEFT, 10);
  Sizer->Add(SliderIntegrationTime_, 0, wxCENTER|wxALL|wxEXPAND,10);
  Sizer->Add(QuitButton_, 0, wxCENTER|wxALL,10);
  SetSizer( Sizer );

  CreateStatusBar();
  SetStatusText( wxT("") );

  Timer_.SetOwner(this, ID_TIMER);  
  ShmName_ = "PMD_SHM_MIP.shm"; 
  cout <<"Using: "<<ShmName_<<endl;

  //here create the shm feeder
  pShmFeeder_ = new VideoShMFeederPMD(ShmName_);
    
  Cam_.OpenDevice();
  Cam_.PreGrab();
  Cam_.InitImage(GrabImage_);

  framecount_ = 0;

  wxCommandEvent cevt;
  wxScrollEvent evt;
  OnGetFrequency(cevt);
  OnGetIntegrationTime(cevt);
  Timer_.Start(20, true);
}

void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
  Cam_.PostGrab();
  delete pShmFeeder_;
  Close(TRUE);
}

void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
  wxMessageBox(wxT("This Application grabs images from a PMD cam\n and stores them in a shared memory\n named: PMD_SHM_MIP"),
               wxT("PMDCamToShm"), wxOK | wxICON_INFORMATION, this);
}

void MyFrame::OnFrequency(wxScrollEvent& event)
{
    int value = SliderFrequency_->GetValue();
    int frequency = value;
    if (Cam_.SetModulationFrequency(frequency)!=0){
      BEXCEPTION("error setting camera");
    }
    cout << "setting frequency: "<<frequency<<endl;
}

void MyFrame::OnIntegrationTime(wxScrollEvent& event)
{
    int value = SliderIntegrationTime_->GetValue();
    int time = value;
    if (Cam_.SetIntegrationTime(time)!=0){
      BEXCEPTION("error setting camera");
    }
    cout << "setting integration time: "<<time<<endl;
}

void MyFrame::OnGetFrequency(wxCommandEvent& event)
{
    unsigned int frequency = 0;
    if(Cam_.GetModulationFrequency(frequency)<=0) {
      BEXCEPTION("error getting camera");
    }
    SliderFrequency_->SetValue(frequency);
    cout << "frequency: "<<frequency<<endl;
}

void MyFrame::OnGetIntegrationTime(wxCommandEvent& event)
{
    
    unsigned int time = 0;
    if (Cam_.GetIntegrationTime(time)<=0){
      BEXCEPTION("error getting integration time");
    }
    SliderIntegrationTime_->SetValue(time);
    cout << "integration time: "<<time<<endl;
}

void MyFrame::OnTimer(wxTimerEvent& event)
{
  Cam_.GrabSingle(GrabImage_);
  Cam_.GrabSingleDepth(DepthImage_);
  Cam_.GrabSingleModCoeff(ModCoeffImage_);

  pShmFeeder_->ProcessImage(&GrabImage_,&DepthImage_,&ModCoeffImage_);
  cout <<framecount_++<<endl;
  Timer_.Start(20, true); // grab new images every 20 ms = resp 50 Hz
}
/** \endcond */