wxProjectionPanel.cpp

#ifdef WIN32
#  pragma warning (disable: 4005) // for VS8 + WX
#endif

#include <Gui/wxProjectionPanel.hh>
#include <Geometry/ProjectionParametersSpherical.hh>
#include <Gui/StringConv.hh>
#include <sstream>

using namespace std;
using namespace BIAS;


/*
===============================================================================
wxProjectionPanel
===============================================================================
*/

// event ids
enum eids
{
  ID_New,
  ID_Load,
  ID_Save,
  ID_NormalizeQuaternion
};

// panel ids
enum pids
{
  ID_Center,
  ID_Quaternion,
  ID_RMatrix,
  ID_ImageSize,
  ID_AspectRatio,
  ID_Principal,
  ID_KMatrix,
  ID_FocalLength,
  ID_Undistortion,
  ID_Radius
};

BEGIN_EVENT_TABLE(wxProjectionPanel, wxPanel)
  EVT_TEXT_ENTER(-1, wxProjectionPanel::OnModified)
  EVT_BUTTON(ID_NormalizeQuaternion, wxProjectionPanel::OnNormalizeQuaternion)
  EVT_BUTTON(ID_New,  wxProjectionPanel::OnNew)
  EVT_BUTTON(ID_Load, wxProjectionPanel::OnLoad)
  EVT_BUTTON(ID_Save, wxProjectionPanel::OnSave)
END_EVENT_TABLE()

wxProjectionPanel::wxProjectionPanel(wxWindow* parent, wxWindowID id,
                             const wxPoint& pos, const wxSize& size,
                             long style, const wxString& name, bool createButtons)
  : wxPanel(parent, id, pos, size, style, name)
{
  selfModifying_ = false;

  projectionPanel_ = new wxScrolledWindow(this);
  projectionPanel_->SetScrollRate(1, 1);

  wxSizer* buttonSizer = new wxBoxSizer(wxHORIZONTAL);

  if (createButtons)
  {
    buttonSizer->Add(new wxButton(this, ID_New,  wxT("New")));
    buttonSizer->Add(new wxButton(this, ID_Load, wxT("Load")));
    buttonSizer->Add(new wxButton(this, ID_Save, wxT("Save")));
  }

  wxSizer* mainSizer = new wxBoxSizer(wxVERTICAL);
  mainSizer->Add(buttonSizer, 0, wxALL, 5);
  mainSizer->Add(projectionPanel_, 1, wxEXPAND | wxALL, 5);

  SetSizer(mainSizer);
}

