ExampleMixtureOfGaussians.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 "ExampleMixtureOfGaussians.hh"
#include <Base/Image/ImageIO.hh>
#include <Base/Common/FileHandling.hh>


using namespace BIAS;
using namespace std;

bool ExampleMixtureOfGaussians::OnInit()
{
  // Open console for windows
  ConsoleRedirectIO();

  
  // create main frame
  ExampleMixtureOfGaussiansFrame *mainFrame;
  mainFrame = new ExampleMixtureOfGaussiansFrame(AsciiToWx("Mixture of Gaussians"), wxPoint(50,50),
                                 wxSize(400,340));
  
  // necessary for high resolution on small monitors (hackish...)
  mainFrame->SetSizeHints(640,480,1800,1600);

  // initialize cameras and try to open them   
  std::vector<string> files,filesFL; 
  if(argc > 1){    
    Param::ParseListFile(WxToAscii(argv[1]),files);
    mainFrame->InitCamera(&files);
    if(argc > 2){
      Param::ParseListFile(WxToAscii(argv[2]),filesFL);
      mainFrame->InitCameraFL(&filesFL);      
    }
  }   
  else
    mainFrame->InitCamera();

  mainFrame->CreateMenu();
  
  // create main windows
  mainFrame->Show(true);
  SetTopWindow(mainFrame);
  
  return true;
}

IMPLEMENT_APP(ExampleMixtureOfGaussians) 



BEGIN_EVENT_TABLE(ExampleMixtureOfGaussiansFrame, wxFrame)
  EVT_MENU      (ID_Quit,               ExampleMixtureOfGaussiansFrame::OnQuit)
  EVT_MENU      (ID_Grab,               ExampleMixtureOfGaussiansFrame::OnGrab)
  EVT_MENU      (ID_GrabContinuous,     ExampleMixtureOfGaussiansFrame::OnGrabContinuous) 
  EVT_MENU      (ID_Show1,              ExampleMixtureOfGaussiansFrame::OnShowImage1) 
  EVT_MENU      (ID_Show2,              ExampleMixtureOfGaussiansFrame::OnShowImage2) 
  EVT_MENU      (ID_Show3,              ExampleMixtureOfGaussiansFrame::OnShowImage3) 
  EVT_MENU      (ID_Show4,              ExampleMixtureOfGaussiansFrame::OnShowImage4) 
  EVT_MENU      (ID_Show5,              ExampleMixtureOfGaussiansFrame::OnShowImage5) 
  EVT_MENU      (ID_Show6,              ExampleMixtureOfGaussiansFrame::OnShowImage6) 
  EVT_MENU      (ID_Show7,              ExampleMixtureOfGaussiansFrame::OnShowImage7) 
  EVT_MENU      (ID_Show8,              ExampleMixtureOfGaussiansFrame::OnShowImage8)
  EVT_MENU      (ID_Show9,              ExampleMixtureOfGaussiansFrame::OnShowImage9)   
  EVT_MENU      (ID_Show_FL,            ExampleMixtureOfGaussiansFrame::OnShowFL)   
  EVT_MENU      (ID_Controller,         ExampleMixtureOfGaussiansFrame::OnShowController)
  EVT_TIMER     (ID_Timer,              ExampleMixtureOfGaussiansFrame::OnTimer)
  
  EVT_KEY_DOWN  (ExampleMixtureOfGaussiansFrame::OnKey) 
END_EVENT_TABLE()


