biasdetectunvignettewx.cpp

#include <Base/Common/W32Compat.hh>

#include <wx/wx.h>
#include <wx/spinctrl.h>
#include <wx/dnd.h>
#include <wx/filename.h>
#include <wx/arrstr.h>


#include <string>
#include <sstream>
#include <Gui/StringConv.hh>
#include <Gui/ImageCanvas.hh>
#include <Base/Image/ImageIO.hh>
#include <Base/ImageUtils/ImageDraw.hh>
#include <Image/Camera.hh>
#include <Image/UnVignette.hh>


#define FRAME_DEFAULT_SIZE  wxSize(700,580)

using namespace std;
using namespace BIAS;

#undef WXWIN_COMPATIBILITY

#if !wxUSE_DRAG_AND_DROP
#  error The dndFileTarget class requires drag and drop support in the WX library. Please recompile wxWidgets. __FILE__: __LINE__
#endif


/**
 * \cond HIDDEN_SYMBOLS
   @file
   @relates Unvignette
   @brief Tool to detect the vignetting function (radial light fall off in images)
   see biasdetectunvignettewx.cpp
   @ingroup g_tools
   @author ischiller
   @date 2006
*/

/*
===============================================================================
MainFrame
===============================================================================
*/
enum
{
  // menu item IDs
  ID_Load=wxID_HIGHEST+2231,
  ID_Exit,
  ID_About,
  ID_Timer,
  ID_Steps,
  ID_UnVig,
  ID_WriteCameraData,
  ID_PPX,
  ID_PPY
};

/** \internal */
class MainFrame : public wxFrame
{
public:
  friend class DragAndDropTarget;

  MainFrame(const wxString& title, const wxPoint& pos, const wxSize& size);

  bool LoadImagesAndCalculate(const wxArrayString &fileNames);

  /// fits the frame size if it is too small for curent image
  void FitSizetIfTooSmall();

  double CalcImageMean3x3(BIAS::Image<unsigned char> img, int x,int y);

public:
 wxArrayString       ImageFileNames_;

 //members /////////////////////////////
protected:

  BIAS::UnVignette    UnVignette_;

  ImageCanvas*        ImageCanvasUC_;

  wxTimer             Timer_;
  wxStaticText*       StaticLabel_;
  wxTextCtrl*         StepsTextCtrl_;
  wxTextCtrl*         PPXTextCtrl_;
  wxTextCtrl*         PPYTextCtrl_;

  bool                bUnVignetteParamsReady_;
  bool                bImageLoaded_;
  int                 dNumberOfSteps_;
  // for file open dialog
  wxString            DefaultFile_;
  wxString            DefaultDir_;
  wxString            fileName_;

  // the unsigned char image for display
  Image<unsigned char> unVigImage_;
  Image<unsigned char> ucImage_;
  ImageBase            origImage_;

  std::vector<double>  controlPoints_;
  std::vector<double>  VignettePercentage_;

  int dGroundThruthWhite_;

  int ImageWidth_;
  int ImageHeight_;

  //offsets from image center (pixel)
  int PrinciplePointX_;
  int PrinciplePointY_;

  //member functions ///////////////////////
protected:
  // event handlers
  void OnLoad(wxCommandEvent& event);
  void OnExit(wxCommandEvent& event);
  void OnAbout(wxCommandEvent& event);

  void OnTimer(wxTimerEvent& event);
  void OnIdle(wxIdleEvent& event);
  void OnSize(wxSizeEvent& event);

  void OnStepsEnter(wxCommandEvent& event);

  void CalculateSteps(int dImageNumber);
  void UnVignette();
  void SaveUnVignetted(wxCommandEvent& event);
  void WriteCameraData(wxCommandEvent& event);