void wxProjectionPanel::SetProjection(const Projection& projection)
{
  // clear old projection panel
  projectionPanel_->DestroyChildren();
  notebookPages_.clear();
  panelCenter_.clear();

  panelQuaternion_.clear();
  panelRMatrix_.clear();
  panelImageSize_.clear();
  panelAspectRatio_.clear();
  panelPrincipal_.clear();
  panelKMatrix_.clear();
  panelFocalLength_.clear();
  panelUndistortion_.clear();
  panelRadius_.clear();

  // create sizer
  wxFlexGridSizer* sizer = new wxFlexGridSizer(1, 5, 5);

  sizer->AddGrowableCol(1);
  projectionPanel_->SetSizer(sizer);
  noteBook_ = new wxNotebook(projectionPanel_, -1,
  //                                 wxDefaultPosition,wxSize(450,450), wxNB_TOP);
                              wxDefaultPosition,wxSize(-1,-1), wxNB_TOP);
  sizer->Add(noteBook_, 0, wxALL, 5);

  projection_ = projection;

  for(unsigned i=0;i<projection_.Size();i++){

    notebookPages_.push_back(new wxScrolledWindow(noteBook_,-1,
        wxDefaultPosition,wxSize(-1,-1)));
    wxFlexGridSizer* sizerPage = new wxFlexGridSizer(2, 1,1);

    sizerPage->AddGrowableCol(1);
    notebookPages_.back()->SetSizer(sizerPage);
    // base parameters
    const ProjectionParametersBase* paramsBase = projection.GetParameters(i);


    sizerPage->Add(new wxStaticText(notebookPages_.back(), -1,
        wxT("Identifier:"),wxDefaultPosition,wxSize(-1,-1)));
    sizerPage->Add(new wxStaticText(notebookPages_.back(), -1,
        AsciiToWx(paramsBase->GetIdentifier()),wxDefaultPosition,wxSize(-1,-1)));

    panelCenter_.push_back(AddVectorPanel(notebookPages_.back(),wxT("Center"),       ID_Center,      true));
    panelQuaternion_.push_back(AddVectorPanel(notebookPages_.back(),wxT("Quaternion"),   ID_Quaternion,  true));

    sizerPage->AddSpacer(0);
    sizerPage->Add(new wxButton(notebookPages_.back(), ID_NormalizeQuaternion, wxT("Normalize Quaternion")));

    panelRMatrix_.push_back(AddMatrixPanel(notebookPages_.back(),wxT("R Matrix"),     ID_RMatrix,     false));
    panelImageSize_.push_back(AddVectorPanel(notebookPages_.back(),wxT("Image Size"),   ID_ImageSize,   true));
    panelAspectRatio_.push_back(AddVectorPanel(notebookPages_.back(),wxT("Aspect Ratio"), ID_AspectRatio, true));
    panelPrincipal_.push_back(AddVectorPanel(notebookPages_.back(),wxT("Principal"),    ID_Principal,   true));

    // perspective parameters
    const ProjectionParametersPerspective* paramsPersp =
            dynamic_cast<const ProjectionParametersPerspective*>(paramsBase);
    if (paramsPersp != NULL)
    {
        panelKMatrix_.push_back(AddMatrixPanel(notebookPages_.back(),wxT("K Matrix"),     ID_KMatrix,       false));
        panelFocalLength_.push_back(AddVectorPanel(notebookPages_.back(),wxT("Focal Length"), ID_FocalLength,   true));
        panelUndistortion_.push_back(AddVectorPanel(notebookPages_.back(),wxT("Undistortion"), ID_Undistortion,  true));
    }
    else
    {
        panelKMatrix_.push_back(NULL);
        panelFocalLength_.push_back(NULL);
        panelUndistortion_.push_back(NULL);
    }

    // spherical parameters
    const ProjectionParametersSpherical* paramsSpherical =
            dynamic_cast<const ProjectionParametersSpherical*>(paramsBase);
    if (paramsSpherical != NULL)
    {
        panelRadius_.push_back(AddVectorPanel(notebookPages_.back(),wxT("Radius"), ID_Radius, true));
    }
    else
    {
        panelRadius_.push_back(NULL);
    }

    sizerPage->Layout();
    // fill gui with values from projection
    UpdateGUI(i);

    //add notebook page
    wxString name;
    name.Printf(_T("%s %d"),wxT("Camera:"), i);
    noteBook_->AddPage(notebookPages_.back(), name,false);
  }


  sizer->Layout();
  Layout();
}

const Projection& wxProjectionPanel::GetProjection() const
{
  return projection_;
}

wxVectorPanel* wxProjectionPanel::
AddVectorPanel(wxWindow* parent,
            const wxString& name,
            wxWindowID id, bool editable)
{
  wxVectorPanel* panel = new wxVectorPanel(parent, id, editable);
  panel->SetSize(wxSize(-1,-1));
  wxSizer* sizer = parent->GetSizer();
  sizer->Add(new wxStaticText(parent, -1, name));
  sizer->Add(panel, 1, wxEXPAND);

  return panel;
}

wxMatrixPanel* wxProjectionPanel::
AddMatrixPanel(wxWindow* parent,const wxString& name,
        wxWindowID id, bool editable)
{
  wxMatrixPanel* panel = new wxMatrixPanel(parent, id, editable);
  panel->SetSize(wxSize(-1,-1));
  wxSizer* sizer = parent->GetSizer();
  sizer->Add(new wxStaticText(parent, -1, name));
  sizer->Add(panel, 1, wxEXPAND);

  return panel;
}

