VideoSource_Controller_PMDZess.cpp

#ifdef WIN32
// workaround for wx 2.6.x redefiniton of _CRT_SECURE_NO_DEPRECATE 
// fixed in wx 2.7.2 
#  pragma warning(disable: 4005)
#endif

#include "VideoSource_Controller_PMDZess.hh"

#ifdef WIN32
#  include <Base/Common/getopt_W32.h>  
#endif

#include <iostream>
#include <Base/Image/ImageIO.hh>
#include <Image/Camera.hh>
#include <Gui/StringConv.hh>

using namespace std;
using namespace BIAS;

BEGIN_EVENT_TABLE(VideoSource_Controller_PMDZess, wxFrame)
  EVT_BUTTON(ID_HIDE,       VideoSource_Controller_PMDZess::OnHide)
  EVT_BUTTON(ID_MODULATIONFREQUENCY, VideoSource_Controller_PMDZess::OnModFreq)
  EVT_COMMAND_SCROLL(ID_GAIN2D,      VideoSource_Controller_PMDZess::OnGain2D)
  EVT_COMMAND_SCROLL(ID_SHUTTER2D,   VideoSource_Controller_PMDZess::OnShutter2D)
  EVT_COMMAND_SCROLL(ID_SHUTTER3D,   VideoSource_Controller_PMDZess::OnShutter3D)
  EVT_BUTTON(ID_BUTTON_UPDATE, VideoSource_Controller_PMDZess::OnUpdate)
END_EVENT_TABLE()




VideoSource_Controller_PMDZess::
VideoSource_Controller_PMDZess(VideoSource *cam, wxFrame *parent, const std::string& title)
  : VideoSource_Controller_Base(parent, -1, AsciiToWx(title)
            ,wxDefaultPosition,wxSize(500,500),wxSTAY_ON_TOP |wxCAPTION){
  
  Initialize();
  SetShutter2DRange();
  SetShutter3DRange();
  SetGain2DRange();
  Cam_ = dynamic_cast<VideoSource_PMDZess*>(cam);

}



VideoSource_Controller_PMDZess::
~VideoSource_Controller_PMDZess()
{

}

void VideoSource_Controller_PMDZess::
Initialize(){
  
  sliderBox_ShGa_Visible = true;    
  vBoxVisible = true;

  wxSize SlSize(100,200);
  wxSize BtSize(55,30);
  
  //Gain 2D Part
  wxBoxSizer *slGa = new wxBoxSizer(wxVERTICAL);
  wxStaticText *textGain = new wxStaticText(this,ID_TEXT, wxT("Gain 2D\n[dB]"));
  SliderGain2D = new wxSlider(this, ID_GAIN2D, 0, 0, 30000,
                            wxDefaultPosition,SlSize,
                            wxSL_VERTICAL | wxSL_LABELS | wxSL_RIGHT,
                            wxDefaultValidator, wxT("Gain2D"));

  SliderGain2D->Enable(true);
  slGa->Add(textGain,0,wxALL,2);  
  slGa->Add(SliderGain2D,0, wxALL,2);
  
  //Shutter 2D
  wxBoxSizer *slSh = new wxBoxSizer(wxVERTICAL);
  wxStaticText *textShutter = new wxStaticText(this,ID_TEXT, wxT("Shutter 2D\n[ms*100]"));
  SliderShutter2D = new wxSlider(this, ID_SHUTTER2D, 20, 0, 80000,
                               wxDefaultPosition,SlSize,
                               wxSL_VERTICAL | wxSL_LABELS | wxSL_RIGHT,
                               wxDefaultValidator, wxT("Shutter2D"));
  
  SliderShutter2D->Enable(true);
  slSh->Add(textShutter,0,wxALL,2);  
  slSh->Add(SliderShutter2D,0,wxALL, 2);
  

 //Shutter 3D
  wxBoxSizer *slSh3D = new wxBoxSizer(wxVERTICAL);
  wxStaticText *textShutter3D = new wxStaticText(this,ID_TEXT, wxT("Shutter 3D\n[ms*100]"));
  SliderShutter3D = new wxSlider(this, ID_SHUTTER3D, 20, 0, 80000,
                               wxDefaultPosition,SlSize,
                               wxSL_VERTICAL | wxSL_LABELS | wxSL_RIGHT,
                               wxDefaultValidator, wxT("Shutter3D"));
  
  SliderShutter3D->Enable(true);
  slSh3D->Add(textShutter3D,0,wxALL,2);  
  slSh3D->Add(SliderShutter3D,0,wxALL, 2);
 
  //ModulationFrequency
  wxBoxSizer *boxModFreq = new wxBoxSizer(wxVERTICAL);
  wxStaticText *textModFreq = new wxStaticText(this,ID_TEXT, wxT("Modulation\nFrequency\n[MHz]"));
  modulationFreqText = new wxTextCtrl(this,ID_MODULATION_TEXT,"20.0",
                wxDefaultPosition,wxSize(50,20));
  setModFreqButton  = new wxButton(this, ID_MODULATIONFREQUENCY, wxT("SetModFreq"),
                wxDefaultPosition,wxSize(100,50));

  boxModFreq->Add(textModFreq,0,wxALL|wxCENTER,2);
  boxModFreq->Add(modulationFreqText,0,wxALL|wxCENTER,2);
  boxModFreq->Add(setModFreqButton,0,wxALL|wxCENTER,2);

  wxBoxSizer *sl = new wxBoxSizer(wxHORIZONTAL);
  sl->Add(slGa,0,wxALL, 2);
  sl->Add(slSh,0,wxALL,2); 
  sl->Add(slSh3D,0,wxALL,2); 
  sl->Add(boxModFreq,0,wxALL,2); 

  showButton = new wxButton(this, ID_HIDE, wxT("Hide"),
                wxDefaultPosition,BtSize);
  update_Button = new wxButton(this, ID_BUTTON_UPDATE, 
                   wxT("UPDATE"),wxDefaultPosition,BtSize);

  vBox = new wxBoxSizer(wxHORIZONTAL);
  vBox->Add(showButton,0,wxALIGN_LEFT   | wxBOTTOM);
  vBox->Add(update_Button, 0, wxALIGN_RIGHT   | wxBOTTOM); 

  
  sliderBox_ShGa = new wxBoxSizer(wxVERTICAL);
  sliderBox_ShGa->Add(sl,0,wxALL, 2);
  sliderBox_ShGa->Add(vBox,0,wxALL,2);

  vBox->SetSizeHints(this);
  this->SetSizer(sliderBox_ShGa);
  SetAutoLayout(true);
  Layout();
  Fit();
  wxCommandEvent fakeEvent;
 // OnUpdate(fakeEvent);
  Show(TRUE);
}

