vpSimulatorAfma6.cpp

/****************************************************************************
 *
 * $Id: vpSimulatorAfma6.cpp 2595 2010-06-02 08:50:59Z nmelchio $
 *
 * 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:
 * Class which provides a simulator for the robot Afma6.
 *
 * Authors:
 * Nicolas Melchior
 *
 *****************************************************************************/



#include <visp/vpConfig.h>
#if defined(_WIN32) || defined(VISP_HAVE_PTHREAD)
#include <visp/vpSimulatorAfma6.h>
#include <visp/vpTime.h>
#include <visp/vpImagePoint.h>
#include <visp/vpPoint.h>
#include <visp/vpMeterPixelConversion.h>
#include <visp/vpRobotException.h>
#include <visp/vpIoTools.h>
#include <cmath>    // std::fabs
#include <limits>   // numeric_limits
#include <string>
const double vpSimulatorAfma6::defaultPositioningVelocity = 25.0;


vpSimulatorAfma6::vpSimulatorAfma6()
  : vpRobotWireFrameSimulator(), vpAfma6(),
    q_prev_getdis(), first_time_getdis(true), positioningVelocity(defaultPositioningVelocity),
    zeroPos(), reposPos(), toolCustom(false), arm_dir()
{
  init();
  initDisplay();
  
  tcur = vpTime::measureTimeMs();

  #if defined(_WIN32)
  mutex_fMi = CreateMutex(NULL,FALSE,NULL);
  mutex_artVel = CreateMutex(NULL,FALSE,NULL);
  mutex_artCoord = CreateMutex(NULL,FALSE,NULL);
  mutex_velocity = CreateMutex(NULL,FALSE,NULL);
  mutex_display = CreateMutex(NULL,FALSE,NULL);


  DWORD   dwThreadIdArray;
  hThread = CreateThread( 
            NULL,                   // default security attributes
            0,                      // use default stack size  
            launcher,               // thread function name
            this,                   // argument to thread function 
            0,                      // use default creation flags 
            &dwThreadIdArray);     // returns the thread identifier 
  #elif defined (VISP_HAVE_PTHREAD)
  pthread_mutex_init(&mutex_fMi, NULL);
  pthread_mutex_init(&mutex_artVel, NULL);
  pthread_mutex_init(&mutex_artCoord, NULL);
  pthread_mutex_init(&mutex_velocity, NULL);
  pthread_mutex_init(&mutex_display, NULL);
  
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  
  pthread_create(&thread, NULL, launcher, (void *)this);
  #endif
  
  compute_fMi();
}

vpSimulatorAfma6::vpSimulatorAfma6(bool do_display)
  : vpRobotWireFrameSimulator(do_display),
    q_prev_getdis(), first_time_getdis(true), positioningVelocity(defaultPositioningVelocity),
    zeroPos(), reposPos(), toolCustom(false), arm_dir()
{
  init();
  initDisplay();
    
  tcur = vpTime::measureTimeMs();
  
    #if defined(_WIN32)
  mutex_fMi = CreateMutex(NULL,FALSE,NULL);
  mutex_artVel = CreateMutex(NULL,FALSE,NULL);
  mutex_artCoord = CreateMutex(NULL,FALSE,NULL);
  mutex_velocity = CreateMutex(NULL,FALSE,NULL);
  mutex_display = CreateMutex(NULL,FALSE,NULL);


  DWORD   dwThreadIdArray;
  hThread = CreateThread( 
            NULL,                   // default security attributes
            0,                      // use default stack size  
            launcher,               // thread function name
            this,                   // argument to thread function 
            0,                      // use default creation flags 
            &dwThreadIdArray);      // returns the thread identifier 
  #elif defined(VISP_HAVE_PTHREAD)
  pthread_mutex_init(&mutex_fMi, NULL);
  pthread_mutex_init(&mutex_artVel, NULL);
  pthread_mutex_init(&mutex_artCoord, NULL);
  pthread_mutex_init(&mutex_velocity, NULL);
  pthread_mutex_init(&mutex_display, NULL);
  
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  
  pthread_create(&thread, NULL, launcher, (void *)this);
  #endif
  
  compute_fMi();
}

vpSimulatorAfma6::~vpSimulatorAfma6()
{
  robotStop = true;
  
  #if defined(_WIN32)
  WaitForSingleObject(hThread,INFINITE);
  CloseHandle(hThread);
  CloseHandle(mutex_fMi);
  CloseHandle(mutex_artVel);
  CloseHandle(mutex_artCoord);
  CloseHandle(mutex_velocity);
  CloseHandle(mutex_display);
  #elif defined(VISP_HAVE_PTHREAD)
  pthread_attr_destroy(&attr);
  pthread_join(thread, NULL);
  pthread_mutex_destroy(&mutex_fMi);
  pthread_mutex_destroy(&mutex_artVel);
  pthread_mutex_destroy(&mutex_artCoord);
  pthread_mutex_destroy(&mutex_velocity);
  pthread_mutex_destroy(&mutex_display);
  #endif
  
  if (robotArms != NULL)
  {
    for(int i = 0; i < 6; i++)
      free_Bound_scene (&(robotArms[i]));
  }

  delete[] robotArms;
  delete[] fMi;
}

void
vpSimulatorAfma6::init()
{
  // set arm_dir from #define VISP_ROBOT_ARMS_DIR if it exists
  if (vpIoTools::checkDirectory(VISP_ROBOT_ARMS_DIR) == true) // directory exists
    arm_dir = VISP_ROBOT_ARMS_DIR;
  else {
    try {
      arm_dir = vpIoTools::getenv("VISP_ROBOT_ARMS_DIR");
      std::cout << "The simulator uses data from VISP_ROBOT_ARMS_DIR=" << arm_dir << std::endl;
    }
    catch (...) {
      std::cout << "Cannot get VISP_ROBOT_ARMS_DIR environment variable" << std::endl;
    }
  }

  this->init(vpAfma6::TOOL_CCMOP);
  toolCustom = false;

  size_fMi = 8;
  fMi = new vpHomogeneousMatrix[8];
  artCoord.resize(njoint);
  artVel.resize(njoint);

  zeroPos.resize(njoint);
  zeroPos = 0;
  reposPos.resize(njoint);
  reposPos = 0;
  reposPos[1] = -M_PI/2; reposPos[2] = M_PI; reposPos[4] = M_PI/2;
  
  artCoord = zeroPos;
  artVel = 0;
  
  q_prev_getdis.resize(njoint);
  q_prev_getdis = 0;
  first_time_getdis = true;
  
  positioningVelocity  = defaultPositioningVelocity ;
  
  setRobotFrame (vpRobot::ARTICULAR_FRAME);
  this->setRobotState(vpRobot::STATE_STOP);
  
  // Software joint limits in radians
  //_joint_min.resize(njoint);
  _joint_min[0] = -0.6501;
  _joint_min[1] = -0.6001;
  _joint_min[2] = -0.5001;
  _joint_min[3] = -2.7301;
  _joint_min[4] = -0.1001;
  _joint_min[5] = -1.5901;
  //_joint_max.resize(njoint);
  _joint_max[0] = 0.7001;
  _joint_max[1] = 0.5201;
  _joint_max[2] = 0.4601;
  _joint_max[3] = 2.7301;
  _joint_max[4] = 2.4801;
  _joint_max[5] = 1.5901;
}

