VideoSource_Controller.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 first, avoid macro collision
#include <Gui/StringConv.hh>

#include "VideoSource_Controller.hh"
#include <Base/Common/getopt_W32.h>

#if defined(WIN32) && defined(HAVE_TRIGGER_CLASSES)
#  include "TriggerIOControl.h"
#endif

#ifdef BIAS_HAVE_DCAM
#  include <VideoSource/VideoSource_DCAM.hh>
#endif

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

using namespace std;
using namespace BIAS;

BEGIN_EVENT_TABLE(VideoSource_Controller, wxFrame)
  EVT_KEY_UP(VideoSource_Controller::OnKeyUp)
  EVT_CLOSE(VideoSource_Controller::OnClose)
  EVT_BUTTON(ID_HIDE,       VideoSource_Controller::OnHide)
  EVT_COMMAND_SCROLL(ID_GAIN,      VideoSource_Controller::OnGain)
  EVT_COMMAND_SCROLL(ID_SHUTTER,   VideoSource_Controller::OnShutter)
  EVT_COMMAND_SCROLL(ID_WBMANUAL,   VideoSource_Controller::OnWhiteBalanceManual)
  EVT_COMMAND_SCROLL(ID_BRIGHTNESS,      VideoSource_Controller::OnBrightness)
  EVT_COMMAND_SCROLL(ID_CONTRAST,   VideoSource_Controller::OnContrast)
  EVT_BUTTON(ID_BUTTON_AUTO_SHUTTER, VideoSource_Controller::OnAuto_Shutter)
  EVT_BUTTON(ID_BUTTON_AUTO_BRIGHTNESS, VideoSource_Controller::OnAuto_Brightness)
  EVT_BUTTON(ID_BUTTON_WHITEBALANCE, VideoSource_Controller::OnWhiteBalance)
  EVT_BUTTON(ID_BUTTON_AUTO_GAIN, VideoSource_Controller::OnAuto_Gain)
  EVT_BUTTON(ID_BUTTON_UPDATE, VideoSource_Controller::OnUpdate)
END_EVENT_TABLE()


VideoSource_Controller::
VideoSource_Controller(VideoSource *cam, 
                       wxWindow *parent,
                       const string &title,
                       double minShutter, double maxShutter,
                       double minGain,double maxGain,
                       double minContrast,double maxContrast,
                       double minBrightness,double maxBrightness)
: VideoSource_Controller_Base(parent, wxID_ANY, (AsciiToWx(title.c_str())),
        wxDefaultPosition, wxSize(400,500), wxSTAY_ON_TOP|wxCAPTION | wxRESIZE_BORDER)
        {

    Cam_ = cam;

  minShutter_=minShutter;
  maxShutter_=maxShutter;
  minGain_= minGain;
  maxGain_= maxGain;
  minContrast_= minContrast;
  maxContrast_= maxContrast;
  minBrightness_= minBrightness;
  maxBrightness_= maxBrightness;

  Initialize_();

}



VideoSource_Controller::
~VideoSource_Controller()
{}

