vpThetaUVector.cpp

/****************************************************************************
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2015 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://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:
 * Theta U parameterization for the rotation.
 *
 * Authors:
 * Eric Marchand
 *
 *****************************************************************************/

#include <cmath>    // std::fabs
#include <limits>   // numeric_limits

#include <visp3/core/vpThetaUVector.h>

const double vpThetaUVector::minimum = 0.0001;

vpThetaUVector::vpThetaUVector()
  : vpRotationVector(3)
{}
vpThetaUVector::vpThetaUVector(const vpThetaUVector &tu)
  : vpRotationVector(tu)
{}

vpThetaUVector::vpThetaUVector(const vpHomogeneousMatrix& M)
  : vpRotationVector(3)
{
  buildFrom(M) ;
}
vpThetaUVector::vpThetaUVector(const vpPoseVector& p)
  : vpRotationVector(3)
{
  buildFrom(p) ;
}
vpThetaUVector::vpThetaUVector(const vpRotationMatrix& R)
  : vpRotationVector(3)
{
  buildFrom(R) ;
}

vpThetaUVector::vpThetaUVector(const vpRzyxVector& rzyx)
  : vpRotationVector(3)
{
  buildFrom(rzyx) ;
} 
vpThetaUVector::vpThetaUVector(const vpRzyzVector& rzyz)
  : vpRotationVector(3)
{
  buildFrom(rzyz) ;
}
vpThetaUVector::vpThetaUVector(const vpRxyzVector& rxyz)
  : vpRotationVector(3)
{
  buildFrom(rxyz) ;
}
vpThetaUVector::vpThetaUVector(const vpQuaternionVector& q)
  : vpRotationVector(4)
{
  buildFrom(q) ;
}

vpThetaUVector::vpThetaUVector(const double tux, const double tuy, const double tuz)
  : vpRotationVector (3)
{
  buildFrom(tux, tuy, tuz);
}

vpThetaUVector
vpThetaUVector::buildFrom(const vpHomogeneousMatrix& M)
{
  vpRotationMatrix R;

  M.extract(R);
  buildFrom(R);

  return *this ;
}
vpThetaUVector
vpThetaUVector::buildFrom(const vpPoseVector& p)
{
  for(unsigned int i=0; i<3; i++)
    data[i] = p[i+3];

  return *this ;
}

vpThetaUVector
vpThetaUVector::buildFrom(const vpRotationMatrix& R)
{
  double s,c,theta,sinc;

  s = (R[1][0]-R[0][1])*(R[1][0]-R[0][1])
    + (R[2][0]-R[0][2])*(R[2][0]-R[0][2])
    + (R[2][1]-R[1][2])*(R[2][1]-R[1][2]);
  s = sqrt(s)/2.0;
  c = (R[0][0]+R[1][1]+R[2][2]-1.0)/2.0;
  theta=atan2(s,c);  /* theta in [0, PI] since s > 0 */

  // General case when theta != pi. If theta=pi, c=-1
  if ( (1+c) > minimum) // Since -1 <= c <= 1, no fabs(1+c) is required
  {
    sinc = vpMath::sinc(s,theta);

    data[0] = (R[2][1]-R[1][2])/(2*sinc);
    data[1] = (R[0][2]-R[2][0])/(2*sinc);
    data[2] = (R[1][0]-R[0][1])/(2*sinc);
  }
  else /* theta near PI */
  {
    if ( (R[0][0]-c) < std::numeric_limits<double>::epsilon() )
      data[0] = 0.;
    else
      data[0] = theta*(sqrt((R[0][0]-c)/(1-c)));
    if ((R[2][1]-R[1][2]) < 0) data[0] = -data[0];

    if ( (R[1][1]-c) < std::numeric_limits<double>::epsilon() )
      data[1] = 0.;
    else
      data[1] = theta*(sqrt((R[1][1]-c)/(1-c)));

    if ((R[0][2]-R[2][0]) < 0) data[1] = -data[1];

    if ( (R[2][2]-c) < std::numeric_limits<double>::epsilon() )
      data[2] = 0.;
    else
      data[2] = theta*(sqrt((R[2][2]-c)/(1-c)));

    if ((R[1][0]-R[0][1]) < 0) data[2] = -data[2];
  }

  return *this ;
}
vpThetaUVector
vpThetaUVector::buildFrom(const vpRzyxVector& rzyx)
{
  vpRotationMatrix R(rzyx) ;

  buildFrom(R) ;
  return *this ;
}
vpThetaUVector
vpThetaUVector::buildFrom(const vpRzyzVector& rzyz)
{
  vpRotationMatrix R(rzyz) ;

  buildFrom(R) ;
  return *this ;
}
vpThetaUVector
vpThetaUVector::buildFrom(const vpRxyzVector& rxyz)
{
  vpRotationMatrix R(rxyz) ;

  buildFrom(R) ;
  return *this ;
}

vpThetaUVector
vpThetaUVector::buildFrom(const vpQuaternionVector& q)
{
  vpRotationMatrix R(q) ;

  buildFrom(R) ;
  return *this ;
}

vpThetaUVector &vpThetaUVector::operator=(double v)
{
  for (unsigned int i=0; i< dsize; i++)
    data[i] = v;

  return *this;
}

void 
vpThetaUVector::extract(double &theta, vpColVector &u) const
{
  u.resize(3);

  theta = sqrt(data[0]*data[0] + data[1]*data[1] + data[2]*data[2]);
  //if (theta == 0) {
  if (std::fabs(theta) <= std::numeric_limits<double>::epsilon()) {
    u = 0;
    return;
  }
  for (unsigned int i=0 ; i < 3 ; i++) 
    u[i] = data[i] / theta ;
}

void
vpThetaUVector::buildFrom(const double tux, const double tuy, const double tuz)
{
  data[0] = tux;
  data[1] = tuy;
  data[2] = tuz;
}