void
vpSimulatorAfma6::initDisplay()
{
  robotArms = NULL;
  robotArms = new Bound_scene[6];
  initArms();
  setExternalCameraPosition(vpHomogeneousMatrix(0,0,0,0,0,vpMath::rad(180))*vpHomogeneousMatrix(-0.1,0,4,vpMath::rad(90),0,0));
  cameraParam.initPersProjWithoutDistortion (558.5309599, 556.055053, 320, 240);
  setExternalCameraParameters(cameraParam);
  vpCameraParameters tmp;
  getCameraParameters(tmp,640,480);
  px_int = tmp.get_px();
  py_int = tmp.get_py();
  sceneInitialized = true;
}


void
vpSimulatorAfma6::init (vpAfma6::vpAfma6ToolType tool,
           vpCameraParameters::vpCameraParametersProjType proj_model)
{
  this->projModel = proj_model;
  unsigned int name_length = 30; // the size of this kind of string "/afma6_tool_vacuum.bnd"
  if (arm_dir.size() > FILENAME_MAX)
    throw vpException (vpException::dimensionError, "Cannot initialize Afma6 simulator");
  unsigned int full_length = (unsigned int)arm_dir.size() + name_length;
  if (full_length > FILENAME_MAX)
    throw vpException (vpException::dimensionError, "Cannot initialize Afma6 simulator");

  // Use here default values of the robot constant parameters.
  switch (tool) {
  case vpAfma6::TOOL_CCMOP: {
      _erc[0] = vpMath::rad(164.35); // rx
      _erc[1] = vpMath::rad( 89.64); // ry
      _erc[2] = vpMath::rad(-73.05); // rz
      _etc[0] = 0.0117; // tx
      _etc[1] = 0.0033; // ty
      _etc[2] = 0.2272; // tz
      
      setCameraParameters(vpCameraParameters(1109.5735473989, 1112.1520168160, 320, 240));
      
      if (robotArms != NULL)
      {
        while (get_displayBusy()) vpTime::wait(2);
        free_Bound_scene (&(robotArms[5]));
        char *name_arm = new char [full_length];
        strcpy(name_arm, arm_dir.c_str());
        strcat(name_arm,"/afma6_tool_ccmop.bnd");
        set_scene(name_arm, robotArms+5, 1.0);
        set_displayBusy(false);
        delete [] name_arm;
      }
      break;
    }
  case vpAfma6::TOOL_GRIPPER: {
      _erc[0] = vpMath::rad( 88.33); // rx
      _erc[1] = vpMath::rad( 72.07); // ry
      _erc[2] = vpMath::rad(  2.53); // rz
      _etc[0] = 0.0783; // tx
      _etc[1] = 0.1234; // ty
      _etc[2] = 0.1638; // tz
      
      setCameraParameters(vpCameraParameters(852.6583228197, 854.8084224761, 320, 240));
      
      if (robotArms != NULL)
      {
        while (get_displayBusy()) vpTime::wait(2);
        free_Bound_scene (&(robotArms[5]));
        char *name_arm = new char [full_length];
        strcpy(name_arm, arm_dir.c_str());
        strcat(name_arm,"/afma6_tool_gripper.bnd");
        set_scene(name_arm, robotArms+5, 1.0);
        set_displayBusy(false);
        delete [] name_arm;
      }
      break;
    }
  case vpAfma6::TOOL_VACUUM: {
      _erc[0] = vpMath::rad( 90.40); // rx
      _erc[1] = vpMath::rad( 75.11); // ry
      _erc[2] = vpMath::rad(  0.18); // rz
      _etc[0] = 0.0038; // tx
      _etc[1] = 0.1281; // ty
      _etc[2] = 0.1658; // tz
      
      setCameraParameters(vpCameraParameters(853.4876600807, 856.0339170706, 320, 240));
      
      if (robotArms != NULL)
      {
        while (get_displayBusy()) vpTime::wait(2);
        free_Bound_scene (&(robotArms[5]));

        char *name_arm = new char [full_length];

        strcpy(name_arm, arm_dir.c_str());
        strcat(name_arm,"/afma6_tool_vacuum.bnd");
        set_scene(name_arm, robotArms+5, 1.0);
        set_displayBusy(false);
        delete [] name_arm;
      }
      break;
    }
  case vpAfma6::TOOL_GENERIC_CAMERA: {
      std::cout << "The generic camera is not handled in vpSimulatorAfma6.cpp" << std::endl;
    }
  }
  
  vpRotationMatrix eRc(_erc);
  this->_eMc.buildFrom(_etc, eRc);
  
  setToolType(tool);
  return ;
}

void
vpSimulatorAfma6::getCameraParameters (vpCameraParameters &cam,
                 const unsigned int &image_width,
                 const unsigned int &image_height)
{
  if (toolCustom)
  {
    vpCameraParameters(px_int,py_int,image_width/2,image_height/2);
  }
  // Set default parameters
  switch (getToolType()) {
  case vpAfma6::TOOL_CCMOP: {
    // Set default intrinsic camera parameters for 640x480 images
    if (image_width == 640 && image_height == 480) 
    {
      std::cout << "Get default camera parameters for camera \"" 
        << vpAfma6::CONST_CCMOP_CAMERA_NAME << "\"" << std::endl;
    cam.initPersProjWithoutDistortion(1109.5735473989, 1112.1520168160, 320, 240);
    }
    else {
      vpTRACE("Cannot get default intrinsic camera parameters for this image resolution");
    }
    break;
  }
  case vpAfma6::TOOL_GRIPPER: {
    // Set default intrinsic camera parameters for 640x480 images
    if (image_width == 640 && image_height == 480) {
      std::cout << "Get default camera parameters for camera \"" 
        << vpAfma6::CONST_GRIPPER_CAMERA_NAME << "\"" << std::endl;
    cam.initPersProjWithoutDistortion(852.6583228197, 854.8084224761, 320, 240);
    }
    else {
      vpTRACE("Cannot get default intrinsic camera parameters for this image resolution");
    }
    break;
  }
  case vpAfma6::TOOL_GENERIC_CAMERA:
  case vpAfma6::TOOL_VACUUM: {
      std::cout << "The generic camera is not handled in vpSimulatorAfma6.cpp" << std::endl;
      break;
  }
  default: 
    vpERROR_TRACE ("This error should not occur!");
    break;
  }
  return;
}

void
vpSimulatorAfma6::getCameraParameters (vpCameraParameters &cam,
            const vpImage<unsigned char> &I_)
{
  getCameraParameters(cam,I_.getWidth(),I_.getHeight());
}

void
vpSimulatorAfma6::getCameraParameters (vpCameraParameters &cam,
         const vpImage<vpRGBa> &I_)
{
  getCameraParameters(cam,I_.getWidth(),I_.getHeight());
}


void
vpSimulatorAfma6::setCameraParameters(const vpCameraParameters &cam)
{
  px_int = cam.get_px();
  py_int = cam.get_py();
  toolCustom = true;
}


