dd/d6f/ExampleContextWx_8cpp-example.html

/*

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

*/


/**

   @example ExampleContextWx.cpp

   @relates ContextWX, GLProjectionParametersPerspective, SceneOpenSceneGraph

   @brief Example for usage ContextWX, GLProjections and Scenes

   @ingroup g_examples

   @ingroup g_glviewer

   @author MIP, ischiller 02/2010

*/


#include <Base/Common/BIASpragmaStart.hh>

#include <wx/wx.h>

#include <wx/aboutdlg.h>

#include <wx/filename.h>

#include <wx/artprov.h>

#include <Base/Common/BIASpragmaEnd.hh>


#include <Base/Image/Image.hh>

#include <Base/Image/ImageIO.hh>

#include <Base/Common/FileHandling.hh>

#include <Gui/StringConv.hh>

#include <GLviewer/ContextWX.hh>

#include <GLviewer/Scenes/SceneBGImage.hh>

#ifdef BIAS_HAVE_OPENSCENEGRAPH

#include <GLviewer/Scenes/SceneOpenSceneGraph.hh>

#endif

#include <GLviewer/GLProjectionParametersPerspective.hh>

#include <GLviewer/Controller/DistanceMeasureControl.hh>


using namespace BIAS;

using namespace std;


/////////////////////////////////////

//////////    the window   //////////

/////////////////////////////////////

/**

 * \cond HIDDEN_SYMBOLS

 */

class CWxFrame : public wxFrame

{


public:


  CWxFrame(wxWindow *parent, const wxString& title);


  void OnOpen(wxCommandEvent &event);

  void OnQuit(wxCommandEvent &event);

  void OnScreenshot(wxCommandEvent& event);

  void OnViewSize(wxCommandEvent& event);

  void OnAbout(wxCommandEvent &event);

  void OnScreenInfo(wxCommandEvent &event);


  void OnResize(wxSizeEvent &event);


  void LateInit();


protected:

    BIAS::DistanceMeasureControl control_;

  ContextWX* DummyContext_;

  ContextWX* Context_;

#ifdef BIAS_HAVE_OPENSCENEGRAPH

  SceneOpenSceneGraph* Scene_;

#endif

  SceneBGImage BGImage_;

  Image<unsigned char> LogoBG_;

  GLProjectionParametersPerspective*  Proj_;


  bool SizeLocked_;


  enum {

    ID_Whatever = wxID_HIGHEST + 42,

    ID_Screenshot,

    ID_VS_Free,

    ID_VS_640,

    ID_VS_800,

    ID_VS_16_9,

    ID_VS_16_10,

    ID_ScreenInfo

  };


private:


  void DumpSizes_();

  void FitToImageSize_();


  wxMenuBar* Menubar_;

  wxToolBar* Toolbar_;

  wxStatusBar* Statusbar_;

  DECLARE_EVENT_TABLE()


};

/** \endcond */


BEGIN_EVENT_TABLE(CWxFrame, wxFrame)

    EVT_MENU(wxID_OPEN, CWxFrame::OnOpen)

    EVT_MENU(wxID_EXIT, CWxFrame::OnQuit)

    EVT_MENU(wxID_ABOUT, CWxFrame::OnAbout)

    EVT_MENU(ID_Screenshot, CWxFrame::OnScreenshot)

    EVT_MENU(ID_VS_Free, CWxFrame::OnViewSize)

    EVT_MENU(ID_VS_640, CWxFrame::OnViewSize)

    EVT_MENU(ID_VS_800, CWxFrame::OnViewSize)

    EVT_MENU(ID_VS_16_9, CWxFrame::OnViewSize)

    EVT_MENU(ID_VS_16_10, CWxFrame::OnViewSize)

    EVT_MENU(ID_ScreenInfo, CWxFrame::OnScreenInfo)

    EVT_SIZE(CWxFrame::OnResize)

END_EVENT_TABLE()


CWxFrame::CWxFrame(wxWindow *parent, const wxString& title)

: wxFrame(parent, wxID_ANY, title),

  Context_(NULL), Proj_(NULL),

  SizeLocked_(false)

