vpSimulator.h

/****************************************************************************
 *
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2019 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 as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 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://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * 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 <visp3/core/vpConfig.h>

#ifdef VISP_HAVE_COIN3D_AND_GUI

#include <visp3/ar/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/SoOffscreenRenderer.h>
#include <Inventor/fields/SoSFTime.h>
#include <Inventor/nodes/SoBaseColor.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/SoTransform.h>
#include <Inventor/nodes/SoTranslation.h>
#include <Inventor/sensors/SoTimerSensor.h>
#include <Inventor/threads/SbThread.h>

// visp
#include <visp3/core/vpCameraParameters.h>
#include <visp3/core/vpDebug.h>
#include <visp3/core/vpHomogeneousMatrix.h>
#include <visp3/core/vpImage.h>
#include <visp3/core/vpImageConvert.h>
#include <visp3/core/vpRGBa.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(unsigned int nlig, unsigned int ncol);
  void initExternalViewer(unsigned int nlig, 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(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(float zoom, int index);

public:
  typedef enum { INTERNAL, EXTERNAL } vpSimulatorViewType;
#ifdef VISP_HAVE_MODULE_IO
  void write(const char *fileName);
#endif
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