vpRobot.cpp

/****************************************************************************
 *
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2023 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:
 * Generic virtual robot.
 *
*****************************************************************************/
 
#include <visp3/core/vpDebug.h>
#include <visp3/robot/vpRobot.h>
#include <visp3/robot/vpRobotException.h>
 
const double vpRobot::maxTranslationVelocityDefault = 0.2;
const double vpRobot::maxRotationVelocityDefault = 0.7;
 
/* -------------------------------------------------------------------------
 */
/* --- CONSTRUCTEUR --------------------------------------------------------
 */
/* -------------------------------------------------------------------------
 */
 
vpRobot::vpRobot(void)
  : stateRobot(vpRobot::STATE_STOP), frameRobot(vpRobot::CAMERA_FRAME),
    maxTranslationVelocity(maxTranslationVelocityDefault), maxRotationVelocity(maxRotationVelocityDefault), nDof(0),
    eJe(), eJeAvailable(false), fJe(), fJeAvailable(false), areJointLimitsAvailable(false), qmin(nullptr), qmax(nullptr),
    verbose_(true)
{
}
 
vpRobot::vpRobot(const vpRobot &robot)
  : stateRobot(vpRobot::STATE_STOP), frameRobot(vpRobot::CAMERA_FRAME),
    maxTranslationVelocity(maxTranslationVelocityDefault), maxRotationVelocity(maxRotationVelocityDefault), nDof(0),
    eJe(), eJeAvailable(false), fJe(), fJeAvailable(false), areJointLimitsAvailable(false), qmin(nullptr), qmax(nullptr),
    verbose_(true)
{
  *this = robot;
}
 
vpRobot::~vpRobot()
{
  if (qmin != nullptr) {
    delete[] qmin;
    qmin = nullptr;
  }
  if (qmax != nullptr) {
    delete[] qmax;
    qmax = nullptr;
  }
}
 
vpRobot &vpRobot::operator=(const vpRobot &robot)
{
  stateRobot = robot.stateRobot;
  frameRobot = robot.frameRobot;
  maxTranslationVelocity = robot.maxTranslationVelocity;
  maxRotationVelocity = robot.maxRotationVelocity;
  nDof = robot.nDof;
  eJe = robot.eJe;
  eJeAvailable = robot.eJeAvailable;
  fJe = robot.fJe;
  fJeAvailable = robot.fJeAvailable;
  areJointLimitsAvailable = robot.areJointLimitsAvailable;
  qmin = new double[nDof];
  qmax = new double[nDof];
  for (int i = 0; i < nDof; i++) {
    qmin[i] = robot.qmin[i];
    qmax[i] = robot.qmax[i];
  }
  verbose_ = robot.verbose_;
 
  return (*this);
}
vpColVector vpRobot::saturateVelocities(const vpColVector &v_in, const vpColVector &v_max, bool verbose)
{
  unsigned int size = v_in.size();
  if (size != v_max.size())
    throw vpRobotException(vpRobotException::dimensionError, "Velocity vectors should have the same dimension");
 
  double scale = 1; // global scale factor to saturate all the axis
  for (unsigned int i = 0; i < size; i++) {
    double v_i = fabs(v_in[i]);
    double v_max_i = fabs(v_max[i]);
    if (v_i > v_max_i) // Test if we should saturate the axis
    {
      double scale_i = v_max_i / v_i;
      if (scale_i < scale)
        scale = scale_i;
 
      if (verbose)
        std::cout << "Excess velocity " << v_in[i] << " axis nr. " << i << std::endl;
    }
  }
 
  vpColVector v_sat(size);
  v_sat = v_in * scale;
 
  return v_sat;
}
 
/* --------------------------------------------------------------------------
 */
/* --------------------------------------------------------------------------
 */
/* --------------------------------------------------------------------------
 */
 
vpRobot::vpRobotStateType vpRobot::setRobotState(const vpRobot::vpRobotStateType newState)
{
  stateRobot = newState;
  return newState;
}
 
vpRobot::vpControlFrameType vpRobot::setRobotFrame(vpRobot::vpControlFrameType newFrame)
{
  frameRobot = newFrame;
  return newFrame;
}
 
vpColVector vpRobot::getPosition(vpRobot::vpControlFrameType frame)
{
  vpColVector r;
  this->getPosition(frame, r);
 
  return r;
}
 
/* -------------------------------------------------------------------------
 */
/* --- VELOCITY CONTROL ----------------------------------------------------
 */
/* -------------------------------------------------------------------------
 */
 
void vpRobot::setMaxTranslationVelocity(double v_max)
{
  this->maxTranslationVelocity = v_max;
  return;
}
 
double vpRobot::getMaxTranslationVelocity(void) const { return this->maxTranslationVelocity; }
 
void vpRobot::setMaxRotationVelocity(double w_max)
{
  this->maxRotationVelocity = w_max;
  return;
}
 
double vpRobot::getMaxRotationVelocity(void) const { return this->maxRotationVelocity; }