{

#ifdef BIAS_HAVE_OPENSCENEGRAPH

    Scene_ = NULL;

#endif

  int ContextAttribs[] = {  WX_GL_RGBA,

                WX_GL_LEVEL, 0,

                WX_GL_MIN_RED, 1,

                WX_GL_MIN_GREEN, 1,

                WX_GL_MIN_BLUE, 1,

                WX_GL_MIN_ALPHA, 1,

                WX_GL_DEPTH_SIZE, 24,

                WX_GL_STENCIL_SIZE, 8,

                WX_GL_DOUBLEBUFFER, 0 };

  DummyContext_ = new ContextWX( this, wxID_ANY,

                 wxDefaultPosition, wxSize(640, 480), 0,

                 wxT("GLCanvas"),ContextAttribs);

  DummyContext_->SetBlending(false);

  DummyContext_->SetBackfaceCulling(false);

  DummyContext_->SetMinSize( wxSize( 320,240 ) );


  // create a status bar

  Statusbar_ = this->CreateStatusBar( 2, wxST_SIZEGRIP, wxID_ANY );

  const int numFields = 2;

  Statusbar_->SetFieldsCount(numFields);

  const int widths[numFields] = { -1, 170 };

  Statusbar_->SetStatusWidths(numFields, widths);


  // create a tool bar

  Toolbar_ = this->CreateToolBar( wxTB_HORIZONTAL, wxID_ANY );

  Toolbar_->SetToolBitmapSize( wxSize( 24,24 ) );

  Toolbar_->SetToolSeparation( 0 );

  Toolbar_->SetToolPacking( 0 );

  Toolbar_->AddTool( ID_ScreenInfo, wxT("Screen Info"),

             wxArtProvider::GetIcon(wxART_INFORMATION,wxART_TOOLBAR) );

  Toolbar_->AddTool( wxID_OPEN, wxT("Open File"),

             wxArtProvider::GetIcon(wxART_FILE_OPEN ,wxART_TOOLBAR) );


  Toolbar_->Realize();


  // create a menu bar

  wxMenu *menuFile = new wxMenu;

  menuFile->Append(wxID_OPEN);

  menuFile->AppendSeparator();

  menuFile->Append(wxID_EXIT);

  wxMenu *menuEdit = new wxMenu;

  menuEdit->Append(ID_Screenshot, wxString(wxT("&Screenshot")) + wxT('\t') + wxT("F3"));

  wxMenu *menuView = new wxMenu;

  menuView->AppendRadioItem(ID_VS_Free, wxString(wxT("View Size &Free")) + wxT('\t') + wxT("CTRL-SHIFT-0"));

  menuView->AppendRadioItem(ID_VS_640, wxString(wxT("View Size 4:3 &small")) + wxT('\t') + wxT("CTRL-SHIFT-1"));

  menuView->AppendRadioItem(ID_VS_800, wxString(wxT("View Size 4:3 &medium")) + wxT('\t') + wxT("CTRL-SHIFT-2"));

  menuView->AppendRadioItem(ID_VS_16_9, wxString(wxT("View Size 16:&9 medium")) + wxT('\t') + wxT("CTRL-SHIFT-3"));

  menuView->AppendRadioItem(ID_VS_16_10, wxString(wxT("View Size 16:&10 medium")) + wxT('\t') + wxT("CTRL-SHIFT-4"));

  wxMenu *menuHelp = new wxMenu;

  menuHelp->Append(wxID_ABOUT);

  Menubar_ = new wxMenuBar;

  Menubar_->Append(menuFile, wxT("&File"));

  Menubar_->Append(menuEdit, wxT("&Edit"));

  Menubar_->Append(menuView, wxT("&View"));

  Menubar_->Append(menuHelp, wxT("&Help"));


  SetMenuBar(Menubar_);

  wxBoxSizer* mainSizer = new wxBoxSizer(wxVERTICAL);

  mainSizer->Add(Context_, 1, wxEXPAND|wxALL|wxALIGN_CENTRE, 0);


  /// this is the problem

  //SetMinSize(wxSize(400,390));


  SetSizer(mainSizer);

  mainSizer->Fit(this);

  Layout();


  Proj_ = new GLProjectionParametersPerspective( /*offscreen*/);

}


void CWxFrame::