void
vpSimulatorAfma6::updateArticularPosition()
{
  double tcur_1 = tcur;// temporary variable used to store the last time since the last command 

  while (!robotStop)
  {
    //Get current time
    tprev = tcur_1;
    tcur = vpTime::measureTimeMs();
    
    if(setVelocityCalled || !constantSamplingTimeMode){
      setVelocityCalled = false;
    
      computeArticularVelocity();
    
      double ellapsedTime = (tcur - tprev) * 1e-3;
      if(constantSamplingTimeMode){//if we want a constant velocity, we force the ellapsed time to the given samplingTime
        ellapsedTime = getSamplingTime(); // in second
      }
    
      vpColVector articularCoordinates = get_artCoord();
      articularCoordinates = get_artCoord();
      vpColVector articularVelocities = get_artVel();
    
      if (jointLimit)
      {
        double art = articularCoordinates[jointLimitArt-1] + ellapsedTime*articularVelocities[jointLimitArt-1];
        if (art <= _joint_min[jointLimitArt-1] || art >= _joint_max[jointLimitArt-1]) {
          if (verbose_) {
            std::cout << "Joint " << jointLimitArt-1
                    << " reaches a limit: " << vpMath::deg(_joint_min[jointLimitArt-1]) << " < "
                    << vpMath::deg(art) << " < " << vpMath::deg(_joint_max[jointLimitArt-1]) << std::endl;
          }

          articularVelocities = 0.0;
        }
        else
          jointLimit = false;
      }
    
      articularCoordinates[0] = articularCoordinates[0] + ellapsedTime*articularVelocities[0];
      articularCoordinates[1] = articularCoordinates[1] + ellapsedTime*articularVelocities[1];
      articularCoordinates[2] = articularCoordinates[2] + ellapsedTime*articularVelocities[2];
      articularCoordinates[3] = articularCoordinates[3] + ellapsedTime*articularVelocities[3];
      articularCoordinates[4] = articularCoordinates[4] + ellapsedTime*articularVelocities[4];
      articularCoordinates[5] = articularCoordinates[5] + ellapsedTime*articularVelocities[5];
      
      int jl = isInJointLimit();
      
      if (jl != 0 && jointLimit == false)
      {
        if (jl < 0)
          ellapsedTime = (_joint_min[(unsigned int)(-jl-1)] - articularCoordinates[(unsigned int)(-jl-1)])/(articularVelocities[(unsigned int)(-jl-1)]);
        else
          ellapsedTime = (_joint_max[(unsigned int)(jl-1)] - articularCoordinates[(unsigned int)(jl-1)])/(articularVelocities[(unsigned int)(jl-1)]);
      
        for (unsigned int i = 0; i < 6; i++)
          articularCoordinates[i] = articularCoordinates[i] + ellapsedTime*articularVelocities[i];
      
        jointLimit = true;
        jointLimitArt = (unsigned int)fabs((double)jl);
      }

      set_artCoord(articularCoordinates);
      set_artVel(articularVelocities);
    
      compute_fMi();
   
      if (displayAllowed)
      {
        vpDisplay::display(I);
        vpDisplay::displayFrame(I,getExternalCameraPosition (),cameraParam,0.2,vpColor::none, thickness_);
        vpDisplay::displayFrame(I,getExternalCameraPosition ()*fMi[7],cameraParam,0.1,vpColor::none, thickness_);
      }
    
      if (displayType == MODEL_3D && displayAllowed)
      {
        while (get_displayBusy()) vpTime::wait(2);
        vpSimulatorAfma6::getExternalImage(I);
        set_displayBusy(false);
      }
        
    
      if (0/*displayType == MODEL_DH && displayAllowed*/)
      {
        vpHomogeneousMatrix fMit[8];
        get_fMi(fMit);
      
      //vpDisplay::displayFrame(I,getExternalCameraPosition ()*fMi[6],cameraParam,0.2,vpColor::none);

        vpImagePoint iP, iP_1;
        vpPoint pt;
        pt.setWorldCoordinates (0,0,0);
      
        pt.track(getExternalCameraPosition ());
        vpMeterPixelConversion::convertPoint (cameraParam, pt.get_x(), pt.get_y(), iP_1);
        pt.track(getExternalCameraPosition ()*fMit[0]);
        vpMeterPixelConversion::convertPoint (cameraParam, pt.get_x(), pt.get_y(), iP);
        vpDisplay::displayLine(I,iP_1,iP,vpColor::green, thickness_);
        for (unsigned int k = 1; k < 7; k++)
        {
          pt.track(getExternalCameraPosition ()*fMit[k-1]);
          vpMeterPixelConversion::convertPoint (cameraParam, pt.get_x(), pt.get_y(), iP_1);
        
          pt.track(getExternalCameraPosition ()*fMit[k]);
          vpMeterPixelConversion::convertPoint (cameraParam, pt.get_x(), pt.get_y(), iP);
        
          vpDisplay::displayLine(I,iP_1,iP,vpColor::green, thickness_);
        }
        vpDisplay::displayCamera(I,getExternalCameraPosition ()*fMit[7],cameraParam,0.1,vpColor::green, thickness_);
      }
    
      vpDisplay::flush(I);
    
      
      vpTime::wait( tcur, 1000*getSamplingTime() );
      tcur_1 = tcur;
    }else{
      vpTime::wait(tcur, vpTime::minTimeForUsleepCall);
    }
  }
}

void 
vpSimulatorAfma6::compute_fMi()
{
  //vpColVector q = get_artCoord();
  vpColVector q(6);//; = get_artCoord();
  q = get_artCoord();
  
  vpHomogeneousMatrix fMit[8];
  
  double q1 = q[0];
  double q2 = q[1];
  double q3 = q[2];
  double q4 = q[3];
  double q5 = q[4];
  double q6 = q[5];
  
  double c4 = cos(q4);
  double s4 = sin(q4);
  double c5 = cos(q5);
  double s5 = sin(q5);
  double c6 = cos(q6);
  double s6 = sin(q6);
  
  fMit[0][0][0] = 1;
  fMit[0][1][0] = 0;
  fMit[0][2][0] = 0;
  fMit[0][0][1] = 0;
  fMit[0][1][1] = 1;
  fMit[0][2][1] = 0;
  fMit[0][0][2] = 0;
  fMit[0][1][2] = 0;
  fMit[0][2][2] = 1;
  fMit[0][0][3] = q1;
  fMit[0][1][3] = 0;
  fMit[0][2][3] = 0;
  
  fMit[1][0][0] = 1;
  fMit[1][1][0] = 0;
  fMit[1][2][0] = 0;
  fMit[1][0][1] = 0;
  fMit[1][1][1] = 1;
  fMit[1][2][1] = 0;
  fMit[1][0][2] = 0;
  fMit[1][1][2] = 0;
  fMit[1][2][2] = 1;
  fMit[1][0][3] = q1;
  fMit[1][1][3] = q2;
  fMit[1][2][3] = 0;
  
  fMit[2][0][0] = 1;
  fMit[2][1][0] = 0;
  fMit[2][2][0] = 0;
  fMit[2][0][1] = 0;
  fMit[2][1][1] = 1;
  fMit[2][2][1] = 0;
  fMit[2][0][2] = 0;
  fMit[2][1][2] = 0;
  fMit[2][2][2] = 1;
  fMit[2][0][3] = q1;
  fMit[2][1][3] = q2;
  fMit[2][2][3] = q3;
  
  fMit[3][0][0] = s4;
  fMit[3][1][0] = -c4;
  fMit[3][2][0] = 0;
  fMit[3][0][1] = c4;
  fMit[3][1][1] = s4;
  fMit[3][2][1] = 0;
  fMit[3][0][2] = 0;
  fMit[3][1][2] = 0;
  fMit[3][2][2] = 1;
  fMit[3][0][3] = q1;
  fMit[3][1][3] = q2;
  fMit[3][2][3] = q3;
  
  fMit[4][0][0] = s4*s5;
  fMit[4][1][0] = -c4*s5;
  fMit[4][2][0] = c5;
  fMit[4][0][1] = s4*c5;
  fMit[4][1][1] = -c4*c5;
  fMit[4][2][1] = -s5;
  fMit[4][0][2] = c4;
  fMit[4][1][2] = s4;
  fMit[4][2][2] = 0;
  fMit[4][0][3] = c4*this->_long_56+q1;
  fMit[4][1][3] = s4*this->_long_56+q2;
  fMit[4][2][3] = q3;
  
  fMit[5][0][0] = s4*s5*c6+c4*s6;
  fMit[5][1][0] = -c4*s5*c6+s4*s6;
  fMit[5][2][0] = c5*c6;
  fMit[5][0][1] = -s4*s5*s6+c4*c6;
  fMit[5][1][1] = c4*s5*s6+s4*c6;
  fMit[5][2][1] = -c5*s6;
  fMit[5][0][2] = -s4*c5;
  fMit[5][1][2] = c4*c5;
  fMit[5][2][2] = s5;
  fMit[5][0][3] = c4*this->_long_56+q1;
  fMit[5][1][3] = s4*this->_long_56+q2;
  fMit[5][2][3] = q3;
  
  fMit[6][0][0] = fMit[5][0][0];
  fMit[6][1][0] = fMit[5][1][0];
  fMit[6][2][0] = fMit[5][2][0];
  fMit[6][0][1] = fMit[5][0][1];
  fMit[6][1][1] = fMit[5][1][1];
  fMit[6][2][1] = fMit[5][2][1];
  fMit[6][0][2] = fMit[5][0][2];
  fMit[6][1][2] = fMit[5][1][2];
  fMit[6][2][2] = fMit[5][2][2];
  fMit[6][0][3] = fMit[5][0][3];
  fMit[6][1][3] = fMit[5][1][3];
  fMit[6][2][3] = fMit[5][2][3];
  
//   vpHomogeneousMatrix cMe;
//   get_cMe(cMe);
//   cMe = cMe.inverse();
//   fMit[7] = fMit[6] * cMe;
  vpAfma6::get_fMc(q,fMit[7]);
  
  #if defined(_WIN32)
  WaitForSingleObject(mutex_fMi,INFINITE);
  for (int i = 0; i < 8; i++)
    fMi[i] = fMit[i];
  ReleaseMutex(mutex_fMi);
  #elif defined(VISP_HAVE_PTHREAD)
  pthread_mutex_lock (&mutex_fMi);
  for (int i = 0; i < 8; i++)
    fMi[i] = fMit[i];
  pthread_mutex_unlock (&mutex_fMi);
  #endif
}


