biasGLviewerGLUT.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 "biasGLviewerGLUT.hh"
#include <algorithm>
#include <iostream>
#include <Utils/IOUtils.hh>

#ifdef BIAS_HAVE_OPENSCENEGRAPH
#include <osg/ShapeDrawable>
#include <osg/Group>
#endif //BIAS_HAVE_OPENSCENEGRAPH

using namespace std;
using namespace BIAS;

void AnimFuncWrapper();
biasGLviewerGLUT* viewerObjPointer = NULL;

biasGLviewerGLUT::
biasGLviewerGLUT(int argc, char* argv[])
{
  initialized_ = false;
  animate_ = false;
  storeToDisc_ = false;
  renderBoundingBoxes_ = false;
  
  slotCounter_ = 0;
  viewingSlot_ = 0;
  contextPointer_ = NULL;
 
  // Animation / Control Params
  int groupID = GetFreeGroupID();
  //animationFile_ = AddParamString(
  //  "anim", "animation file", "", 'a', groupID);
  //fixedFPS_ = AddParamDouble(
  //  "fps", "set a fixed fps for animation", 25, 1, 1000, 'f', groupID);
  useFlyMode_ = AddParamBool(
     "fly", "set mouse control to fly mode", false, 0 ,groupID);
  useRotMode_ = AddParamBool(
     "onlyRot", "turn only rotation for mouse control on", false, 0, groupID);
  SetGroupName(groupID, "Animation / Control");
  
  // View Params
  groupID = GetFreeGroupID();
  zNear_ = AddParamDouble(
     "zNear", "set near clipping plane distance, overrides autoClipping", 0.001, 0.000001, DBL_MAX, 0 ,groupID);
  zFar_ = AddParamDouble(
     "zFar", "set near clipping plane distance, overrides autoClipping", 10000, 0.00001, DBL_MAX, 0, groupID);
  fov_ = AddParamDouble(
     "fov", "field of view in degree", 0, 0, 359.9, 0, groupID);
  autoClipping_ = AddParamBool(
     "autoClipping", "turns auto clipping on/off", true, 0 , groupID);
  backfaceCulling_ = AddParamBool(
     "backfaceCulling", "do not draw back faces of triangles?", false, 0, groupID);
  teapot_ = AddParamBool(
     "teapot", "Add a glut teapot to scene", false, 0, groupID);
  cube_ = AddParamBool(
      "cube", "Add a glut cube to scene", false, 0, groupID);
  tetrahedron_ = AddParamBool(
      "tetrahedron", "Add a glut tetrahedron to scene", false, 0, groupID);
  icosahedron_ = AddParamBool(
       "icosahedron", "Add a glut  icosahedron to scene", false, 0, groupID);
  
  SetGroupName(groupID, "View");

  // Camera Params
  groupID = GetFreeGroupID(); 
  projectionFile_ = AddParamString(
     "projection", "load camera parameters from this file, sets findSceneCenter to false if useJustIntrinsics is false (default)", 
     "", 'p', groupID);
  useSceneCenter_ = AddParamBool(
     "findSceneCenter", "sets camera to center of scene", 
     true, 0, groupID);
  useJustIntrinsics_ = AddParamBool(
     "useJustIntrinsics", "uses only intrinsics from loaded projection", 
     false, 0, groupID);

  // create values for reshape behaviour
  std::vector<std::string> reshapeBehaviour;
  reshapeBehaviour.push_back("Deny");
  reshapeBehaviour.push_back("AutoRescaleParams");
  reshapeBehaviour.push_back("AutoCutImage");
  reshapeBehaviour.push_back("AutoSimplePerspectiveCam");

  autoReshapeBehaviour_ = AddParamEnum(
     "reshapeBehaviour", "sets the automatic reshape behaviour of the camera",
     reshapeBehaviour, 1,NULL, 0, groupID);
  SetGroupName(groupID, "Camera");

  // Misc Params
  groupID = GetFreeGroupID();
  winwidth_ = AddParamInt(
     "winwidth", "window width", 640, 0, INT_MAX, 'w', groupID);
  winheight_ = AddParamInt(
     "winheight", "window width", 480, 0, INT_MAX, 'h', groupID);
  screenShotName_ = AddParamString(
     "screenShotName", "name for screenshots default is 'screenShot'", "screenShot", 0, groupID);
  backGroundColor_ = AddParamVecDbl(
     "bgColor", "set background clear color", "200.0 230.0 230.0", 0, groupID); 
  
  bool ret = IOUtils::ParseCommandLineEvalHelp(*this,argc, argv,firstUnkownParam_);
  if(!ret) BIASWARN("Parsing command line arguments failed. Please check them!");
  argc_ = argc;
  argv_ = argv;
}