  void RefitClients();
  DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(MainFrame, wxFrame)
EVT_MENU    (ID_Load,     MainFrame::OnLoad)
EVT_MENU    (ID_Exit,     MainFrame::OnExit)
EVT_MENU    (ID_About,    MainFrame::OnAbout)
EVT_MENU    (ID_WriteCameraData,    MainFrame::WriteCameraData)
EVT_TEXT_ENTER (ID_Steps, MainFrame::OnStepsEnter)
EVT_TEXT_ENTER (ID_PPX, MainFrame::OnStepsEnter)
EVT_TEXT_ENTER (ID_PPY, MainFrame::OnStepsEnter)

EVT_BUTTON  (ID_UnVig,    MainFrame::SaveUnVignetted)
EVT_BUTTON  (ID_WriteCameraData, MainFrame::WriteCameraData)

EVT_TIMER   (ID_Timer, MainFrame::OnTimer)
EVT_IDLE    (MainFrame::OnIdle)
EVT_SIZE    (MainFrame::OnSize)
END_EVENT_TABLE()


// ctor
MainFrame::MainFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
: wxFrame((wxFrame*)NULL, -1, title, pos, size)
,ImageCanvasUC_(NULL)
{
  DefaultFile_      = wxT("test.pgm");
  DefaultDir_       = wxT("");
  dNumberOfSteps_   = 10;
  PrinciplePointX_  = 0;
  PrinciplePointY_  = 0;
  dGroundThruthWhite_ = 0;
  bUnVignetteParamsReady_ = false;
  bImageLoaded_ = false;
  // init timer
  Timer_.SetOwner(this, ID_Timer);

  // create file menu
  wxMenu* fileMenu = new wxMenu;
  fileMenu->Append(ID_Load, wxT("&Open/Load...\tCtrl-O"), wxT("Open a file from disk for loading"));
  fileMenu->Append(ID_WriteCameraData, wxT("&Write Camera Data...\tCtrl-W"), wxT("Save camera vignette parameters"));
  fileMenu->AppendSeparator();

  // create help menu
  wxMenu* helpMenu = new wxMenu;
  helpMenu->Append(ID_About, wxT("&About...\tF1"));

  // create menu bar
  wxMenuBar* menuBar = new wxMenuBar;
  menuBar->Append(fileMenu, wxT("&File"));
  menuBar->Append(helpMenu, wxT("&Help"));
  SetMenuBar(menuBar);

  wxToolBar* toolBar = CreateToolBar();
  toolBar->SetSize(1200,200);
  StepsTextCtrl_ = new wxTextCtrl(toolBar, ID_Steps, wxT("10"), wxDefaultPosition,wxDefaultSize,wxTE_PROCESS_ENTER);
  toolBar->AddControl(new wxStaticText(toolBar, -1, wxT("  Nr. of Steps: ")));
  toolBar->AddControl(StepsTextCtrl_);

  toolBar->AddSeparator();
  toolBar->AddControl(new wxButton(toolBar, ID_UnVig, wxT("Save Unvignetted")));
  toolBar->AddControl(new wxButton(toolBar, ID_WriteCameraData, wxT("Write Cameradata")));
  toolBar->AddSeparator();
  PPXTextCtrl_ = new wxTextCtrl(toolBar, ID_PPX, wxT("0"), wxDefaultPosition, wxDefaultSize,wxTE_PROCESS_ENTER);
  PPYTextCtrl_ = new wxTextCtrl(toolBar, ID_PPY, wxT("0"), wxDefaultPosition, wxDefaultSize,wxTE_PROCESS_ENTER);

  toolBar->AddControl(new wxStaticText(toolBar, -1, wxT(" PPX: ")));
  toolBar->AddControl(PPXTextCtrl_);
  toolBar->AddControl(new wxStaticText(toolBar, -1, wxT(" PPY: ")));
  toolBar->AddControl(PPYTextCtrl_);

  toolBar->Realize();


  // create status bar
  const int numFields = 2;
  CreateStatusBar(numFields);
  int widths[] = { -3, -1 };
  SetStatusWidths(numFields, widths);
  SetStatusText(wxT("Welcome to Unvignette detection"), 0);

}

void MainFrame::WriteCameraData(wxCommandEvent& /*event*/)
{
  if(!bUnVignetteParamsReady_)
  {
    wxMessageDialog mDlg(this,wxT("Camera unvignette parameters are not ready, compute first!"),
      wxT("Not ready!"),wxOK);
    mDlg.ShowModal();
    return;
  }
  std::ofstream OutStream;
  wxArrayString paths;
  wxFileDialog fileDialog(
    this,                            // parent
    wxT("Choose xml file to save Camera Data."), // message
    DefaultDir_,                     // default directory
    wxT("UnVignetteParams.xml"),     // default file
    wxT("*.xml"),                    // wildcard
    wxFD_SAVE|wxFD_OVERWRITE_PROMPT); // style

  if (fileDialog.ShowModal() == wxID_OK)
  {
    // get file names
    fileDialog.GetPaths(paths);
  } else {
    SetStatusText(wxT("Writing Camera Data cancelled"));
    return;
  }

  DefaultDir_= fileDialog.GetDirectory();

  OutStream.open(WxToAscii(paths.Last()),ios_base::out | ios_base::trunc);
  OutStream << setprecision(10);
  OutStream<<"<VignetteCalib>\n";
  for(unsigned int i = 0;i<controlPoints_.size();i++)
    OutStream<<"<MeasPt Dist=\""<<controlPoints_[i]<<"\" Fac=\""<<VignettePercentage_[i]<<"\"/>"<<endl;
  OutStream<<"</VignetteCalib>"<<endl;
  OutStream.flush();
  OutStream.close();
}

void MainFrame::SaveUnVignetted(wxCommandEvent& /*event*/)
{
  if(unVigImage_.IsEmpty())
  {
   wxMessageDialog mDlg(this,wxT("No image loaded, load first!"),
      wxT("Not ready!"),wxOK);
    mDlg.ShowModal();
    return;
  }
  wxArrayString paths;
  wxFileDialog fileDialog(
    this,                            // parent
    wxT("Choose image file to save unvignetted image."), // message
    DefaultDir_,                     // default directory
    wxT("TestUnVignette.mip"),       // default file
    wxT("*.mip"),                    // wildcard
    wxFD_SAVE|wxFD_OVERWRITE_PROMPT);      // style

  if (fileDialog.ShowModal() == wxID_OK)
  {
    // get file names
    fileDialog.GetPaths(paths);
  } else {
    SetStatusText(wxT("Writing unvignetted image cancelled"));
    return;
  }

  DefaultDir_= fileDialog.GetDirectory();
  //BIAS::ImageIO::Save(WxToAscii(paths.Last()),unVigImage_);
  BIAS::ImageIO::Save(WxToAscii(paths.Last()),unVigImage_);
}

void MainFrame::OnStepsEnter(wxCommandEvent& /*event*/)
{
  LoadImagesAndCalculate(ImageFileNames_);
  StepsTextCtrl_->SetFocus();
}

void MainFrame::CalculateSteps(int dImageNumber)
{
  ucImage_ = origImage_;

  ImageWidth_ = ucImage_.GetWidth();
  ImageHeight_ = ucImage_.GetHeight();

  if(dImageNumber == 0){
    controlPoints_.clear();
    VignettePercentage_.clear();
  }
  //this is diagonal distance of image rectangle
  double diagonal = sqrt(pow((double)ImageWidth_,2)+pow((double)ImageHeight_,2));
  //calculate stepswidth
  int step =  int ( diagonal / (dNumberOfSteps_*2) );
  int currentRadius=0;
  int valueX=0, valueY=0;
  double mean=0.0, mean1=0.0, mean2=0.0, mean3=0.0, mean4=0.0;

  double alpha = atan((double)ImageHeight_/(double)ImageWidth_);
//  unsigned char ** ida = ucImage_.GetImageDataArray();
  //go over steps and draw lines and calculate values
  for(int currentstep =0;currentstep <=dNumberOfSteps_;currentstep++)
  {
    // go into all 4 corners and build mean of 4 measurements
    for(int corner=0;corner<4;corner++)
    {
        // calculate ControlPoints on diagonal of image and on circle around PrinciplePoint with radius
      if(corner==0) // left top corner
      {
        valueX = ImageWidth_/2 + PrinciplePointX_ - int(currentRadius * cos(alpha));
        valueY= ImageHeight_/2 + PrinciplePointY_ - int(currentRadius * sin(alpha));

        //only save control points if first image and first corner
        if(valueX<(ImageWidth_-1)&&valueY <(ImageHeight_-1)&& valueY >= 0  && valueX >= 0)
        {
          mean1 = CalcImageMean3x3(ucImage_,valueX,valueY);
          if(mean1 >= 0 && dImageNumber == 0)
            controlPoints_.push_back((double)currentRadius/((double)ImageWidth_/2));
          else if(mean1 < 0.0){
            corner =5;
            break;
          }
        }
      }
      else if(corner==1) //right top corner
      {
        valueX = int(currentRadius * cos(alpha) + ImageWidth_/2 + PrinciplePointX_);
        valueY= ImageHeight_/2 + PrinciplePointY_ - int(currentRadius * sin(alpha));
        mean2 = CalcImageMean3x3(ucImage_,valueX,valueY);
        if(mean2 <0.0){
          corner =5;
          break;
        }

      }
      else if(corner==2) //left bottom corner
      {
        valueX = ImageWidth_/2 + PrinciplePointX_ - int(currentRadius * cos(alpha));
        valueY= int(currentRadius * sin(alpha) + ImageHeight_/2 + PrinciplePointY_);
        mean3 = CalcImageMean3x3(ucImage_,valueX,valueY);
        if(mean3 <0.0){
          corner =5;
          break;
        }
      }
      else if(corner==3) // right bottom corner
      {
        valueX = int(currentRadius * cos(alpha) + ImageWidth_/2 + PrinciplePointX_);
        valueY= int(currentRadius * sin(alpha) + ImageHeight_/2 + PrinciplePointY_);
        mean4 = CalcImageMean3x3(ucImage_,valueX,valueY);
        if(mean4 <0.0){
          corner =5;
          break;
        }
      }
    }// end go over corners

    //check if all positions were in the image and valid else break;
    if(! (mean1>=0.0 && mean2>=0.0 && mean3>=0.0 && mean4>=0.0))
      break;
    // this is mean of all 4 corners
    mean =(mean1+mean2+mean3+mean4)/4;
    //this is the center, save the value as fixpoint
    double percentage = 0.0;
    if(currentstep==0){
      dGroundThruthWhite_ = int(mean);
      percentage = 1.0;
    }
    else
      percentage = ((double)dGroundThruthWhite_/mean);
    //only push_back if first image else make mean
    if(dImageNumber==0)
    {
      if(percentage>=0.0)
        VignettePercentage_.push_back(percentage);
      else
        VignettePercentage_.push_back(0.0);
      }
    else
    {
      if(percentage >=0.0)
      {
        VignettePercentage_[currentstep] *= dImageNumber;
        VignettePercentage_[currentstep] += percentage;
        VignettePercentage_[currentstep] /=(dImageNumber+1);
      }
    }//end else

    //Draw circels in image
    BIAS::ImageDraw<unsigned char>::CircleCenter(ucImage_,ImageWidth_/2+ PrinciplePointX_,
      ImageHeight_/2+ PrinciplePointY_,currentRadius);

    currentRadius += step;
  }

  ImageCanvasUC_->Show(ucImage_, WxToAscii(fileName_));
  if (ImageCanvasUC_) ImageCanvasUC_->SetFocus();

}

void MainFrame::UnVignette()
{
  if(!bImageLoaded_)
  {
    /*wxMessageDialog mDlg(this,"No image loaded, load first!",
      "Not ready!",wxOK);
    mDlg.ShowModal();*/
    return;
  }
  unVigImage_ = origImage_;
  UnVignette_.Init(controlPoints_,VignettePercentage_,unVigImage_.GetWidth(),
    unVigImage_.GetHeight(),PrinciplePointX_+unVigImage_.GetWidth()/2,
    PrinciplePointY_+unVigImage_.GetHeight()/2,LEAST_SQUARES);
  UnVignette_.Compute(unVigImage_);

  bUnVignetteParamsReady_ = true;
}

void MainFrame::RefitClients()
{
  // canvas needs to be refitted on windows after loading (not sure why)
  int w, h;
  GetClientSize(&w, &h);
  if (ImageCanvasUC_!=NULL)
    ImageCanvasUC_->SetSize(0, 0, w, h);
}

bool MainFrame::LoadImagesAndCalculate(const wxArrayString &fileNames)
{
  dNumberOfSteps_ = atoi(WxToAscii(StepsTextCtrl_->GetValue()));
  PrinciplePointX_ = atoi(WxToAscii(PPXTextCtrl_->GetValue()));
  PrinciplePointY_ = atoi(WxToAscii(PPYTextCtrl_->GetValue()));
  for(unsigned int k=0;k<fileNames.Count();k++)
  {
    // load image
    fileName_ = fileNames[k];

    if (ImageIO::Load(WxToAscii(fileName_), origImage_)!=0)
    {
      stringstream msg;
      msg << "Error loading " << fileName_;
      BIASERR(msg.str());
      SetStatusText(AsciiToWx(msg.str()));
    }
    else
    {

      // create uc image canvas
      if(ImageCanvasUC_ == NULL)
      {
        ImageCanvasUC_ = new ImageCanvas(this, GetStatusBar(), 1);
      }
      bImageLoaded_ = true;

      //calculate steps and show image
      this->CalculateSteps(k);

      this->RefitClients();

    }//end else (means loading succeeded

  }//end for

  //after collection of all data, finally unvignette
  this->UnVignette();

  return true;
}

void MainFrame::OnLoad(wxCommandEvent& /*event*/)
{
  wxFileDialog fileDialog(
    this,                              // parent
    wxT("Choose file(s) to load"),     // message
    DefaultDir_,                       // default directory
    DefaultFile_,                      // default file
    wxT("*.*"),                        // wildcard
    wxFD_OPEN | wxFD_MULTIPLE);              // style

  if (fileDialog.ShowModal() == wxID_OK)
  {
    // get file names

    fileDialog.GetPaths(ImageFileNames_);
    // load last item
    LoadImagesAndCalculate(ImageFileNames_);
  } else {
    SetStatusText(wxT("Loading canceled"));
    cout << "Canceled loading image" << endl;
  }

  DefaultDir_= fileDialog.GetDirectory();

}

double MainFrame::
CalcImageMean3x3(BIAS::Image<unsigned char> img, int x,int y)
{
  int width, height;
  width = img.GetWidth();
  height = img.GetHeight();
  if( (x>1) && (y>1) && (x<width-1) &&  (y<height-1))
  {
    double mean = ((double)img.PixelValue(x-1,y-1) +
      (double)img.PixelValue(x,y-1)+(double)img.PixelValue(x+1,y-1)+
      (double)img.PixelValue(x-1,y)+ (double)img.PixelValue(x,y)+
      (double)img.PixelValue(x+1,y)+ (double)img.PixelValue(x-1,y+1) +
      (double)img.PixelValue(x,y+1) + (double)img.PixelValue(x+1,y+1))/9;
    return mean;
  }
  else
    return -1.0;
}

void MainFrame::OnExit(wxCommandEvent& /*event*/){}
void MainFrame::OnAbout(wxCommandEvent& /*event*/)
{
stringstream msg;

  msg << "The BIAS Vignette Detection Program\n\n"
    << "http://www.mip.informatik.uni-kiel.de\n\n"
    << "build on " << __DATE__ << " " << __TIME__ << "\n"
    << "from file " << __FILE__ << "\n"
    << "GUI using: " << wxVERSION_STRING << "\n"
    << "Author : Ingo Schiller "<< "\n"
    << "\n";

  wxMessageBox(AsciiToWx(msg.str()), wxT("About biasdetectunvignettewx"),
    wxOK | wxICON_INFORMATION, this);
}

void MainFrame::OnTimer(wxTimerEvent& /*event*/){}
void MainFrame::OnIdle(wxIdleEvent& /*event*/){}
void MainFrame::OnSize(wxSizeEvent& /*event*/){ this->RefitClients();}

/*
===============================================================================
DragAndDropTarget
===============================================================================
*/

/** @brief drag and drop files onto application.
drag a file from MS explorer or kde file manager directly onto an application
(instaed of using a load from filename function.)
*/
class DragAndDropTarget : public wxFileDropTarget
{
public:
  DragAndDropTarget(MainFrame* frame);

  virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
protected:
  MainFrame* Frame_;
};

DragAndDropTarget::DragAndDropTarget(MainFrame* frame)
{
  Frame_ = frame;
}

bool DragAndDropTarget::OnDropFiles(wxCoord /*x*/, wxCoord /*y*/, const wxArrayString& filenames)
{
  BIASASSERT( Frame_ != NULL);
  Frame_->ImageFileNames_ = filenames;
  Frame_->LoadImagesAndCalculate(filenames);

  return true;
}


/*
===============================================================================
BiasDetectUnvignetteApp
===============================================================================
*/

class BiasDetectUnvignetteApp : public wxApp
{
public:
  virtual bool OnInit();
};

bool BiasDetectUnvignetteApp::OnInit()
{

  MainFrame* frame = new MainFrame(wxT("BiasDetectUnvignetteApp"), wxPoint(50,50), FRAME_DEFAULT_SIZE );


  // create drag and drop target
  DragAndDropTarget* dndTarget = new DragAndDropTarget(frame);
  frame->SetDropTarget(dndTarget);

  // show frame
  frame->Show(TRUE);
  SetTopWindow(frame);

  return TRUE;
}


IMPLEMENT_APP(BiasDetectUnvignetteApp)
/** \endcond */