vpRobot::vpRobotStateType
vpSimulatorAfma6::setRobotState(vpRobot::vpRobotStateType newState)
{
  switch (newState) {
  case vpRobot::STATE_STOP: {
    // Start primitive STOP only if the current state is Velocity
    if (vpRobot::STATE_VELOCITY_CONTROL == getRobotState ()) {
      stopMotion();
    }
    break;
  }
  case vpRobot::STATE_POSITION_CONTROL: {
    if (vpRobot::STATE_VELOCITY_CONTROL == getRobotState ()) {
      std::cout << "Change the control mode from velocity to position control.\n";
      stopMotion();
    }
    else {
      //std::cout << "Change the control mode from stop to position control.\n";
    }
    break;
  }
  case vpRobot::STATE_VELOCITY_CONTROL: {
    if (vpRobot::STATE_VELOCITY_CONTROL != getRobotState ()) {
      std::cout << "Change the control mode from stop to velocity control.\n";
    }
    break;
  }
  case vpRobot::STATE_ACCELERATION_CONTROL:
  default:
    break ;
  }

  return vpRobot::setRobotState (newState);
}

void
vpSimulatorAfma6::setVelocity (const vpRobot::vpControlFrameType frame, const vpColVector & vel)
{
  if (vpRobot::STATE_VELOCITY_CONTROL != getRobotState ()) {
    vpERROR_TRACE ("Cannot send a velocity to the robot "
           "use setRobotState(vpRobot::STATE_VELOCITY_CONTROL) first) ");
    throw vpRobotException (vpRobotException::wrongStateError,
                "Cannot send a velocity to the robot "
                "use setRobotState(vpRobot::STATE_VELOCITY_CONTROL) first) ");
  }
  
  vpColVector vel_sat(6);

  double scale_trans_sat = 1;
  double scale_rot_sat   = 1;
  double scale_sat       = 1;
  double vel_trans_max = getMaxTranslationVelocity();
  double vel_rot_max   = getMaxRotationVelocity();
  
  double vel_abs; // Absolute value
  
  // Velocity saturation
  switch(frame)
  {
    // saturation in cartesian space
    case vpRobot::CAMERA_FRAME :
    case vpRobot::REFERENCE_FRAME :
    {
      if (vel.getRows() != 6)
      {
    vpERROR_TRACE ("The velocity vector must have a size of 6 !!!!");
    throw;
      }
      
      for (unsigned int i = 0 ; i < 3; ++ i)
      {
        vel_abs = fabs (vel[i]);
        if (vel_abs > vel_trans_max && !jointLimit)
        {
      vel_trans_max = vel_abs;
      vpERROR_TRACE ("Excess velocity %g m/s in TRANSLATION "
                 "(axis nr. %d).", vel[i], i+1);
        }
      
        vel_abs = fabs (vel[i+3]);
        if (vel_abs > vel_rot_max && !jointLimit) {
      vel_rot_max = vel_abs;
      vpERROR_TRACE ("Excess velocity %g rad/s in ROTATION "
               "(axis nr. %d).", vel[i+3], i+4);
        }
      }
    
      if (vel_trans_max > getMaxTranslationVelocity())                     
        scale_trans_sat = getMaxTranslationVelocity() / vel_trans_max;
    
      if (vel_rot_max > getMaxRotationVelocity())
        scale_rot_sat = getMaxRotationVelocity() / vel_rot_max; 
    
      if ( (scale_trans_sat < 1) || (scale_rot_sat < 1) )
      {
        if (scale_trans_sat < scale_rot_sat)  
      scale_sat = scale_trans_sat;                    
        else                        
      scale_sat = scale_rot_sat;
      }
      break;
    }
    
    // saturation in joint space
    case vpRobot::ARTICULAR_FRAME :
    {
      if (vel.getRows() != 6)
      {
    vpERROR_TRACE ("The velocity vector must have a size of 6 !!!!");
    throw;
      }
      for (unsigned int i = 0 ; i < 6; ++ i)
      {
        vel_abs = fabs (vel[i]);
        if (vel_abs > vel_rot_max && !jointLimit)
        {
      vel_rot_max = vel_abs;
      vpERROR_TRACE ("Excess velocity %g rad/s in ROTATION "
               "(axis nr. %d).", vel[i], i+1);
        }
      }
      if (vel_rot_max > getMaxRotationVelocity())
        scale_rot_sat = getMaxRotationVelocity() / vel_rot_max; 
      if ( scale_rot_sat < 1 ) 
        scale_sat = scale_rot_sat;
      break;
    }
    case vpRobot::MIXT_FRAME :
    {
      break;
    }
  }
  
  set_velocity (vel * scale_sat);
  setRobotFrame (frame);
  setVelocityCalled = true;
}