LateInit()

{

  Context_ = DummyContext_;

  //Context_->AppendAdditionalListener(&Handler_);

  LogoBG_.Init(400, 300, 3);

  LogoBG_.FillImageWithConstValue(120);

  BGImage_.SetImage(LogoBG_);

  Context_->MakeGLContextCurrent();

  Context_->SetBlending(false);


  // use special background image mode, which bypasses also fisheye rendering

  // doesn't seem to work with distortion mapping

  Context_->SetBackgroundImageScene(&BGImage_);

#ifdef BIAS_HAVE_OPENSCENEGRAPH

  Scene_ = new SceneOpenSceneGraph;

  BIASASSERT(Scene_);

  if(Scene_->Init()!=0)

  {

    cerr<<"Scene_ init failed !!!"<<endl;

  }

  Scene_->SetActive(false);

  Scene_->HeadlightSwitch(true);

  Context_->AppendScene(Scene_);


#else

  BIASWARN("Need OpenSceneGraph to show something")

#endif


  Proj_->SetSimplePerspectiveCam(40.0);

  Proj_->SetAutoReshapeBehaviour(GLProjectionParametersBase::AutoRescaleSimple);

  Context_->SetGLProjectionParametersInterface(Proj_);

  Context_->SetControl(&control_);

  //DistanceMeaseureControl is also derived from Scenebase and draws itself

  Context_->AppendScene(&control_);


  Context_->PrintGLStatus();

  Context_->InitializationComplete();


  Context_->SetAutoClipping(true);

  Context_->SetAutoClipMinZNear(0.1);


  // background color (yellow: 1.0f, 1.0f, 0.0f, 0.0f)

  Vector4<float> bg(1.0f, 1.0f, 0.0f, 0.0f);

  Context_->SetClearColor(bg);


  FitToImageSize_();

}


void CWxFrame::

OnResize(wxSizeEvent &event)

{

  cout << "size event: window size \t("

       << GetSize().GetWidth() << " x " << GetSize().GetHeight() << ")\n";

  event.Skip();

}


void CWxFrame::

OnOpen(wxCommandEvent &event)

{

#ifdef BIAS_HAVE_OPENSCENEGRAPH

    wxString fileName;

        wxFileDialog

                dialog(

                        this,

                        wxT("Load Model"),

                        wxT(""),

                        wxT(""),

                        wxT("Model files (*.wrl;*.dae;*.osg;*.3ds;)|*.wrl;*.dae;*.osg;*.3ds;|All files (*.*)|*.*"),

                        wxFD_OPEN);

        int ret = dialog.ShowModal();

        if (ret == wxID_OK) {

            ret = Scene_->AppendSubTreeFromFile(WxToAscii(dialog.GetPath()));

        }

        if (ret != 0){

            stringstream text;

            text<<"Error, model could not be loaded";

            wxMessageBox(AsciiToWx(text.str()),wxT("Error"), wxOK | wxICON_ERROR, this);

        }

        else{

            BIAS::Vector3<double> CameraCenter, radius, SceneCenter;

            if (!Context_->GetSceneCenter(SceneCenter, radius))

                BIASERR("could not retrieve bounding box from scene");

            // move 10% outwards

            CameraCenter = SceneCenter + 1.1 * radius;

            cout<<"using scene center "<<SceneCenter<<" and new camera center "

            <<CameraCenter <<endl;

            // set point of interest only if not equal to camera center

            if ((CameraCenter-SceneCenter).NormL2()>0.001) {

                Proj_->GetMyselfAsProjectionParameterBase()->SetC(CameraCenter);

                control_.SetPointOfInterest(SceneCenter);

            } else {

                cerr<<"could not set poi, empty scene ?"<<endl;

            }

            Context_->Refresh();

        }

#else

        stringstream text;

        text<<"Error, BIAS does not have OpenSceneGraph to load models!";

        wxMessageBox(AsciiToWx(text.str()),wxT("Error"), wxOK | wxICON_ERROR, this);

#endif

  event.Skip();

}


void CWxFrame::

OnQuit(wxCommandEvent &event)

{

  Close();

}


void CWxFrame::

OnViewSize(wxCommandEvent& event)

