vpImageSimulator.h

/*
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2025 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: Class which enables to project an image in the 3D space
 * and get the view of a virtual camera.
 *
 *
 * Authors:
 * Amaury Dame
 */
 
#ifndef vpImageSimulator_h
#define vpImageSimulator_h

 
#include <visp3/core/vpCameraParameters.h>
#include <visp3/core/vpColVector.h>
#include <visp3/core/vpConfig.h>
#include <visp3/core/vpHomogeneousMatrix.h>
#include <visp3/core/vpImage.h>
#include <visp3/core/vpPoint.h>
#include <visp3/core/vpRect.h>
#include <visp3/core/vpTriangle.h>
 
#include <list>
#include <vector>
 
BEGIN_VISP_NAMESPACE
class VISP_EXPORT vpImageSimulator
{
public:
  typedef enum { COLORED, GRAY_SCALED } vpColorPlan;
 
  typedef enum { SIMPLE, BILINEAR_INTERPOLATION } vpInterpolationType;
 
private:
  vpColVector X[4];
  vpHomogeneousMatrix cMt;
  vpColVector X2[4];
  std::vector<vpPoint> pt;
  std::vector<vpPoint> ptClipped;
 
  vpInterpolationType interp;
 
  // normal repere objet
  vpColVector normal_obj;
  // normal repere cam
  vpColVector normal_Cam;
  // normal repere cam sous forme de pointeur sinon vpColVector prend trop de
  // temps
  double *normal_Cam_optim;
 
  // distance du plan au centre de camera
  double distance;
  double visible_result;
  bool visible;
 
  // point 3D du plan definissant ou sera le pixel (0,0) de l'image
  double *X0_2_optim;
 
  // variable pour intersection algebre : vecteurs de la base 2D et leur norme
  double frobeniusNorm_u, fronbniusNorm_v;
 
  // 2 vecteur 3D (typiquement deux cotes du plan) qui definissent le repere
  // 2D u,v de l'image
  vpColVector vbase_u, vbase_v;
  // version pointeur des vecteurs de base
  double *vbase_u_optim;
  double *vbase_v_optim;
 
  // allocation memoire du point 3D d'intersection entre le vecteur
  // (centre_cam - point_plan_image) et le plan
  double *Xinter_optim;
 
  // triangles de projection du plan
  std::vector<vpTriangle> listTriangle;
 
  // image de texture
  vpColorPlan colorI;
  vpImage<unsigned char> Ig;
  vpImage<vpRGBa> Ic;
 
  vpRect rect;
  bool cleanPrevImage;
  bool setBackgroundTexture; // flag set when the background is to a texture
                             // using setBackGroundTexture()
  vpColor bgColor;
 
  vpColVector focal;
 
  // boolean to tell if the points in the camera frame have to be clipped
  bool needClipping;
 
public:
  VP_EXPLICIT vpImageSimulator(const vpColorPlan &col = COLORED);
  vpImageSimulator(const vpImageSimulator &text);
  virtual ~vpImageSimulator();
 
  vpImageSimulator &operator=(const vpImageSimulator &sim);
 
  // creation du plan a partir de ses coordonnees 3D ds repere objet et de son
  // image texture
  void init(const vpImage<unsigned char> &I, vpColVector *X);
  void init(const vpImage<vpRGBa> &I, vpColVector *X);
#ifdef VISP_HAVE_MODULE_IO
  void init(const char *file_image, vpColVector *X);
#endif
  void init(const vpImage<unsigned char> &I, const std::vector<vpPoint> &X);
  void init(const vpImage<vpRGBa> &I, const std::vector<vpPoint> &X);
#ifdef VISP_HAVE_MODULE_IO
  void init(const char *file_image, const std::vector<vpPoint> &X);
#endif
 
  // projection du plan par cMo => creation des deux triangles definissant
  // projection du plan sur plan image (coord en metre)
  void setCameraPosition(const vpHomogeneousMatrix &cMt);
 
  void setInterpolationType(const vpInterpolationType interplt) { this->interp = interplt; }
 
  void getImage(vpImage<unsigned char> &I, const vpCameraParameters &cam);
  void getImage(vpImage<vpRGBa> &I, const vpCameraParameters &cam);
 
  void getImage(vpImage<unsigned char> &I, vpImage<unsigned char> &Isrc, const vpCameraParameters &cam);
  void getImage(vpImage<vpRGBa> &I, vpImage<vpRGBa> &Isrc, const vpCameraParameters &cam);
 
  void getImage(vpImage<unsigned char> &I, const vpCameraParameters &cam, vpMatrix &zBuffer);
  void getImage(vpImage<vpRGBa> &I, const vpCameraParameters &cam, vpMatrix &zBuffer);
 
  static void getImage(vpImage<unsigned char> &I, std::list<vpImageSimulator> &list, const vpCameraParameters &cam);
  static void getImage(vpImage<vpRGBa> &I, std::list<vpImageSimulator> &list, const vpCameraParameters &cam);
 
  std::vector<vpColVector> get3DcornersTextureRectangle();
 
  friend VISP_EXPORT std::ostream &operator<<(std::ostream &os, const vpImageSimulator & /*ip*/);

  void setCleanPreviousImage(const bool &clean, const vpColor &color = vpColor::white)
  {
    cleanPrevImage = clean;
    bgColor = color;
  }

  inline void setBackGroundTexture(const vpImage<unsigned char> &Iback)
  {
    setBackgroundTexture = true;
    Ig = Iback;
  }
 
private:
  void initPlan(vpColVector *X);
 
  // result = plan est visible.
  // ie: un plan est oriente dans si normal_plan.focal < 0 => plan est visible
  // sinon invisible.
  bool isVisible() { return visible; }
 
  // function that project a point x,y on the plane, return true if the
  // projection is on the limited plane
  // and in this case return the corresponding image pixel Ipixelplan
  bool getPixel(const vpImagePoint &iP, unsigned char &Ipixelplan);
  bool getPixel(const vpImagePoint &iP, vpRGBa &Ipixelplan);
  bool getPixel(vpImage<unsigned char> &Isrc, const vpImagePoint &iP, unsigned char &Ipixelplan);
  bool getPixel(vpImage<vpRGBa> &Isrc, const vpImagePoint &iP, vpRGBa &Ipixelplan);
  bool getPixelDepth(const vpImagePoint &iP, double &Zpixelplan);
  bool getPixelVisibility(const vpImagePoint &iP, double &Zpixelplan);
 
  // operation 3D de base :
  void project(const vpColVector &_vin, const vpHomogeneousMatrix &_cMt, vpColVector &_vout);
  // donne coordonnes homogenes de _v;
  void getHomogCoord(const vpColVector &_v, vpColVector &_vH);
  // donne coordonnes _v en fction coord homogenes _vH;
  void getCoordFromHomog(const vpColVector &_vH, vpColVector &_v);
 
  void getRoi(const unsigned int &Iwidth, const unsigned int &Iheight, const vpCameraParameters &cam,
              const std::vector<vpPoint> &point, vpRect &rect);
};
END_VISP_NAMESPACE
#endif
 
/*
 * Local variables:
 * c-basic-offset: 2
 * End:
 */