void
vpSimulatorAfma6::computeArticularVelocity()
{
  vpRobot::vpControlFrameType frame = getRobotFrame();
  
  double scale_rot_sat   = 1;
  double scale_sat       = 1;
  double vel_rot_max   = getMaxRotationVelocity();
  double vel_abs;
  
  vpColVector articularCoordinates = get_artCoord();
  vpColVector velocityframe = get_velocity();
  vpColVector articularVelocity;
  
  switch(frame)
  {
    case vpRobot::CAMERA_FRAME :
    {
      vpMatrix eJe_;
      vpVelocityTwistMatrix eVc(_eMc);
      vpAfma6::get_eJe(articularCoordinates,eJe_);
      eJe_ = eJe_.pseudoInverse();
      if (singularityManagement)
        singularityTest(articularCoordinates,eJe_);
      articularVelocity = eJe_*eVc*velocityframe;
      set_artVel (articularVelocity);
      break;
    }
    case vpRobot::REFERENCE_FRAME :
    {
      vpMatrix fJe_;
      vpAfma6::get_fJe(articularCoordinates,fJe_);
      fJe_ = fJe_.pseudoInverse();
      if (singularityManagement)
        singularityTest(articularCoordinates,fJe_);
      articularVelocity = fJe_*velocityframe;
      set_artVel (articularVelocity);
      break;
    }
    case vpRobot::ARTICULAR_FRAME :
    {
      articularVelocity = velocityframe;
      set_artVel (articularVelocity);
      break;
    }
    case vpRobot::MIXT_FRAME :
    {
      break;
    }
  }
  
  
  
  switch(frame)
  {
    case vpRobot::CAMERA_FRAME :
    case vpRobot::REFERENCE_FRAME :
    {
      for (unsigned int i = 0 ; i < 6; ++ i)
      {
        vel_abs = fabs (articularVelocity[i]);
        if (vel_abs > vel_rot_max && !jointLimit)
        {
          vel_rot_max = vel_abs;
          vpERROR_TRACE ("Excess velocity %g rad/s in ROTATION "
             "(axis nr. %d).", articularVelocity[i], i+1);
        }
      }
      if (vel_rot_max > getMaxRotationVelocity())
        scale_rot_sat = getMaxRotationVelocity() / vel_rot_max; 
      if ( scale_rot_sat < 1 ) 
        scale_sat = scale_rot_sat;
    
      set_artVel(articularVelocity * scale_sat);
      break;
    }
    case vpRobot::ARTICULAR_FRAME :
    case vpRobot::MIXT_FRAME :
    {
      break;
    }
  }
}


void
vpSimulatorAfma6::getVelocity (const vpRobot::vpControlFrameType frame, vpColVector & vel)
{
  vel.resize(6);
  
  vpColVector articularCoordinates = get_artCoord();
  vpColVector articularVelocity = get_artVel();
  
  switch(frame)
  {
    case vpRobot::CAMERA_FRAME : 
    {
      vpMatrix eJe_;
      vpVelocityTwistMatrix cVe(_eMc);
      vpAfma6::get_eJe(articularCoordinates,eJe_);
      vel = cVe*eJe_*articularVelocity;
      break ;
    }
    case vpRobot::ARTICULAR_FRAME : 
    {
      vel = articularVelocity;
      break ;
    }
    case vpRobot::REFERENCE_FRAME : 
    {
      vpMatrix fJe_;
      vpAfma6::get_fJe(articularCoordinates,fJe_);
      vel = fJe_*articularVelocity;
      break ;
    }
    case vpRobot::MIXT_FRAME : 
    {
      break ;
    }
    default: 
    {
      vpERROR_TRACE ("Error in spec of vpRobot. "
           "Case not taken in account.");
      return;
    }
  }
}

void
vpSimulatorAfma6::getVelocity (const vpRobot::vpControlFrameType frame, vpColVector & vel, double &timestamp)
{
  timestamp = vpTime::measureTimeSecond();
  getVelocity(frame, vel);
}

vpColVector
vpSimulatorAfma6::getVelocity (vpRobot::vpControlFrameType frame)
{
  vpColVector vel(6);
  getVelocity (frame, vel);

  return vel;
}

vpColVector
vpSimulatorAfma6::getVelocity (vpRobot::vpControlFrameType frame, double &timestamp)
{
  timestamp = vpTime::measureTimeSecond();
  vpColVector vel(6);
  getVelocity (frame, vel);

  return vel;
}

void 
vpSimulatorAfma6::findHighestPositioningSpeed(vpColVector &q)
{
  double vel_rot_max   = getMaxRotationVelocity();
  double velmax =  fabs(q[0]);
  for (unsigned int i = 1; i < 6; i++)
  {
    if (velmax < fabs(q[i]))
      velmax =  fabs(q[i]);
  }
  
  double alpha = (getPositioningVelocity() * vel_rot_max) / (velmax*100);
  q = q * alpha;
}

void 
vpSimulatorAfma6::setPosition(const vpRobot::vpControlFrameType frame,const vpColVector &q)
{
  if (vpRobot::STATE_POSITION_CONTROL != getRobotState ())
  {
    vpERROR_TRACE ("Robot was not in position-based control\n"
             "Modification of the robot state");
   // setRobotState(vpRobot::STATE_POSITION_CONTROL) ;
  }
  
  vpColVector articularCoordinates = get_artCoord();
  
  vpColVector error(6);
  double errsqr = 0;
  switch(frame)
  {
    case vpRobot::CAMERA_FRAME : 
    {
      int nbSol;
      vpColVector qdes(6);

      vpTranslationVector txyz;
      vpRxyzVector rxyz;
      for (unsigned int i=0; i < 3; i++)
      {
        txyz[i] = q[i];
        rxyz[i] = q[i+3];
      }

      vpRotationMatrix cRc2(rxyz);
      vpHomogeneousMatrix cMc2(txyz, cRc2);

      vpHomogeneousMatrix fMc_;
      vpAfma6::get_fMc(articularCoordinates, fMc_);
    
      vpHomogeneousMatrix fMc2 = fMc_ * cMc2;
    
      do
      {
        articularCoordinates = get_artCoord();
        qdes = articularCoordinates;
        nbSol = getInverseKinematics(fMc2, qdes, true, verbose_);
        setVelocityCalled = true;
        if (nbSol > 0)
        {
          error = qdes - articularCoordinates;
          errsqr = error.sumSquare();
          //findHighestPositioningSpeed(error);
          set_artVel(error);
          if (errsqr < 1e-4)
          {
            set_artCoord (qdes);
            error = 0;
            set_artVel(error);
            set_velocity(error);
            break;
          }
        }
        else
        {
          vpERROR_TRACE ("Positionning error.");
          throw vpRobotException (vpRobotException::positionOutOfRangeError,
                "Position out of range.");
        }
      }while (errsqr > 1e-8 && nbSol > 0);

      break ;
    }
      
    case vpRobot::ARTICULAR_FRAME:
    {
      do
      {
        articularCoordinates = get_artCoord();
        error = q - articularCoordinates;
        errsqr = error.sumSquare();
        //findHighestPositioningSpeed(error);
        set_artVel(error);
        setVelocityCalled = true;
        if (errsqr < 1e-4)
        {
          set_artCoord (q);
          error = 0;
          set_artVel(error);
          set_velocity(error);
          break;
        }
      }while (errsqr > 1e-8);
      break ;
    }
      
    case vpRobot::REFERENCE_FRAME:
    {
      int nbSol;
      vpColVector qdes(6);

      vpTranslationVector txyz;
      vpRxyzVector rxyz;
      for (unsigned int i=0; i < 3; i++)
      {
        txyz[i] = q[i];
        rxyz[i] = q[i+3];
      }

      vpRotationMatrix fRc(rxyz);
      vpHomogeneousMatrix fMc_(txyz, fRc);

      do
      {
        articularCoordinates = get_artCoord();
        qdes = articularCoordinates;
        nbSol = getInverseKinematics(fMc_, qdes, true, verbose_);
        setVelocityCalled = true;
        if (nbSol > 0)
        {
          error = qdes - articularCoordinates;
          errsqr = error.sumSquare();
          //findHighestPositioningSpeed(error);
          set_artVel(error);
          if (errsqr < 1e-4)
          {
            set_artCoord (qdes);
            error = 0;
            set_artVel(error);
            set_velocity(error);
            break;
          }
        }
        else
          vpERROR_TRACE ("Positionning error. Position unreachable");
      }while (errsqr > 1e-8 && nbSol > 0);
      break ;
    }
    case vpRobot::MIXT_FRAME:
    {
      vpERROR_TRACE ("Positionning error. Mixt frame not implemented");
      throw vpRobotException (vpRobotException::lowLevelError,
                  "Positionning error: "
                  "Mixt frame not implemented.");
      break ;
    }
  }
}

