vpSimulator.h

/****************************************************************************
 *
 * $Id: vpSimulator.h 4056 2013-01-05 13:04:42Z fspindle $
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2013 by INRIA. All rights reserved.
 * 
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact INRIA about acquiring a ViSP Professional 
 * Edition License.
 *
 * See http://www.irisa.fr/lagadic/visp/visp.html for more information.
 * 
 * This software was developed at:
 * INRIA Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 * http://www.irisa.fr/lagadic
 *
 * If you have questions regarding the use of this file, please contact
 * INRIA at visp@inria.fr
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * Description:
 * Simulator based on Coin3d.
 *
 * Authors:
 * Eric Marchand
 * Anthony Saunier
 *
 *****************************************************************************/

#ifndef vpSimulator_HH
#define vpSimulator_HH

#include <visp/vpConfig.h>

#ifdef VISP_HAVE_COIN_AND_GUI

#include <visp/vpViewer.h>

/*   KNOWN ISSUE DEALING WITH X11 and QT
     If you get a strange compiler error on the line with None,
     it's probably because you're also including X11 headers,
     which #define the symbol None. Put the X11 includes after
     the Qt includes to solve this problem.
 */

#include <Inventor/nodes/SoBaseColor.h>
#include <Inventor/nodes/SoTransform.h>
#include <Inventor/nodes/SoCone.h>
#include <Inventor/nodes/SoCube.h>
#include <Inventor/nodes/SoImage.h>
#include <Inventor/nodes/SoLightModel.h>
#include <Inventor/nodes/SoPerspectiveCamera.h>
#include <Inventor/nodes/SoRotationXYZ.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoTranslation.h>
#include <Inventor/sensors/SoTimerSensor.h>
#include <Inventor/SoOffscreenRenderer.h>
#include <Inventor/fields/SoSFTime.h>
#include <Inventor/threads/SbThread.h>

// visp
#include <visp/vpDebug.h>
#include <visp/vpHomogeneousMatrix.h>
#include <visp/vpCameraParameters.h>
#include <visp/vpImage.h>
#include <visp/vpRGBa.h>
#include <visp/vpImageConvert.h>

class VISP_EXPORT vpSimulator
{
protected:
  void init() ;
  void kill() ;

public:
  vpSimulator() ;
  virtual ~vpSimulator() ;

protected:
#if defined(VISP_HAVE_SOWIN)
  HWND mainWindow ;
#elif defined(VISP_HAVE_SOQT)
  QWidget * mainWindow ;
#elif defined(VISP_HAVE_SOXT)
  Widget mainWindow ;
#endif

  bool mainWindowInitialized ;

  void initSoApplication() ;

public:
  typedef enum  {
    grayImage,
    colorImage
  } vpImageType ;
  vpImageType typeImage ;

  GLubyte * image_background;
  virtual   void mainLoop() ;

protected:
  vpViewer *internalView ;
  vpViewer *externalView ;

public:
  virtual void initInternalViewer(const unsigned int nlig, const unsigned int ncol) ;
  void initExternalViewer(const unsigned int nlig, const unsigned int ncol) ;

protected:
  SbThread * mainThread;
  //pthread_t mainThread;

public:
  void initApplication(void *(*start_routine)(void *)) ;
  void initApplication(void *(*start_routine)(void *), void* data);
  void initMainApplication() ;
  void closeMainApplication() ;

  //----------------------------------------------------
  // scene description
protected:
  unsigned int internal_width;
  unsigned int internal_height;
  unsigned int external_width;
  unsigned int external_height;

public:
  unsigned int getInternalWidth() const { return internal_width; }
  unsigned int getInternalHeight() const { return internal_height; }

protected:
  SoSeparator *scene;
  SoSeparator *internalRoot;
  SoSeparator *externalRoot;

  SoPerspectiveCamera *internalCamera ;
  SoPerspectiveCamera *externalCamera ;

  SoTransform *internalCameraPosition ;

  SoTransform *extrenalCameraPosition ;

  SoSeparator *internalCameraObject;

  void initSceneGraph() ;

  void addObject(SoSeparator * object, const vpHomogeneousMatrix &fMo,
         SoSeparator * root) ;

public :
  void addObject(SoSeparator * newObject, const vpHomogeneousMatrix &fMo) ;

public:
  void redraw() ;
  void load(const char *file_name) ;
  void load(const char *iv_filename,const vpHomogeneousMatrix &fMo) ;
  void save(const char *name,bool binary=false) ;

  void addAbsoluteFrame (float zoom=1) ;
  void addFrame (const vpHomogeneousMatrix &fMo, float zoom=1) ;
  void setZoomFactor (const float zoom) ;

protected:
  float zoomFactor ;
  //---------------------------------------------------
  //  camera description
protected:
  bool cameraPositionInitialized ;
  vpHomogeneousMatrix cMf ;
  vpCameraParameters internalCameraParameters ;
  vpCameraParameters externalCameraParameters ;

public:
  void setCameraPosition(vpHomogeneousMatrix &cMf) ;
  void getCameraPosition(vpHomogeneousMatrix &_cMf) { _cMf = cMf ; }
  void moveInternalCamera(vpHomogeneousMatrix &cMf) ;
  void setInternalCameraParameters(vpCameraParameters &cam) ;
  void setExternalCameraParameters(vpCameraParameters &cam) ;
  void getExternalCameraPosition(vpHomogeneousMatrix &cMf) ;

  void getInternalImage(vpImage<unsigned char> &I) ;
  void getInternalImage(vpImage<vpRGBa> &I) ;
  /* --- Off screen rendering  --- */
  
  void changeZoomFactor(const float zoom, const int index);
public:
  typedef enum { INTERNAL, EXTERNAL } vpSimulatorViewType ;
  void  write(const char * fileName);
protected:
  SbTime * realtime ;
  SoOffscreenRenderer * offScreenRenderer ;
  void offScreenRendering (vpSimulatorViewType view=vpSimulator::EXTERNAL,
               int * width = NULL,
               int * height = NULL);
public:
  unsigned char * bufferView;

  int get ;
public:
  unsigned char* getBufferedOffScreenRenderer()
  {
    return bufferView;
  }

  void getSizeInternalView(int& width, int& height);

  void getCameraParameters(vpCameraParameters &cam)
  {
    cam = internalCameraParameters;
  }
} ;


#endif
#endif