ExampleMixtureOfGaussiansFrame::
ExampleMixtureOfGaussiansFrame(const wxString& title, 
        const wxPoint& pos, const wxSize& size)
    : wxFrame(NULL, -1, title, pos, size)
{

  // all parameters for MOG here, change if desired
  mog_ = new MixtureOfGaussians<unsigned char>(2, 5, .2f,MOG_NRGB);
  mog_->InitWeights(100000, 10, 2.9f );
  mog_->SetSmoothing(false);
  mogFL_ = new MixtureOfGaussians<float>(5, 2, .2f,MOG_RGB);
  mogFL_->InitWeights(1000000, 0, 4.9f );
  mogFL_->SetSmoothing(false);
  CameraFL_= NULL;
  Camera_= NULL;
  bShowImageFL_=false;
  roi_.UL[0] = 0;
  roi_.UL[1] = 0;
  roi_.LR[0] = 00;
  roi_.LR[1] = 00;
  downsample_ = false;
    
  // create status bar and add status text
  CreateStatusBar(3);
  wxString text;
  text.Printf(wxT("size: %4dx%4d"),0, 0);
  SetStatusText(text, 2);
  
  // init image canvas
  IC_ = new ImageCanvas(this,GetStatusBar(), 0,-1,wxDefaultPosition,                          
                        wxSize(1024,768));

  // add image canvas to main window
  wxBoxSizer *vbox = new wxBoxSizer(wxVERTICAL);
  vbox->Add(IC_,1,  wxEXPAND |wxALL |wxFIXED_MINSIZE , 5);
  vbox->SetMinSize(640,480);
  SetSizer(vbox);
  SetAutoLayout(true);
  Layout();

  // init and start timer
  Timer_.SetOwner(this, ID_Timer);  
  Timer_.Start(50,true);
  StopWatch_.Start();  
  ShowImage_ = &CamImg_;
  dCurImage_ = 0;
  
  guardimagemutex = new pthread_mutex_t;
  guarddiffimagemutex = new pthread_mutex_t;
  pthread_mutex_init(guardimagemutex, NULL);
  pthread_mutex_init(guarddiffimagemutex, NULL);
  barrier = new pthread_barrier_t;
  pthread_barrier_init(barrier, NULL, 2);

}

void ExampleMixtureOfGaussiansFrame::InitCamera(std::vector<std::string>* fileNames) {
  if(fileNames != NULL && fileNames->size() > 0){
    Camera_ = new VideoSource_Disk;
    // std::vector<string> files; 
    // Param::ParseListFile("/data/projects/Dyn3D/DiplomFalkoKellner/MOG-Pictures-Fisheye/MOGin.lst",files);
    // Param::ParseListFile("/data/projects/Dyn3D/MixedReality/SIGGRAPH/Scenes2/Scene06/lists/Scene06-Tex-undist-sync.lst",files);

    Camera_->OpenDevice(*fileNames);
    ((VideoSource_Disk*)Camera_)->SetLoopMode(true);  
  }
  else{
    Camera_ = new VideoSource_DCAM();
    dynamic_cast<VideoSource_DCAM*>(Camera_)->SetFirewireB(false);
    if(Camera_->OpenDevice() != 0){
      delete Camera_; 
      BIASERR("No DCAM present!");
      return;
    }
  }

  Camera_->InitImage(CamImgOrg_);
  CamImgOrgRGB_.Init(CamImgOrg_.GetWidth(), CamImgOrg_.GetHeight(),3);
  Camera_->PreGrab();
  
  pthread_create(&grabthread, NULL, grabImages_, this);
  pthread_create(&processthread, NULL, processImages_, this);

}

void ExampleMixtureOfGaussiansFrame::InitCameraFL(std::vector<std::string>* fileNames) {
  if(fileNames != NULL && fileNames->size() > 0){
    CameraFL_ = new VideoSource_Disk;
    CameraFL_->OpenDevice(*fileNames);
    ((VideoSource_Disk*)CameraFL_)->SetLoopMode(true);  
  }
  else{
    BIASERR("No way!");
  }

  CameraFL_->PreGrab();
}

void ExampleMixtureOfGaussiansFrame::CreateMenu() {
  // create file menu
  wxMenu *menuFile = new wxMenu;
  menuFile->Append(ID_Quit, wxT("E&xit") );

  // create menu for showing different cameras
  wxMenu *menuShow = new wxMenu;
  menuShow->Append(ID_Show1, wxT("Original Image") );
  menuShow->Append(ID_Show2, wxT("Normalized Image") );
  menuShow->Append(ID_Show3, wxT("Weight Image") );
  menuShow->Append(ID_Show4, wxT("Difference Image") );
  menuShow->Append(ID_Show5, wxT("Visualization") );
  menuShow->AppendSeparator();
  if(CameraFL_ != NULL){
    pCheckItemFL_=
      menuShow->AppendCheckItem(ID_Show_FL ,
                                wxT("&Show float images"),
                                wxT(""));
    pCheckItemFL_->Check(false);
  }
  menuShow->Append(ID_Controller, wxT("Controller") );  
  
  // add menues to menu bar
  wxMenuBar *menuBar = new wxMenuBar;
  menuBar->Append(menuFile, wxT("&File"));
  menuBar->Append(menuShow, wxT("&Show"));
  SetMenuBar(menuBar);

  // fit all components to size of window
  Fit();
}