void vpSimulatorAfma6::setPosition (const vpRobot::vpControlFrameType frame,
                   const double pos1,
                   const double pos2,
                   const double pos3,
                   const double pos4,
                   const double pos5,
                   const double pos6)
{
  try{
    vpColVector position(6) ;
    position[0] = pos1 ;
    position[1] = pos2 ;
    position[2] = pos3 ;
    position[3] = pos4 ;
    position[4] = pos5 ;
    position[5] = pos6 ;

    setPosition(frame, position) ;
  }
  catch(...)
    {
      vpERROR_TRACE("Error caught");
      throw ;
    }
}

void vpSimulatorAfma6::setPosition(const char *filename)
{
  vpColVector q;
  bool ret;

  ret = this->readPosFile(filename, q);

  if (ret == false) {
    vpERROR_TRACE ("Bad position in \"%s\"", filename);
    throw vpRobotException (vpRobotException::lowLevelError,
                "Bad position in filename.");
  }
  this->setRobotState(vpRobot::STATE_POSITION_CONTROL);
  this->setPosition(vpRobot::ARTICULAR_FRAME, q);
}

void 
vpSimulatorAfma6::getPosition(const vpRobot::vpControlFrameType frame, vpColVector &q)
{
  q.resize(6);
  
  switch(frame)
  {
    case vpRobot::CAMERA_FRAME : 
    {
      q = 0;
      break ;
    }
      
    case vpRobot::ARTICULAR_FRAME:
    {
      q = get_artCoord();
      break ;
    }
      
    case vpRobot::REFERENCE_FRAME:
    {
      vpHomogeneousMatrix fMc_;
      vpAfma6::get_fMc (get_artCoord(), fMc_);
      
      vpRotationMatrix fRc;
      fMc_.extract(fRc);
      vpRxyzVector rxyz(fRc);
      
      vpTranslationVector txyz;
      fMc_.extract(txyz);
      
      for (unsigned int i=0; i <3; i++)
      {
        q[i] = txyz[i];
        q[i+3] = rxyz[i];
      }
      break ;
    }
    
    case vpRobot::MIXT_FRAME:
    {
      vpERROR_TRACE ("Positionning error. Mixt frame not implemented");
      throw vpRobotException (vpRobotException::lowLevelError,
                  "Positionning error: "
                  "Mixt frame not implemented.");
      break ;
    }
  }
}

void
vpSimulatorAfma6::getPosition(const vpRobot::vpControlFrameType frame, vpColVector &q, double &timestamp)
{
  timestamp = vpTime::measureTimeSecond();
  getPosition(frame, q);
}


void 
vpSimulatorAfma6::getPosition (const vpRobot::vpControlFrameType frame, vpPoseVector &position)
{
  vpColVector posRxyz;
  //recupere  position en Rxyz
  this->getPosition(frame,posRxyz);
  
  //recupere le vecteur thetaU correspondant
  vpThetaUVector RtuVect(posRxyz[3],posRxyz[4],posRxyz[5]);

  //remplit le vpPoseVector avec translation et rotation ThetaU
  for(unsigned int j=0;j<3;j++)
  {
    position[j]=posRxyz[j];
    position[j+3]=RtuVect[j];
  }
}

void
vpSimulatorAfma6::getPosition(const vpRobot::vpControlFrameType frame,
                                 vpPoseVector &position, double &timestamp)
{
  timestamp = vpTime::measureTimeSecond();
  getPosition(frame, position);
}

void 
vpSimulatorAfma6::setJointLimit(const vpColVector &limitMin, const vpColVector &limitMax)
{
  if (limitMin.getRows() != 6 || limitMax.getRows() != 6)
  {
    vpTRACE("Joint limit vector has not a size of 6 !");
    return;
  }
  
  _joint_min[0] = limitMin[0];
  _joint_min[1] = limitMin[1];
  _joint_min[2] = limitMin[2];
  _joint_min[3] = limitMin[3];
  _joint_min[4] = limitMin[4];
  _joint_min[5] = limitMin[5];

  _joint_max[0] = limitMax[0];
  _joint_max[1] = limitMax[1];
  _joint_max[2] = limitMax[2];
  _joint_max[3] = limitMax[3];
  _joint_max[4] = limitMax[4];
  _joint_max[5] = limitMax[5];

}

bool
vpSimulatorAfma6::singularityTest(const vpColVector q, vpMatrix &J)
{
  double q5 = q[4];
  
  bool cond = fabs(q5-M_PI/2) < 1e-1;
  
  if(cond)
  {
    J[0][3] = 0;
    J[0][4] = 0;
    J[1][3] = 0;
    J[1][4] = 0;
    J[3][3] = 0;
    J[3][4] = 0;
    J[5][3] = 0;
    J[5][4] = 0;
    return true;
  }
  
  return false;
}

int
vpSimulatorAfma6::isInJointLimit ()
{
  int artNumb = 0;
  double diff = 0;
  double difft = 0;
  
  vpColVector articularCoordinates = get_artCoord();
  
  for (unsigned int i = 0; i < 6; i++)
  {
    if (articularCoordinates[i] <= _joint_min[i])
    {
      difft = _joint_min[i] - articularCoordinates[i];
      if (difft > diff)
      {
    diff = difft;
    artNumb = -(int)i-1;
      }
    }
  }
  
  for (unsigned int i = 0; i < 6; i++)
  {
    if (articularCoordinates[i] >= _joint_max[i])
    {
      difft = articularCoordinates[i] - _joint_max[i];
      if (difft > diff)
      {
    diff = difft;
    artNumb = (int)(i+1);
      }
    }
  }
  
  if (artNumb != 0)
    std::cout << "\nWarning: Velocity control stopped: axis " << fabs((float)artNumb) << " on joint limit!" <<std::endl;
  
  return artNumb;
}

void
vpSimulatorAfma6::getCameraDisplacement(vpColVector &displacement)
{
  getDisplacement(vpRobot::CAMERA_FRAME, displacement);
}

void
vpSimulatorAfma6::getArticularDisplacement(vpColVector  &displacement)
{
  getDisplacement(vpRobot::ARTICULAR_FRAME, displacement);
}