void wxProjectionPanel::UpdateGUI(unsigned int cameraNr)
{
  selfModifying_ = true;

  // base parameters
  const ProjectionParametersBase* paramsBase = projection_.GetParameters(cameraNr);

  unsigned int imageWidth, imageHeight;
  paramsBase->GetImageSize(imageWidth, imageHeight);

  double principalX, principalY;
  paramsBase->GetPrincipal(principalX, principalY);
  if (paramsBase->CValid())
    panelCenter_[cameraNr]->SetVector(paramsBase->GetC());
  else{
    Vector3<double> C(0,0,0);
    panelCenter_[cameraNr]->SetVector(C);
  }
  if (paramsBase->QValid()) {
    panelQuaternion_[cameraNr]->SetVector(paramsBase->GetQ());
    panelRMatrix_[cameraNr]->SetMatrix(BIAS::Matrix<double>(paramsBase->GetR()));
  }
  else{
    panelQuaternion_[cameraNr]->SetVector(Quaternion<double>(0,0,0,1));
    Matrix<double> R(3,3,0); R.SetIdentity();
    //cout<<"Setting identity 3x3 matrix"<<endl;
    panelRMatrix_[cameraNr]->SetMatrix(R);
  }
  panelImageSize_[cameraNr]->SetVector(Vector2<double>(imageWidth, imageHeight));
  panelAspectRatio_[cameraNr]->SetVector(Vector<double>(1, paramsBase->GetAspectratio()));
  panelPrincipal_[cameraNr]->SetVector(Vector2<double>(principalX, principalY));

  // perspective parameters
  const ProjectionParametersPerspective* paramsPersp =
    dynamic_cast<const ProjectionParametersPerspective*>(paramsBase);
  if (paramsPersp != NULL)
  {
    double focalLength;
    double kc1, kc2, kc3, kc4;
    paramsPersp->GetFocalLength(focalLength);
    paramsPersp->GetUndistortion(kc1, kc2, kc3, kc4);

    panelKMatrix_[cameraNr]->SetMatrix((Matrix<double>)(paramsPersp->GetK()));
    panelFocalLength_[cameraNr]->SetVector(Vector<double>(1, focalLength));
    panelUndistortion_[cameraNr]->SetVector(Vector4<double>(kc1, kc2, kc3, kc4));
  }

  // spherical parameters
  const ProjectionParametersSpherical* paramsSpherical =
    dynamic_cast<const ProjectionParametersSpherical*>(paramsBase);
  if (paramsSpherical != NULL)
  {
    panelRadius_[cameraNr]->SetVector(Vector<double>(1, paramsSpherical->GetRadius()));
  }

  selfModifying_ = false;
}

void wxProjectionPanel::OnNormalizeQuaternion(wxCommandEvent& /*event*/)
{
    unsigned cameraNr = noteBook_->GetSelection();
  ProjectionParametersBase* paramsBase = projection_.GetParameters(cameraNr);
  Quaternion<double> Q = paramsBase->GetQ();
  Q.Normalize();
  paramsBase->SetQ(Q);
  UpdateGUI(cameraNr);
}