void ExampleMixtureOfGaussiansFrame::OnQuit(wxCommandEvent& event) {
  Timer_.Stop();
  Close(true);
}

void ExampleMixtureOfGaussiansFrame::OnGrab(wxCommandEvent& event) {}
void ExampleMixtureOfGaussiansFrame::OnGrabContinuous(wxCommandEvent& event) {} 
void ExampleMixtureOfGaussiansFrame::OnShowImage1(wxCommandEvent& event) {
  dCurImage_ = 0;
}
void ExampleMixtureOfGaussiansFrame::OnShowImage2(wxCommandEvent& event) {
  dCurImage_ = 1;
}
void ExampleMixtureOfGaussiansFrame::OnShowImage3(wxCommandEvent& event) {
  dCurImage_ = 2;
} 
void ExampleMixtureOfGaussiansFrame::OnShowImage4(wxCommandEvent& event) {
  dCurImage_ = 3;
}
void ExampleMixtureOfGaussiansFrame::OnShowImage5(wxCommandEvent& event) {
  dCurImage_ = 4;
}

void ExampleMixtureOfGaussiansFrame::OnShowFL(wxCommandEvent& event) {
  bShowImageFL_ = event.IsChecked();
}

void ExampleMixtureOfGaussiansFrame::OnShowImage6(wxCommandEvent& event) {}
void ExampleMixtureOfGaussiansFrame::OnShowImage7(wxCommandEvent& event) {}
void ExampleMixtureOfGaussiansFrame::OnShowImage8(wxCommandEvent& event) {}
void ExampleMixtureOfGaussiansFrame::OnShowImage9(wxCommandEvent& event) {}     
void ExampleMixtureOfGaussiansFrame::OnShowController(wxCommandEvent& event) {} 

void* ExampleMixtureOfGaussiansFrame::grabImages_(void *thisvisu) {
  ExampleMixtureOfGaussiansFrame *obj = static_cast<ExampleMixtureOfGaussiansFrame*>(thisvisu);
  Image<unsigned char> bufferImage(obj->CamImgOrg_.GetWidth(), obj->CamImgOrg_.GetHeight(), 3);
  do {
    obj->Camera_->GrabSingle(obj->CamImgOrg_);
    if (obj->CamImgOrg_.GetColorModel() != ImageBase::CM_RGB) {
      //obj->CamImgOrg_.SetColorModel(ImageBase::CM_Bayer_RGGB);
      ImageConvert::ToRGB(obj->CamImgOrg_, bufferImage);
    } else {
      bufferImage = obj->CamImgOrg_;
    }
    pthread_mutex_lock(obj->guardimagemutex);
    obj->CamImgOrgRGB_.CopyIn_NoInit(bufferImage.GetImageData());
    pthread_mutex_unlock(obj->guardimagemutex);
    pthread_barrier_wait(obj->barrier);
  } while (!obj->stopRequest);
  return NULL;
}

void* ExampleMixtureOfGaussiansFrame::processImages_(void *thisvisu) {
  ExampleMixtureOfGaussiansFrame *obj = static_cast<ExampleMixtureOfGaussiansFrame*>(thisvisu);
  Image<unsigned char> bufferImage(obj->CamImgOrg_.GetWidth(), obj->CamImgOrg_.GetHeight(), 3);;
  do {
    pthread_barrier_wait(obj->barrier);
    pthread_mutex_lock(obj->guardimagemutex);
    bufferImage.CopyIn_NoInit(obj->CamImgOrgRGB_.GetImageData());
    pthread_mutex_unlock(obj->guardimagemutex);
    pthread_mutex_lock(obj->guarddiffimagemutex);
    bufferImage.SetROI(5,5,bufferImage.GetWidth()-5,bufferImage.GetHeight()-5);
    obj->mog_->Apply(bufferImage);
    pthread_mutex_unlock(obj->guarddiffimagemutex);
  } while (!obj->stopRequest);
  return NULL;
}


