vpSimulator.h

/*
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2024 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 https://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.
 */
 
#ifndef VP_SIMULATOR_H
#define VP_SIMULATOR_H
#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>
 
BEGIN_VISP_NAMESPACE
 
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 = nullptr, int *height = nullptr);
 
public:
  unsigned char *bufferView;

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

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

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