void wxProjectionPanel::OnModified(wxCommandEvent& event)
{
  cout << "Modifying" << endl;
  if (selfModifying_)
  {
    return;
  }
    unsigned cameraNr = noteBook_->GetSelection();
  ProjectionParametersBase* paramsBase = projection_.GetParameters(cameraNr);
  ProjectionParametersPerspective* paramsPersp =
    dynamic_cast<ProjectionParametersPerspective*>(paramsBase);
  ProjectionParametersSpherical* paramsSpherical =
    dynamic_cast<ProjectionParametersSpherical*>(paramsBase);

  switch (event.GetId())
  {
    case ID_Center:
    {
      Vector<double> C = panelCenter_[cameraNr]->GetVector();
      paramsBase->SetC(Vector3<double>(C));

    } break;

    case ID_Quaternion:
    {
      Vector<double> Q = panelQuaternion_[cameraNr]->GetVector();
      paramsBase->SetQ(Quaternion<double>(Q[0], Q[1], Q[2], Q[3]));
    } break;

    case ID_RMatrix:
    {
      Matrix<double> R = panelRMatrix_[cameraNr]->GetMatrix();
      paramsBase->SetR(Matrix3x3<double>(R));
    } break;

    case ID_ImageSize:
    {
      Vector<double> imageSize = panelImageSize_[cameraNr]->GetVector();
      paramsBase->SetImageSize((int)imageSize[0], (int)imageSize[1]);
    } break;

    case ID_AspectRatio:
    {
      Vector<double> aspectratio = panelAspectRatio_[cameraNr]->GetVector();
      paramsBase->SetAspectratio(aspectratio[0]);
      BIASASSERT(false); // aspect ratio is read-only
    } break;

    case ID_Principal:
    {
      Vector<double> principal = panelPrincipal_[cameraNr]->GetVector();
      paramsBase->SetPrincipal(principal[0], principal[1]);
    } break;

    case ID_KMatrix:
    {
      BIASASSERT(false); // K matrix is read-only
    } break;

    case ID_FocalLength:
    {
      Vector<double> focalLength = panelFocalLength_[cameraNr]->GetVector();
      paramsPersp->SetFocalLengthAndAspect(focalLength[0],
                                           paramsPersp->GetAspectratio());
    } break;

    case ID_Undistortion:
    {
      Vector<double> undist = panelUndistortion_[cameraNr]->GetVector();
      paramsPersp->SetUndistortion(undist[0], undist[1], undist[2], undist[3]);
    } break;

    case ID_Radius:
    {
      Vector<double> radius = panelRadius_[cameraNr]->GetVector();
      paramsSpherical->SetRadius(radius[0]);
    } break;
  }

  UpdateGUI(cameraNr);
}

void wxProjectionPanel::OnNew(wxCommandEvent& /*event*/)
{
  wxString choices[] = { wxT("Perspective"), wxT("Spherical") };
  int numChoices = 2;

  wxSingleChoiceDialog dlg(NULL, wxT("Choose projection type:"),
                           wxT("New Projection"), numChoices, choices);
  if (dlg.ShowModal() == wxID_OK)
  {
    switch (dlg.GetSelection())
    {
    case 0:
      SetProjection(Projection(ProjectionParametersPerspective()));
      break;
    case 1:
      SetProjection(Projection(ProjectionParametersSpherical()));
      break;
    }
  }
}

void wxProjectionPanel::OnLoad(wxCommandEvent& /*event*/)
{
#ifdef BIAS_HAVE_XML2
  wxFileDialog dlg(NULL, wxT("Load Projection"), wxT(""), wxT(""), wxT("*.*"),
                   wxFD_OPEN | wxFD_FILE_MUST_EXIST);
  if (dlg.ShowModal() == wxID_OK)
  {
    Projection loadedProjection;
    if (loadedProjection.Load(WxToAscii(dlg.GetPath())) != 0)
    {
      wxMessageDialog dlg(this, wxT("Failed to load projection"), wxT("Error"));
      dlg.ShowModal();
    }
    else
    {
      SetProjection(loadedProjection);
    }
  }
#else
  BIASERR("XML2 missing");
#endif
}

void wxProjectionPanel::OnSave(wxCommandEvent& /*event*/)
{
#ifdef BIAS_HAVE_XML2
  wxFileDialog dlg(NULL, wxT("Save Projection"), wxT(""), wxT(""), wxT("*.*"), wxFD_SAVE);
  if (dlg.ShowModal() == wxID_OK)
  {
    if (GetProjection().XMLWrite(WxToAscii(dlg.GetPath())) != 0)
    {
      wxMessageDialog dlg(this, wxT("Failed to save projection"), wxT("Error"));
      dlg.ShowModal();
    }
  }
#else
  BIASERR("XML2 missing");
#endif
}