void ExampleMixtureOfGaussiansFrame::OnTimer(wxTimerEvent& event) {
  // update frames per second and restart timer and counters
  Timer_.Stop();
  StopWatch_.Stop();
  double fps = 1000000.0 / StopWatch_.GetRealTime();
  StopWatch_.Reset();
  StopWatch_.Start();
  FrameCounter_++;
  wxString text;
  text.Printf(wxT("%05d %2.1f fps "),FrameCounter_, fps);
  SetStatusText(text, 2);
  
  pthread_mutex_lock(guardimagemutex);
  CamImg_ = CamImgOrgRGB_;
  pthread_mutex_unlock(guardimagemutex);

  unsigned int w,h;
  // get width and height from image
  w = CamImg_.GetWidth();
  h = CamImg_.GetHeight();      

  text.Printf(wxT("size: %4dx%4d"),w, h);
  SetStatusText(text, 1);

  // set new height or width if changed
  if (w != Width_ || h != Height_)
  {
    Width_  = w;
    Height_ = h;
    IC_->SetSize(w+50,h+80);
    SetMinSize(wxSize(w+50,h+80));
    Fit();
  }

  BIAS::Image<float> tmp;  BIAS::Camera<unsigned char> tmpUC;  

  //FLOAT
  if(CameraFL_ != NULL){
    CameraFL_->GrabSingle(CamImgOrgFL_);
    if (downsample_) {
      if (CamImgRescaledFL_.IsEmpty())
        CamImgRescaledFL_.Init(CamImgOrgFL_.GetWidth()/2,CamImgOrgFL_.GetHeight()/2,1);
      Rescale<float,float> pRescaleFilter;
      pRescaleFilter.Downsample (CamImgOrgFL_,CamImgFL_,2);   
      
    }
    else 
      CamImgFL_ = CamImgOrgFL_;

    w = CamImgFL_.GetWidth();
    h = CamImgFL_.GetHeight();      
    CamImgFL_.SetROI(15,15,w-15,h-15);

    mogFL_->Apply(CamImgFL_);
  }
  
  static int n=0;
  n++;
  if (n>100) {
    mog_->AllowCreationOfNewDistributions(false);
    mog_->SetUpdateFactor(0.0f);
    mog_->EnableCleanup(true, true, false);
  }
  switch (dCurImage_) {
  
  case 0:
    if(bShowImageFL_) { 
      CamImgFL_.ScaleShiftBetween(0,255);
      BIAS::ImageConvert::ConvertST(CamImgFL_,tmpUC,ImageBase::ST_unsignedchar);
      ShowImage_ = &tmpUC;
    }
    else ShowImage_ = &CamImg_;
    break;
  case 1:
    if(bShowImageFL_) {
      mogFL_->GetNormalizedImage(tmp);
    }else{
      mog_->GetNormalizedImage(tmp);
    }
    tmp.ScaleShiftBetween(0,255);
    BIAS::ImageConvert::ConvertST(tmp, CamImgNormalizedChar_, ImageBase::ST_unsignedchar);        
    ShowImage_ = &CamImgNormalizedChar_;
    break;
  case 2:
    if(bShowImageFL_) 
      mogFL_->GetWeightImage(tmp);    
    else
//      mog_->GetWeightImage(tmp);
      mog_->GetMatchValueImage(tmp);
    ImageIO::Save("bla-"+FileHandling::LeadingZeroString(n,5)+".mip", tmp);
    tmp.ScaleShiftBetween(0,255);
    BIAS::ImageConvert::ConvertST(tmp, WeightImgChar_, ImageBase::ST_unsignedchar);
    ShowImage_ = &WeightImgChar_;
    break;
  case 3:
    if(bShowImageFL_) 
      mogFL_->GetDifferenceImage(DifferenceImgChar_);
    else
      mog_->GetDifferenceImage(DifferenceImgChar_);
    ShowImage_ = &DifferenceImgChar_;
    break;
  case 4:
    if(bShowImageFL_) 
      mogFL_->GetDifferenceImageWithVisuals(DifferenceImgCharRGB_);
    else
      mog_->GetDifferenceImageWithVisuals(DifferenceImgCharRGB_);
    ShowImage_ = &DifferenceImgCharRGB_;
//    ImageIO::Save("MOG-visu"+BIAS::LeadingZeroString(n,3)+".mip", DifferenceImgCharRGB_);
    break;
  default:
    ShowImage_ = &CamImg_;
    break;
  }

  // show actual camera image on main frame
  IC_->Show(*ShowImage_, "Camera Image");

  Timer_.Start(30, true);  
}

void ExampleMixtureOfGaussiansFrame::OnKey(wxKeyEvent& event) {
  
}