void
vpSimulatorAfma6::getDisplacement(vpRobot::vpControlFrameType frame,
                 vpColVector &displacement)
{
  displacement.resize (6);
  displacement = 0;
  vpColVector q_cur(6);

  q_cur = get_artCoord();

  if ( ! first_time_getdis ) 
  {
    switch (frame) 
    {
      case vpRobot::CAMERA_FRAME: 
      {
        std::cout << "getDisplacement() CAMERA_FRAME not implemented\n";
        return;
        break ;
      }

      case vpRobot::ARTICULAR_FRAME: 
      {
        displacement = q_cur - q_prev_getdis;
        break ;
      }

      case vpRobot::REFERENCE_FRAME: 
      {
        std::cout << "getDisplacement() REFERENCE_FRAME not implemented\n";
        return;
        break ;
      }

      case vpRobot::MIXT_FRAME: 
      {
        std::cout << "getDisplacement() MIXT_FRAME not implemented\n";
        return;
        break ;
      }
    }
  }
  else 
  {
    first_time_getdis = false;
  }

  // Memorize the joint position for the next call
  q_prev_getdis = q_cur;
}

bool
vpSimulatorAfma6::readPosFile(const char *filename, vpColVector &q)
{
  FILE * fd ;
  fd = fopen(filename, "r") ;
  if (fd == NULL)
    return false;

  char line[FILENAME_MAX];
  char dummy[FILENAME_MAX];
  char head[] = "R:";
  bool sortie = false;

  do {
    // Saut des lignes commencant par #
    if (fgets (line, FILENAME_MAX, fd) != NULL) {
      if ( strncmp (line, "#", 1) != 0) {
        // La ligne n'est pas un commentaire
        if ( strncmp (line, head, sizeof(head)-1) == 0) {
          sortie = true;    // Position robot trouvee.
        }
        //  else
        //    return (false); // fin fichier sans position robot.
      }
    }
    else {
      fclose(fd) ;
      return (false);       /* fin fichier  */
    }

  }
  while ( sortie != true );

  // Lecture des positions
  q.resize(njoint);
  int ret = sscanf(line, "%s %lf %lf %lf %lf %lf %lf",
                   dummy,
                   &q[0], &q[1], &q[2], &q[3], &q[4], &q[5]);

  if (ret != 7) {
    fclose(fd) ;
    return false;
  }

  // converts rotations from degrees into radians
  //q.deg2rad();
  
  q[3] = vpMath::rad(q[3]);
  q[4] = vpMath::rad(q[4]);
  q[5] = vpMath::rad(q[5]);

  fclose(fd) ;
  return (true);
}

bool
vpSimulatorAfma6::savePosFile(const char *filename, const vpColVector &q)
{

  FILE * fd ;
  fd = fopen(filename, "w") ;
  if (fd == NULL)
    return false;

  fprintf(fd, "\
#AFMA6 - Position - Version 2.01\n\
#\n\
# R: X Y Z A B C\n\
# Joint position: X, Y, Z: translations in meters\n\
#                 A, B, C: rotations in degrees\n\
#\n\
#\n\n");

  // Save positions in mm and deg
  fprintf(fd, "R: %lf %lf %lf %lf %lf %lf\n",
      q[0],
      q[1],
      q[2],
      vpMath::deg(q[3]),
      vpMath::deg(q[4]),
      vpMath::deg(q[5]));

  fclose(fd) ;
  return (true);
}

void
vpSimulatorAfma6::move(const char *filename)
{
  vpColVector q;

  try
  {
    this->readPosFile(filename, q);
    this->setRobotState(vpRobot::STATE_POSITION_CONTROL);
    this->setPosition ( vpRobot::ARTICULAR_FRAME,  q);
  }
  catch(...) 
  {
    throw;
  }
}

void
vpSimulatorAfma6::get_cMe(vpHomogeneousMatrix &cMe)
{
  vpAfma6::get_cMe(cMe) ;
}

void
vpSimulatorAfma6::get_cVe(vpVelocityTwistMatrix &cVe)
{
  vpHomogeneousMatrix cMe ;
  vpAfma6::get_cMe(cMe) ;

  cVe.buildFrom(cMe) ;
}

void
vpSimulatorAfma6::get_eJe(vpMatrix &eJe_)
{
  try
  {
    vpAfma6::get_eJe(get_artCoord(), eJe_) ;
  }
  catch(...)
  {
    vpERROR_TRACE("catch exception ") ;
    throw ;
  }
}

void
vpSimulatorAfma6::get_fJe(vpMatrix &fJe_)
{
  try
  {
    vpColVector articularCoordinates = get_artCoord(); 
    vpAfma6::get_fJe(articularCoordinates, fJe_) ;
  }
  catch(...)
  {
    vpERROR_TRACE("Error caught");
    throw ;
  }
}

void 
vpSimulatorAfma6::stopMotion()
{
  if (getRobotState() != vpRobot::STATE_VELOCITY_CONTROL)
    return;
  
  vpColVector stop(6);
  stop = 0;
  set_artVel(stop);
  set_velocity(stop);
  setRobotState (vpRobot::STATE_STOP);
}



/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/

void
vpSimulatorAfma6::initArms()
{
  // set scene_dir from #define VISP_SCENE_DIR if it exists
  std::string scene_dir_;
  if (vpIoTools::checkDirectory(VISP_SCENES_DIR) == true) // directory exists
    scene_dir_ = VISP_SCENES_DIR;
  else {
    try {
      scene_dir_ = vpIoTools::getenv("VISP_SCENES_DIR");
      std::cout << "The simulator uses data from VISP_SCENES_DIR=" << scene_dir_ << std::endl;
    }
    catch (...) {
      std::cout << "Cannot get VISP_SCENES_DIR environment variable" << std::endl;
    }
  }

  unsigned int name_length = 30; // the size of this kind of string "/afma6_arm2.bnd"
  if (scene_dir_.size() > FILENAME_MAX)
    throw vpException (vpException::dimensionError, "Cannot initialize Afma6 simulator");
  unsigned int full_length = (unsigned int)scene_dir_.size() + name_length;
  if (full_length > FILENAME_MAX)
    throw vpException (vpException::dimensionError, "Cannot initialize Afma6 simulator");

  char *name_cam = new char [full_length];

  strcpy(name_cam, scene_dir_.c_str());
  strcat(name_cam,"/camera.bnd");
  set_scene(name_cam,&camera,cameraFactor);
  
  if (arm_dir.size() > FILENAME_MAX)
    throw vpException (vpException::dimensionError, "Cannot initialize Afma6 simulator");
  full_length = (unsigned int)arm_dir.size() + name_length;
  if (full_length > FILENAME_MAX)
    throw vpException (vpException::dimensionError, "Cannot initialize Afma6 simulator");

  char *name_arm = new char [full_length];
  strcpy(name_arm, arm_dir.c_str());
  strcat(name_arm,"/afma6_gate.bnd");
  set_scene(name_arm, robotArms, 1.0);
  strcpy(name_arm, arm_dir.c_str());
  strcat(name_arm,"/afma6_arm1.bnd");
  set_scene(name_arm, robotArms+1, 1.0);
  strcpy(name_arm, arm_dir.c_str());
  strcat(name_arm,"/afma6_arm2.bnd");
  set_scene(name_arm, robotArms+2, 1.0);
  strcpy(name_arm, arm_dir.c_str());
  strcat(name_arm,"/afma6_arm3.bnd");
  set_scene(name_arm, robotArms+3, 1.0);
  strcpy(name_arm, arm_dir.c_str());
  strcat(name_arm,"/afma6_arm4.bnd");
  set_scene(name_arm, robotArms+4, 1.0);
  
  vpAfma6::vpAfma6ToolType tool;
  tool = getToolType();
  strcpy(name_arm, arm_dir.c_str());
  switch (tool) {
  case vpAfma6::TOOL_CCMOP: {
      strcat(name_arm,"/afma6_tool_ccmop.bnd");
      break;
    }
  case vpAfma6::TOOL_GRIPPER: {
      strcat(name_arm,"/afma6_tool_gripper.bnd");
      break;
    }
  case vpAfma6::TOOL_VACUUM: {
      strcat(name_arm,"/afma6_tool_vacuum.bnd");
      break;
    }
  case vpAfma6::TOOL_GENERIC_CAMERA: {
      std::cout << "The generic camera is not handled in vpSimulatorAfma6.cpp" << std::endl;
      break;
    }
  }
  set_scene(name_arm, robotArms+5, 1.0);
  
  add_rfstack(IS_BACK);

  add_vwstack ("start","depth", 0.0, 100.0);
  add_vwstack ("start","window", -0.1,0.1,-0.1,0.1);
  add_vwstack ("start","type", PERSPECTIVE);
// 
//   sceneInitialized = true;
//   displayObject = true;
  displayCamera = true;

  delete [] name_cam;
  delete [] name_arm;
}