void biasGLviewerGLUT::
Init()
{
  // init projection and window size
  unsigned int winwidth = *winwidth_, winheight = *winheight_;
  if(*projectionFile_ == "") {   
        Vector3<double> C(0.0,0.0,0.0);
        Quaternion<double> Q(0.0,0.0,0.0,1.0);
        GLProjectionParametersPerspective* ppp = new GLProjectionParametersPerspective;
        ppp->SetSimplePerspectiveCam(65.0,winwidth,winheight);
        cout<<"Setting simple perspective camera with: 65 degrees fov and:"
                <<winwidth<<"x"<<winheight<<" pixel."<<endl;
        ppp->SetExtrinsics(C,Q);
        camera_.Assign(*ppp);
  }
  else {    
    // when projection with extrinsics is loaded no scene center is used
    if (!(*useJustIntrinsics_)) {        
      *useSceneCenter_ = false;
    } 
    Projection proj;

#ifdef BIAS_HAVE_XML2
    if (proj.XMLRead(*projectionFile_) != 0) {
#else
    if (proj.Load(*projectionFile_) != 0) {
#endif
      BIASERR("could not read projection file!\n");
      exit(0);
    }
    else
      camera_.Assign(*proj.GetParameters());
  }
  unsigned int width, height;
  camera_.GetMyselfAsProjectionParameterBase()->GetImageSize(width, height);
  
  if(winwidth == 0)
    winwidth = width;
  if(winheight == 0)
    winheight = height;
  
  // init Glut Context
  contextPointer_ = 
    new ContextGLUT(0,0, winwidth, winheight, 
                    "BIASOpenGLViewerGlut", NULL, &argc_, argv_); 

  //check if a value was entered for clipping planes and set auto to false
  if(*zFar_ != 10000 || *zNear_ != 0.001)
    contextPointer_->SetAutoClipping(false);
  else
    contextPointer_->SetAutoClipping(*autoClipping_);

  // set background color
  Vector4<float> clearColor((float)((*backGroundColor_)[0]),
                            (float)((*backGroundColor_)[1]),
                            (float)((*backGroundColor_)[2]),
                            0.0);
  contextPointer_->SetClearColor(clearColor);

  // init Clipping Planes
  camera_.SetZClippingPlanes(*zNear_, *zFar_);

  // init screen shor control
  screenShotControl_.Init(contextPointer_, *screenShotName_, "ppm", "", true);

  sceneLight_.SetLightAsHeadLight(false);
  sceneLight_.SetDrawLightPosition(false);
  sceneLight_.SetAmbient(Vector4<double>(0.3,0.3,0.3,1.0));
  sceneLight_.SetDiffuse(Vector4<double>(1.0,1.0,1.0,1.0));
  sceneLight_.SetSpecular(Vector4<double>(1.0,1.0,1.0,1.0));
  contextPointer_->AppendScene(&sceneLight_);
  
#ifdef BIAS_HAVE_OPENSCENEGRAPH
  // init and load scene
  scene_.Init();  
  bool hasModel = false;
  
  if(argc_ - firstUnkownParam_ >= 1 && firstUnkownParam_ > 0) {
    for(int i=0;i< (argc_ - firstUnkownParam_);i++){    
        cout<<"loading "<<argv_[firstUnkownParam_+i]<< "... \n"; cout.flush();
        if(scene_.AppendSubTreeFromFile(argv_[firstUnkownParam_+i])!=0)
            cout<<" failed\n";
        else{
            cout<<" success\n";
            hasModel = true;
        }
    }
  }

  if(!hasModel && ! (*teapot_) && ! (*cube_)
         && ! (*icosahedron_) && ! (*tetrahedron_)) {   
    osg::ShapeDrawable *sphere =
      new osg::ShapeDrawable(new osg::Sphere(osg::Vec3(0., 0., 0.), 2.0));
    const osg::Vec4 color(139.0/255.0,248.0/255.0,244.0/255.0,0);
    sphere->setColor(color);
    osg::Geode *n = new osg::Geode;
    n->addDrawable(sphere);
    scene_.AppendNode(n);
  }
  
  contextPointer_->AppendScene(&scene_);
  
#endif
  
  //append glut Scene
  sceneGlut_.SetDrawTeapot(*teapot_,0.4);
  sceneGlut_.SetDrawCube(*cube_,0.4);       
  sceneGlut_.SetDrawIcosahedron(*icosahedron_);
  sceneGlut_.SetDrawTetrahedron(*tetrahedron_);
  contextPointer_->AppendScene(&sceneGlut_);

  
  
  // set auto reshape behaviour of camera, default is AutoRescaleParams
  switch(*autoReshapeBehaviour_)
  {
    case 0:
      camera_.SetAutoReshapeBehaviour(GLProjectionParametersInterface::Deny);
      break;
    case 2:
      camera_.SetAutoReshapeBehaviour(GLProjectionParametersInterface::AutoCutImage);
      break;
    case 3:
      camera_.SetAutoReshapeBehaviour(GLProjectionParametersInterface::AutoSimplePerspectiveCam);
      break;
    default:
      camera_.SetAutoReshapeBehaviour(GLProjectionParametersInterface::AutoRescaleParams);
      break;
  }


  // init camera control
  contextPointer_->SetGLProjectionParametersInterface(&camera_);
  
  if(*useFlyMode_ && ! *useRotMode_) {
    contextPointer_->SetControl(&flyControl_);
  }
  else if (!*useFlyMode_ && ! *useRotMode_ ) {
    contextPointer_->SetControl(&control_);
    //DistanceMeaseureControl is also derived from Scenebase and draws itself
    contextPointer_->AppendScene(&control_);
  }
  else {
    contextPointer_->SetControl(&rotControl_);
  }

  // add listeners
  contextPointer_->AppendAdditionalListener(&screenShotControl_);
  contextPointer_->AppendAdditionalListener(this); //key listener

  // set camera center
  if(*useSceneCenter_) {
    BIAS::Vector3<double> CameraCenter, radius, SceneCenter;
    if (!contextPointer_->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) {
      camera_.GetMyselfAsProjectionParameterBase()->SetC(CameraCenter);
      control_.SetPointOfInterest(SceneCenter);
    } else {
      cerr<<"could not set poi, empty scene ?"<<endl;
    }
  }

  // backface culling
  if (*backfaceCulling_)
    glEnable(GL_CULL_FACE);
  else
    glDisable(GL_CULL_FACE);

  initialized_ = true;
}

void biasGLviewerGLUT::
Run()
{
  if (initialized_) glutMainLoop();
  else cout << "Run Init() first!" << endl;
}


bool biasGLviewerGLUT::
StandardKeyPressed(unsigned char key, int, int)
{
  static int pointSizeG = 1;
  static bool twosided = false;
  switch(key) {
  case 'b':
    renderBoundingBoxes_ = !renderBoundingBoxes_;
    cout<<"switched bounding box rendering "
    << (renderBoundingBoxes_? "on" : "off")<<endl;
    contextPointer_->GlobalBoundingBoxSwitch(renderBoundingBoxes_);
    break;
  case 'q':
    exit(0);
    break;
  case '0' :
    viewingSlot_ = 0;
    cout<<"camera->SetActiveSlot(0)"<<endl;
    break;
  case 'z':   glPolygonMode( GL_FRONT_AND_BACK, GL_POINT);
    cout << "PolygonMode: Point." << endl;
    break;
  case 'x':   glPolygonMode( GL_FRONT_AND_BACK, GL_LINE);
    cout << "PolygonMode: Line." << endl;
    break;
  case 'c':   glPolygonMode( GL_FRONT_AND_BACK, GL_FILL);
    cout << "PolygonMode: Fill." << endl;
    break;
  case 'Z':   glShadeModel(GL_SMOOTH);
    cout << "Shading Smooth." << endl;
    break;
  case 'X': glShadeModel(GL_FLAT);
    cout << "Shading Flat." << endl;
    break;
  case 'T':
    if(!twosided) {
      glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
      twosided = true;
    } else {
      glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
      twosided = false;
    }
    cout << "Two-sided lighting is " << (twosided ? "on" : "off")
     << "." << endl;
    break;

  case ']':
    pointSizeG++;
    cout<<"Point/Line Size increasing:"<<pointSizeG<<endl;
    glPointSize(pointSizeG);
    glLineWidth(pointSizeG);
    break;
  case '[':
    pointSizeG--;
    if (pointSizeG<1) pointSizeG=1;
    cout<<"Point/Line Size decreasing:"<<pointSizeG<<endl;
    glPointSize(pointSizeG);
    glLineWidth(pointSizeG);
    break;
  case 'G':SceneBase::SetAnimationSpeed(1.0); 
    cout<<"Enabling Animation/Collision in SceneBase. Speed = 1"<<endl;
    break;
  case 'g':SceneBase::SetAnimationSpeed(0.0);
    cout<<"Disabling Animation/Collision in SceneBase."<<endl;
    break;
  case 'a':
    animate_ = true;
    glutIdleFunc(AnimFuncWrapper);
    break;
  case 's':
    animate_ = false;
    glutIdleFunc(NULL);
    break;
  case 'S':
    toggleStoreToDisc_();
    break;
  case 'h' :
    cout<<"\n Application specific controls: \n\n";
    cout<<"\t +   : Increase TimeStep\n";
    cout<<"\t -   : Decrease TimeStep\n";
    cout<<"\t n   : switch view to next slot\n";
    cout<<"\t 0   : switch view to slot 0\n";
    cout<<"\t a   : start/resume animation\n";
    cout<<"\t s   : stop animation\n";
    cout<<"\t g/G : enable/disable SceneBase animation/collision"<<endl;
    cout<<"\t S   : store images to disc, resume with next slot when done\n";
    cout<<"\t T   : toggle two-sided lighting\n";
    cout<<"\t m   : toggle the distance measurement control\n";
    cout<<"\t P   : Print current camera info \n";
    cout<<"\t q   : quit \n";
    cout<<"\t b   : toggle bounding box rendering\n";
    cout<<"\t []  : increase/decrease point/line size\n";
    cout<<"\t zxc : toggle polygon mode\n";
    cout<<"\t </> : decrerase/increase zFar \n";
    cout<<"\t ,/. : decrerase/increase zNear \n";
    cout<<"\t F5  : screenshot + depth\n";
    cout<<"\t F6  : camera params\n";
    break;
  case 'm':  
    control_.SetDistanceMeasure(! control_.GetDistanceMeasure());
    break;
  case 'P' :
    cout<<"Current Camera:"<<camera_<<endl;
    break;
  case '>' :
    *zFar_ *= (12.0)/(10.0);
    camera_.SetZClippingPlanes(*zNear_, *zFar_);
    cout<<"zFar = "<<*zFar_<<endl;
    break;
  case '<' :
    *zFar_ *= (10.0)/(12.0);
    cout<<"zFar = "<<*zFar_<<endl;
    camera_.SetZClippingPlanes(*zNear_, *zFar_);
    break;
  case ',':
    *zNear_ *= (10.0)/(12.0);
    cout<<"zNear = "<<*zNear_<<endl;
    camera_.SetZClippingPlanes(*zNear_, *zFar_);
    break;
  case '.':
    *zNear_ *= (12.0)/(10.0);
    cout<<"zNear = "<<*zNear_<<endl;
    camera_.SetZClippingPlanes(*zNear_, *zFar_);
    break;
  default:
    return false;
    break;
  }
  glutPostRedisplay();
  return true;
}

void biasGLviewerGLUT::
AnimationFunc() {
 /* if (!animate_) return;
  
  if(animator_.Animate()!=1) {
    if(storeToDisc_) {
      screenShotControl_.StoreScreenShot();
    }
    BIAS::RMatrix rmat;Vector3<double> C;
    camera_.GetAbsoluteExtrinsics(C,rmat);
    double PhiX, PhiY, PhiZ;
    rmat.GetRotationAnglesXYZ(PhiX, PhiY, PhiZ);
 
  } else {
    if(storeToDisc_) {
      if(slotCounter_ < camera_.GetNumSlots()-1) {
        slotCounter_++;
        
        animator_.Start();
      } else {
        toggleStoreToDisc_();
        slotCounter_ = 0;

     
      }
    }
  }
  */
}

void AnimFuncWrapper() {
  (*viewerObjPointer).AnimationFunc();
  glutPostRedisplay();
}


void biasGLviewerGLUT::
toggleStoreToDisc_() {
  storeToDisc_ = !storeToDisc_;
  if(storeToDisc_)
    cout<<"WRITING to disc ENABLED!\n";
  else
    cout<<"WRITING to disc DISABLED!\n";
}

int main(int argc, char* argv[])
{
  biasGLviewerGLUT viewer(argc,argv);
  viewerObjPointer = &viewer;
  viewer.Init();
  viewer.Run();
  return 0;
}