void VideoSource_Controller_PMDZess::
SetVideoSource(BIAS::VideoSource *cam){
  Cam_ = cam;
}


void VideoSource_Controller_PMDZess::
OnHide(wxCommandEvent& event){
  Show(false);
}

void VideoSource_Controller_PMDZess::
OnClose(wxCloseEvent& event) {

  Show(false);
}

void VideoSource_Controller_PMDZess::
OnModFreq(wxCommandEvent& event) {
  wxString modFreq = modulationFreqText->GetValue();
  double current =0.0;
  int res = modFreq.ToDouble(&current);
  if (res >=0 && Cam_!= NULL) {
    //Cam_->SetModulationFrequency(rint(current));      
      cout<<"Setting ModulationFreq "<<current<<endl;
  }
}

void VideoSource_Controller_PMDZess::
OnGain2D(wxScrollEvent& event) {
  double value = SliderGain2D->GetValue();
  if (Cam_!= NULL) {
    //Cam_->SetGain2D(value);       
    BIASERR("Not working");
  }
    cout<<"Setting Gain 2D "<<value/100.0f<<endl;
}

void VideoSource_Controller_PMDZess::
OnShutter2D(wxScrollEvent& event) {
  double value = SliderShutter2D->GetValue();
  if (Cam_!= NULL) {
    Cam_->SetShutter2D(value/100.0);        
  }
}

void VideoSource_Controller_PMDZess::
OnShutter3D(wxScrollEvent& event) {
  double value = SliderShutter3D->GetValue();
  if (Cam_!= NULL) {
    Cam_->SetShutter3D(value/100.0);        
  }
}


void VideoSource_Controller_PMDZess::
Update() {
  if (Cam_!= NULL) {
    float currentShutter2D =0.0;
        currentShutter2D = Cam_->GetShutter2D();
    SliderShutter2D->SetValue(int(currentShutter2D*100.0));
   
    float currentShutter3D= Cam_->GetShutter3D();
    SliderShutter3D->SetValue(int(currentShutter3D*100.0f));
    
    float currentGain2D = Cam_->GetGain2D();
    SliderGain2D->SetValue(int(currentGain2D));

    int modFreq = Cam_->GetModulationFrequency();
    if(modFreq <= 0)
       BIASERR("Camera returned wrong Modulation Frequency");
    wxString text;
    text.Printf(wxT("%d"),modFreq );
    modulationFreqText->SetValue(text);
  }
}

void VideoSource_Controller_PMDZess::
OnUpdate(wxCommandEvent& event) {
  Update();
}

void  VideoSource_Controller_PMDZess::
SetShutter2DRange(unsigned int min,unsigned int max)
{
  SliderShutter2D->SetRange(min,max);

}

void  VideoSource_Controller_PMDZess::
SetShutter3DRange(unsigned int min,unsigned int max)
{
  SliderShutter3D->SetRange(min,max);

}

void  VideoSource_Controller_PMDZess::
SetGain2DRange(unsigned int min,unsigned int max)
{
 SliderGain2D->SetRange(min,max);
}