void 
vpSimulatorAfma6::getExternalImage(vpImage<vpRGBa> &I_)
{
  bool changed = false;
  vpHomogeneousMatrix displacement = navigation(I_,changed);

  //if (displacement[2][3] != 0)
  if (std::fabs(displacement[2][3]) > std::numeric_limits<double>::epsilon())
    camMf2 = camMf2*displacement;

  f2Mf = camMf2.inverse()*camMf;

  camMf = camMf2* displacement * f2Mf;

  double u;
  double v;
  //if(px_ext != 1 && py_ext != 1)
  // we assume px_ext and py_ext > 0
  if( (std::fabs(px_ext-1.) > vpMath::maximum(px_ext,1.)*std::numeric_limits<double>::epsilon()) 
      && (std::fabs(py_ext-1) > vpMath::maximum(py_ext,1.)*std::numeric_limits<double>::epsilon()))
  {
    u = (double)I_.getWidth()/(2*px_ext);
    v = (double)I_.getHeight()/(2*py_ext);
  }
  else
  {
    u = (double)I_.getWidth()/(vpMath::minimum(I_.getWidth(),I_.getHeight()));
    v = (double)I_.getHeight()/(vpMath::minimum(I_.getWidth(),I_.getHeight()));
  }

  float w44o[4][4],w44cext[4][4],x,y,z;

  vp2jlc_matrix(camMf.inverse(),w44cext);

  add_vwstack ("start","cop", w44cext[3][0],w44cext[3][1],w44cext[3][2]);
  x = w44cext[2][0] + w44cext[3][0];
  y = w44cext[2][1] + w44cext[3][1];
  z = w44cext[2][2] + w44cext[3][2];
  add_vwstack ("start","vrp", x,y,z);
  add_vwstack ("start","vpn", w44cext[2][0],w44cext[2][1],w44cext[2][2]);
  add_vwstack ("start","vup", w44cext[1][0],w44cext[1][1],w44cext[1][2]);
  add_vwstack ("start","window", -u, u, -v, v);
  
  vpHomogeneousMatrix fMit[8];
  get_fMi(fMit);
  
  vp2jlc_matrix(vpHomogeneousMatrix(0,0,0,0,0,0),w44o);
  display_scene(w44o,robotArms[0],I_, curColor);
  
  vp2jlc_matrix(fMit[0],w44o);
  display_scene(w44o,robotArms[1],I_, curColor);
  
  vp2jlc_matrix(fMit[2],w44o);
  display_scene(w44o,robotArms[2],I_, curColor);
  
  vp2jlc_matrix(fMit[3],w44o);
  display_scene(w44o,robotArms[3],I_, curColor);
  
  vp2jlc_matrix(fMit[4],w44o);
  display_scene(w44o,robotArms[4],I_, curColor);
  
  vp2jlc_matrix(fMit[5],w44o);
  display_scene(w44o,robotArms[5],I_, curColor);

  if (displayCamera)
  {
    vpHomogeneousMatrix cMe;
    get_cMe(cMe);
    cMe = cMe.inverse();
    cMe = fMit[6] * cMe;
    vp2jlc_matrix(cMe,w44o);
    display_scene(w44o,camera, I_, camColor);
  }
  
  if (displayObject)
  {
    vp2jlc_matrix(fMo,w44o);
    display_scene(w44o,scene,I_, curColor);
  }
}

bool
vpSimulatorAfma6::initialiseCameraRelativeToObject(const vpHomogeneousMatrix &cMo_)
{
  vpColVector stop(6);
  bool status = true;
  stop = 0;
  set_artVel(stop);
  set_velocity(stop);
  vpHomogeneousMatrix fMc_;
  fMc_ = fMo * cMo_.inverse();
  
  vpColVector articularCoordinates = get_artCoord();
  int nbSol = getInverseKinematics(fMc_, articularCoordinates, true, verbose_);
  
  if (nbSol == 0) {
    status = false;
    vpERROR_TRACE ("Positionning error. Position unreachable");
  }
  
  if (verbose_)
    std::cout << "Used joint coordinates (rad): " << articularCoordinates.t() << std::endl;

  set_artCoord(articularCoordinates);
  
  compute_fMi();

  return status;
}

void 
vpSimulatorAfma6::initialiseObjectRelativeToCamera(const vpHomogeneousMatrix &cMo_)
{
  vpColVector stop(6);
  stop = 0;
  set_artVel(stop);
  set_velocity(stop);
  vpHomogeneousMatrix fMit[8];
  get_fMi(fMit);
  fMo = fMit[7] * cMo_;
}

bool
vpSimulatorAfma6::setPosition(const vpHomogeneousMatrix &cdMo_, vpImage<unsigned char> *Iint, const double &errMax)
{
    // get rid of max velocity
    double vMax = getMaxTranslationVelocity();
    double wMax = getMaxRotationVelocity();
    setMaxTranslationVelocity(10.*vMax);
    setMaxRotationVelocity(10.*wMax);

    vpColVector v(3),w(3),vel(6);
    vpHomogeneousMatrix cdMc;
    vpTranslationVector cdTc;vpRotationMatrix cdRc;vpThetaUVector cdTUc;
    vpColVector err(6);err=1.;
    const double lambda = 5.;
    double t;

    vpVelocityTwistMatrix cVe;

    unsigned int i,iter=0;
    while((iter++<300) & (err.euclideanNorm()>errMax))
        {
        t = vpTime::measureTimeMs();

        // update image
        if(Iint != NULL)
        {
            vpDisplay::display(*Iint);
            getInternalView(*Iint);
            vpDisplay::flush(*Iint);
        }

        // update pose error
    cdMc = cdMo_*get_cMo().inverse();
        cdMc.extract(cdRc);
        cdMc.extract(cdTc);
        cdTUc.buildFrom(cdRc);

        // compute v,w and velocity
        v = -lambda*cdRc.t()*cdTc;
        w = -lambda*cdTUc;
        for(i=0;i<3;++i)
        {
            vel[i] = v[i];
            vel[i+3] = w[i];
            err[i] = cdTc[i];
            err[i+3] = cdTUc[i];
        }

        // update feat
        setVelocity(vpRobot::CAMERA_FRAME,vel);

        // wait for it
        vpTime::wait(t,10);
        }
    vel=0.;
    set_velocity(vel);
    set_artVel(vel);
    setMaxTranslationVelocity(vMax);
    setMaxRotationVelocity(wMax);

    //std::cout << "setPosition: final error " << err.t() << std::endl;
    return(err.euclideanNorm()<= errMax);
}

#endif