vpRobot.cpp

/****************************************************************************
 *
 * $Id: vpRobot.cpp 5238 2015-01-30 13:52:25Z fspindle $
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2014 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:
 * Generic virtual robot.
 *
 * Authors:
 * Eric Marchand
 *
 *****************************************************************************/

#include <visp/vpRobot.h>
#include <visp/vpRobotException.h>
#include <visp/vpDebug.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(NULL), qmax(NULL), 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(NULL), qmax(NULL), verbose_(true)
{
  *this = robot;
}

vpRobot::~vpRobot()
{
  if (qmin != NULL) {
    delete [] qmin;
    qmin = NULL;
  }
  if (qmax != NULL) {
    delete [] qmax;
    qmax = NULL;
  }
}

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 (const double v_max)
{
  this ->maxTranslationVelocity = v_max;
  return;
}

double
vpRobot::getMaxTranslationVelocity (void) const
{
  return this ->maxTranslationVelocity;
}
void
vpRobot::setMaxRotationVelocity (const double w_max)
{
  this ->maxRotationVelocity = w_max;
  return;
}

double
vpRobot::getMaxRotationVelocity (void) const
{
  return this ->maxRotationVelocity;
}