void VideoSource_Controller::
Initialize_()
{      
  if(minShutter_ == -1 && maxShutter_ == -1)
    Cam_->GetShutterRange(minShutter_, maxShutter_);

  if(minGain_ == -1 && maxGain_ == -1) 
    Cam_->GetGainRange(minGain_, maxGain_);

  if(minContrast_ == -1 && maxContrast_ == -1)
    Cam_->GetContrastRange(minContrast_, maxContrast_);
  
  if(minBrightness_ == -1 && maxBrightness_ == -1)
    Cam_->GetBrightnessRange(minBrightness_, maxBrightness_);

  
  SliderGain = NULL;
  SliderShutter= NULL;
  SliderWbRed= NULL;
  SliderWbBlue= NULL;
  SliderBrightness= NULL;
  SliderContrast= NULL;
  showButton = NULL;
  whiteBalanceButton = NULL;
  auto_sh_Button = NULL;
  auto_ga_Button = NULL;
  auto_br_Button = NULL;
  auto_co_Button = NULL;
  update_Button = NULL;
  sliderBox_ShGa = NULL;

  LetterAscii_ = WXK_F4;
  Ctrl_ = false;
  Shift_ = false;
  Alt_ = true;
  //Shut the Automode DOWN
  auto_gain = false;
  auto_shutter = false;
  auto_brightness = false;
  sliderBox_ShGa_Visible = true;
  vBoxVisible = true;
  
  SetShutterRange((unsigned)minShutter_,(unsigned)maxShutter_);
  SetGainRange((unsigned)minGain_,(unsigned)maxGain_);

  wxSize SlSize(200,35);
  wxSize BtSize(60,30);
 
  // the sizer
  wxFlexGridSizer* itemFlexGridSizer = new wxFlexGridSizer(11, 3, 0, 0);
  this->SetSizer(itemFlexGridSizer);

  if (Cam_->HasControlWhiteBalance()){
  ////////////// White Balance 
     whiteBalanceButton = new wxButton(this, ID_BUTTON_WHITEBALANCE, 
       wxT("Auto Software\nWhite Balance"),wxDefaultPosition,wxSize(120,60));

     wxStaticText *textWbr = new wxStaticText(this,ID_TEXT, wxT("red gain"));
     SliderWbRed = new wxSlider(this, ID_WBMANUAL, 50, 0, 100,
       wxDefaultPosition,SlSize,
       wxSL_HORIZONTAL | wxSL_LABELS | wxSL_TOP |wxSL_SELRANGE,
       wxDefaultValidator, wxT("RedGain"));

     SliderWbRed->Enable(true);
     //small sizer
     wxBoxSizer *slWbr = new wxBoxSizer(wxVERTICAL);
     slWbr->Add(textWbr,0,wxALL,2);
     slWbr->Add(SliderWbRed,0,wxALL, 2);


     wxStaticText *textWbb = new wxStaticText(this,ID_TEXT, wxT("blue gain"));
     SliderWbBlue = new wxSlider(this, ID_WBMANUAL, 50, 0, 100,
       wxDefaultPosition,SlSize,
       wxSL_HORIZONTAL | wxSL_LABELS | wxSL_TOP |wxSL_SELRANGE,
       wxDefaultValidator, wxT("BlueGain"));

     SliderWbBlue->Enable(true);
     //small sizers
     wxBoxSizer *slWbb = new wxBoxSizer(wxVERTICAL);
     slWbb->Add(textWbb,0,wxALL,2);
     slWbb->Add(SliderWbBlue,0,wxALL, 2);

     //add to sizer
     itemFlexGridSizer->Add(whiteBalanceButton,0,
                         wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
     itemFlexGridSizer->Add(slWbr,0,
                         wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
     itemFlexGridSizer->Add(slWbb,0,
                             wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
   }//end Cam_->HasControlWhiteBalance()
  /////////////////////////// Brightness //////////////////////
  if (Cam_->HasControlBrightness()){
    wxStaticText *textBr = new wxStaticText(this,ID_TEXT, wxT("Brightness"));
    SliderBrightness = new wxSlider(this, ID_BRIGHTNESS, 157, 0, 255,
                    wxDefaultPosition,SlSize,
                    wxSL_HORIZONTAL | wxSL_LABELS | wxSL_TOP |wxSL_SELRANGE,
                    wxDefaultValidator, wxT("Brightness"));

    auto_br_Button = new wxButton(this, ID_BUTTON_AUTO_BRIGHTNESS, 
                  wxT("Manual"),wxDefaultPosition,BtSize);

    SliderBrightness->Enable(true);

    itemFlexGridSizer->Add(textBr,0,
        wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
    itemFlexGridSizer->Add(SliderBrightness,0,
            wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
    itemFlexGridSizer->Add(auto_br_Button,0,
                wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
  }
  ///////////////////////////// Gain /////////////////////
  if (Cam_->HasControlGain()){   
    wxStaticText *textGa = new wxStaticText(this,ID_TEXT, wxT("Gain [dB]"));
    SliderGain = new wxSlider(this, ID_GAIN, int((maxGain_-minGain_)/2.0), (int)minGain_, (int)maxGain_,
                  wxDefaultPosition,SlSize,
                  wxSL_HORIZONTAL | wxSL_LABELS | wxSL_TOP |wxSL_SELRANGE,
                  wxDefaultValidator, wxT("Gain"));

    auto_ga_Button = new wxButton(this, ID_BUTTON_AUTO_GAIN, 
                  wxT("Manual"),wxDefaultPosition,BtSize);

    SliderGain->Enable(true);

    itemFlexGridSizer->Add(textGa,0,
            wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
    itemFlexGridSizer->Add(SliderGain,0,
            wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
    itemFlexGridSizer->Add(auto_ga_Button,0,
            wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

  }
  ///////////////////////////// Contrast /////////////////////
  if (Cam_->HasControlContrast()){
    wxStaticText *textContrast = new wxStaticText(this,ID_TEXT, wxT("Contrast"));
    SliderContrast = new wxSlider(this, ID_CONTRAST, int((maxContrast_ - minContrast_)/2.0), 
          (int)minContrast_, (int)maxContrast_,
                  wxDefaultPosition,SlSize,
                  wxSL_HORIZONTAL | wxSL_LABELS | wxSL_TOP |wxSL_SELRANGE,
                  wxDefaultValidator, wxT("Gain"));

    auto_co_Button = new wxButton(this, ID_BUTTON_AUTO_CONTRAST, 
                  wxT("Manual"),wxDefaultPosition,BtSize);

    SliderContrast->Enable(true);

    itemFlexGridSizer->Add(textContrast,0,
            wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
    itemFlexGridSizer->Add(SliderContrast,0,
            wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
    itemFlexGridSizer->Add(auto_co_Button,0,
            wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

  }
  /////////////////////////////// Shutter ///////////////////
  if (Cam_->HasControlShutter()){
    wxStaticText *textShutter = new wxStaticText(this,ID_TEXT, wxT("Shutter [ms]"));
    SliderShutter = new wxSlider(this, ID_SHUTTER, int((maxShutter_-minShutter_)/2.0), 
      (int)minShutter_, (int)maxShutter_,
                 wxDefaultPosition,SlSize,
                 wxSL_HORIZONTAL | wxSL_LABELS | wxSL_TOP  |wxSL_SELRANGE,
                 wxDefaultValidator, wxT("Shutter"));
  
    auto_sh_Button = new wxButton(this, ID_BUTTON_AUTO_SHUTTER, 
                  wxT("Manual"),wxDefaultPosition,BtSize);

    SliderShutter->Enable(true);
    itemFlexGridSizer->Add(textShutter,0,
            wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
    itemFlexGridSizer->Add(SliderShutter,0,
            wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
    itemFlexGridSizer->Add(auto_sh_Button,0,
            wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
  }
  //////////////////////////////////////////////////

  
  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);

  itemFlexGridSizer->Add(vBox,0,
            wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

  SetAutoLayout(true);
  Layout();
  Fit();
  wxCommandEvent fakeEvent;
  OnUpdate(fakeEvent);
  Show(true);
}

bool VideoSource_Controller::
Show(bool show)
{
  bool res = wxWindow::Show(show);
  if (show) {
    /// wait a moment to let wx sort its key and focus events
    wxMilliSleep(200);
    //SliderGain->SetFocus();
    Raise();
  }
  return res;

}

void VideoSource_Controller::
SetCloseShortcut(const int &asciiCode, 
         bool ctrl, bool shift, bool alt)
{
  LetterAscii_ = asciiCode;
  Ctrl_ = ctrl;
  Shift_ = shift;
  Alt_ = alt;
}

bool VideoSource_Controller::
AreModifiersCorrect_(const wxKeyEvent &event)
{
  return ( (event.ShiftDown() == Shift_)
       && (event.ControlDown() == Ctrl_)
       && (event.AltDown() == Alt_) );
}

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

void VideoSource_Controller::
OnKeyUp(wxKeyEvent& event)
{
  int keyCode = event.GetKeyCode();

  /// hide window on shortcut 
  if ( AreModifiersCorrect_(event) ) {
    if ( keyCode == LetterAscii_ ) {
      Close();
    }
  }
  else {
    event.Skip();
  }
}

void VideoSource_Controller::
OnHide(wxCommandEvent& event)
{
  Close();
}

void VideoSource_Controller::
OnClose(wxCloseEvent& event) 
{
  Show(false);
  wxWindow* parent = GetParent();
  if ( parent != NULL ) parent->Refresh();
}

void VideoSource_Controller::
OnGain(wxScrollEvent& event) 
{
  float value = (float)SliderGain->GetValue();
  if(Cam_ != NULL){
    auto_off(1);
    //cout<<"Set Gain:"<<value<<endl;
        Cam_->SetGain(value);
    //cout<<"Get Gain:"<<Cam_->GetGain()<<endl;
  }
}

void VideoSource_Controller::
OnShutter(wxScrollEvent& event) 
{ 
  if(Cam_ != NULL){
      auto_off(0);
    float value = (float)SliderShutter->GetValue();
    // why /10000?
    /*
    cout<<"Set Shutter:"<<value/10000.0<<endl;
    int ret = Cam_->SetShutter(value/10000.0f);
    if(ret <0) BIASERR("Setting Shutter failed!");
    cout<<"Get Shutter:"<<Cam_->GetShutter()*10000.0<<endl;
    */
    cout<<"Set Shutter:"<<value<<endl;
    int ret = Cam_->SetShutter(value);
    if(ret <0) BIASERR("Setting Shutter failed!");
    cout<<"Get Shutter:"<<Cam_->GetShutter()<<endl;
  }
}

void VideoSource_Controller::
OnWhiteBalanceManual(wxScrollEvent& event) 
{
  float vred = (float)(SliderWbRed->GetValue() / 100.0 - 0.5);
  float vblue = (float)(SliderWbBlue->GetValue() / 100.0 - 0.5);
  if(Cam_ != NULL){
    Cam_->SetWhiteBalance(vred,vblue);
  }
  std::cout << vred << std::endl;
}


void VideoSource_Controller::
OnWhiteBalance(wxCommandEvent& event) 
{
  if(Cam_!=NULL)
    Cam_->SoftwareWhiteBalance();
}

void VideoSource_Controller::
OnAuto_Shutter(wxCommandEvent& event) 
{
  if(!auto_shutter) {
    auto_on(0);
  }
  else {
    auto_off(0);
  }
}

void VideoSource_Controller::
OnAuto_Gain(wxCommandEvent& event) 
{
  if(!auto_gain) {
    auto_on(1);
  }
  else {
    auto_off(1);
  }
}

void VideoSource_Controller::
OnAuto_Brightness(wxCommandEvent& event) 
{
  if(!auto_brightness) {
    auto_on(2);
  }
  else {
    auto_off(2);
  }
}


void VideoSource_Controller::
OnBrightness(wxScrollEvent& event)
{
  if(Cam_ != NULL){
    auto_off(2);
    float value = (float)SliderBrightness->GetValue();
    //cout<<"Brightness:"<<value<<endl;
    Cam_->SetBrightness(value); 
  }
}

void VideoSource_Controller::
OnContrast(wxScrollEvent& event)
{
  if(Cam_ != NULL){
    //    auto_off(0);
    cout<<"SetContrast:"<<SliderContrast->GetValue()<<endl;    
    Cam_->SetContrast((float)SliderContrast->GetValue()); 
    cout<<"GetContrast:"<<Cam_->GetContrast()<<endl;
  }
}

void VideoSource_Controller::
Update() 
{
  if (Cam_!= NULL) {
    float current =0.0;
    if (Cam_->HasControlShutter()){
      current= (float)(Cam_->GetShutter()*1000.0);
      if(current >=0)    
          SliderShutter->SetValue(int(current));
      bool autoon = Cam_->GetAutoShutter();
      if (autoon)  auto_sh_Button->SetLabel(wxT("Auto"));
      else  auto_sh_Button->SetLabel(wxT("Manual"));
    }
    if (Cam_->HasControlGain()){
      current = Cam_->GetGain();
      //cout<<"GetGain:"<<current<<endl;
      if (current >=0) 
          SliderGain->SetValue(int(current));
      bool autoon = Cam_->GetAutoGain();
      if (autoon) auto_ga_Button->SetLabel(wxT("Auto"));
      else  auto_ga_Button->SetLabel(wxT("Manual"));
    }
    if (Cam_->HasControlContrast()){
      current = Cam_->GetContrast();
      if (current >=0) 
          SliderContrast->SetValue(int(current));
    }
    if (Cam_->HasControlBrightness()){
      current = Cam_->GetBrightness();
      if (current >=0) 
          SliderBrightness->SetValue(int(current));
      bool autoon = Cam_->GetAutoBrightness();
      if (autoon) auto_br_Button->SetLabel(wxT("Auto"));
      else  auto_br_Button->SetLabel(wxT("Manual"));
    }
  }
}

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

void VideoSource_Controller::
auto_on(int param) 
{
  //SHUTTER
  if(param == 0){
    auto_shutter = true;
    Cam_->SetAutoShutter(true);
    auto_sh_Button->SetLabel(wxT("Auto"));
  }
  //GAIN
  else if(param == 1){
    auto_gain = true;
    Cam_->SetAutoGain(true);
    auto_ga_Button->SetLabel(wxT("Auto"));
  }
  //Brightness
  else if(param == 2){
    auto_brightness = true;
    Cam_->SetAutoBrightness(true);
    auto_br_Button->SetLabel(wxT("Auto"));
  }
}

void VideoSource_Controller::
auto_off(int param) 
{
  //SHUTTER
  if(param == 0){
    auto_shutter = false;
    Cam_->SetAutoShutter(false);
    auto_sh_Button->SetLabel(wxT("Manual"));
  }
  //GAIN
  else if(param == 1){
    auto_gain = false;
    Cam_->SetAutoGain(false);
    auto_ga_Button->SetLabel(wxT("Manual"));
  }
  //Brightness
  else if(param == 2){
    auto_brightness = false;
    Cam_->SetAutoBrightness(false);
    auto_br_Button->SetLabel(wxT("Manual"));
  }
}

void  VideoSource_Controller::
SetShutterRange(unsigned int min,unsigned int max)
{
  if (Cam_->HasControlShutter() && SliderShutter != NULL)
    SliderShutter->SetRange(min,max);
}

void  VideoSource_Controller::
SetGainRange(unsigned int min,unsigned int max)
{
  if (Cam_->HasControlGain() && SliderGain != NULL)
    SliderGain->SetRange(min,max);
}

void VideoSource_Controller::
SetBrightnessRange(unsigned int min,unsigned int max)
{
  if (Cam_->HasControlBrightness()&& SliderShutter != NULL)
    SliderBrightness->SetRange(min,max);
}
 
void VideoSource_Controller::
SetContrastRange(unsigned int min,unsigned int max)
{
  if (Cam_->HasControlContrast() && SliderContrast!= NULL)
      SliderContrast->SetRange(min,max);
}