{

  FitToImageSize_();

}


void CWxFrame::

OnScreenInfo(wxCommandEvent &event)

{

  BIASASSERT(Context_);

  BIASASSERT(Proj_);

  Image<unsigned char> shot;

  Context_->MakeGLContextCurrent();

  Proj_->GetImage(shot);

  unsigned w,h;

  Proj_->GetImageSize(w, h);


  wxString msg = wxT("Context size is ");

  msg << Context_->GetSize().GetWidth() << wxT(" x ")

      << Context_->GetSize().GetHeight();

  msg << wxT("\n") << wxT("Projection size is ");

  msg << w << wxT(" x ") << h;

  msg << wxT("\n") << wxT("Screenshot size will be ");

  msg << shot.GetWidth() << wxT(" x ") << shot.GetHeight();


  wxMessageBox(msg, wxT("Example ContextWX - Screen Info"),

           wxOK | wxICON_INFORMATION, this);


}


void CWxFrame::

OnScreenshot(wxCommandEvent& event)

{

  BIASASSERT(Context_);


  Image<unsigned char> shot;

  Context_->MakeGLContextCurrent();

  Proj_->GetImage(shot);


  wxFileDialog dlg(this, _("Example ContextWX - Save Screenshot"),

           wxGetCwd(), wxT("ContextScreenshot"),

           _("PNG (*.png)|*.png|JPEG (*.jpg)|*.jpg"),

           wxFD_SAVE | wxFD_OVERWRITE_PROMPT | wxFD_CHANGE_DIR);

  if ( dlg.ShowModal() != wxID_OK) return;


  wxFileName fname( dlg.GetPath() );


  if ( !fname.HasExt() ) {

    int idx = dlg.GetFilterIndex();

    switch (idx) {

    case 1:

      fname.SetExt(_("jpg"));

      break;

    default:

      fname.SetExt(_("png"));

      break;

    }

  }


  int res = -1;

  if ( fname.GetExt() == wxT("jpg") ) {

    res = ImageIO::Save(WxToFilenames(fname.GetFullPath()), shot, ImageIO::FF_jpg);

  }

  if ( fname.GetExt() == wxT("png") ) {

    res = ImageIO::Save(WxToFilenames(fname.GetFullPath()), shot, ImageIO::FF_png);

  }

  if ( res != 0 ) {

    wxMessageBox(wxT("Saving screenshot failed!"), wxT("Error"),

         wxOK | wxICON_ERROR, this);

  }

}


void CWxFrame::

OnAbout(wxCommandEvent &event)

{

  wxString desc;

  desc << wxT(" This example is part of the\n");

  desc << wxT(" BIAS library (Basic ImageAlgorithmS)\n");

  wxString lic = wxT("BIAS is free software; you can redistribute it and/or modify\n \

it under the terms of the GNU Lesser General Public Licence as published by\n \

the Free Software Foundation; either version 2.1 of the Licence, or\n \

(at your option) any later version.\n \

\n \

BIAS is distributed in the hope that it will be useful,\n \

but WITHOUT ANY WARRANTY; without even the implied warranty of\n \

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n \

GNU Lesser General Public Licence for more details.\n \

\n \

You should have received a copy of the GNU Lesser General Public Licence\n \

along with BIAS; if not, write to the Free Software\n \

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n");


  wxAboutDialogInfo aboutdlg;

  aboutdlg.SetDescription( desc );

  aboutdlg.SetLicence( lic );

  aboutdlg.SetCopyright( wxT("Copyright (C) 2003-2010\n \

  Multimediale Systeme der Informationsverarbeitung\n \

  Institut fuer Informatik\n \

  Christian-Albrechts-Universitaet Kiel") );

  aboutdlg.SetWebSite( wxT("http://www.mip.informatik.uni-kiel.de/") );


  wxAboutBox( aboutdlg );

}


void CWxFrame::

DumpSizes_()

{

  static unsigned run = 0;

  cout << "\n****** loads of sizes (no. " << run++ << ") *****\n";

  cout << "size locked? " << boolalpha << SizeLocked_ << endl;

  cout << "window size \t(" << GetSize().GetWidth() << " x " << GetSize().GetHeight() << ")\n";

  cout << "client size \t(" << GetClientSize().GetWidth() << " x " << GetClientSize().GetHeight() << ")\n";

  cout << "menubar size \t(" << Menubar_->GetSize().GetWidth() << " x " << Menubar_->GetSize().GetHeight() << ")\n";

  cout << "toolbar size \t(" << Toolbar_->GetSize().GetWidth() << " x " << Toolbar_->GetSize().GetHeight() << ")\n";

  cout << "statusbar size \t(" << Statusbar_->GetSize().GetWidth() << " x " << Statusbar_->GetSize().GetHeight() << ")\n";

  cout << "context size \t(" << Context_->GetSize().GetWidth() << " x " << Context_->GetSize().GetHeight() << ")\n";

  Context_->MakeGLContextCurrent();

  Context_->Render();

  if (Proj_ != NULL) {

    unsigned w,h;

    Proj_->GetImageSize(w,h);

    cout << "projection image \t(" << w << " x " << h << ")\n";

  }

  Image<unsigned char> img;

  Context_->GetImage(img);

  cout << "context image \t(" << img.GetWidth() << " x " << img.GetHeight() << ")\n";


}


void CWxFrame::

FitToImageSize_()

{

  cout << "++++ fitting ++++" << endl;

  BIASASSERT(Context_);

  DumpSizes_();

  //wxSize windowSize = this->GetSize();

  //wxSize clientSize = this->GetClientSize();

  wxSize contextSize = Context_->GetSize();

  SizeLocked_ = false;

  //int barsHeight = 0; barsHeight = Menubar_->GetSize().GetHeight() + Toolbar_->GetSize().GetHeight()

  //  + Statusbar_->GetSize().GetHeight();


  if ( Menubar_->IsChecked(ID_VS_640) ) {

    SizeLocked_ = true;

    contextSize.Set(640, 480);

    //clientSize.Set(640, 480);

  }


  if ( Menubar_->IsChecked(ID_VS_800) ) {

    SizeLocked_ = true;

    contextSize.Set(800, 600);

    //clientSize.Set(800, 600);

  }


  if ( Menubar_->IsChecked(ID_VS_16_9) ) {

    SizeLocked_ = true;

    contextSize.Set(800, 450);

    //clientSize.Set(800, 450);

  }


  if ( Menubar_->IsChecked(ID_VS_16_10) ) {

    SizeLocked_ = true;

    contextSize.Set(800, 500);

    //clientSize.Set(800, 500);

  }


  if ( Menubar_->IsChecked(ID_VS_Free) ) {

    SizeLocked_ = false;

  }


  if ( SizeLocked_ ) {

    Context_->SetSize(contextSize);

    cout << "setting context size \t(" << Context_->GetSize().GetWidth() << " x " << Context_->GetSize().GetHeight() << ")\n";

    this->SetClientSize(contextSize);

  }

  else {

    wxSize minContextSize = Context_->GetMinSize();

    if ( contextSize.GetWidth() < minContextSize.GetWidth()

     || contextSize.GetHeight() < minContextSize.GetHeight() ) {

      contextSize = minContextSize;

      Context_->SetSize(contextSize);

    }

    this->SetClientSize(contextSize);

  }


  Fit();

  cout << "fit: context size \t(" << Context_->GetSize().GetWidth() << " x " << Context_->GetSize().GetHeight() << ")\n";

  //Layout();

  //Update();

  //DumpSizes_();

  wxString msg = wxT("Context size is ");

  msg << Context_->GetSize().GetWidth() << wxT(" x ")

      << Context_->GetSize().GetHeight();

  Statusbar_->SetStatusText(msg);

}


////////////////////////////////////////

//////////    main routine    //////////

////////////////////////////////////////

/** \cond HIDDEN_SYMBOLS */

class CWxApp : public wxApp

{


public:

  bool OnInit();


protected:


};

/** \endcond */


bool CWxApp::OnInit()

{

  wxInitAllImageHandlers();


  CWxFrame* mainFrame =

    new CWxFrame(NULL, wxT("Example ContextWX"));

  mainFrame->Show();


  mainFrame->LateInit();


  return true;


}


IMPLEMENT_APP(CWxApp)