---

IKJacobian.h

Go to the documentation of this file.

//
//      Title           : IKJacobian.h
//      Project         : OSCAR
//      Created         : Thu Nov 30 07:52:08 1995
//      Author          : Chetan Kapoor & Peter March
//              Platforms               :  All
//              Copyright               :  Copyright) The University of Texas at Austin, 2002. All rights reserved.
//                 
//          This software and documentation constitute an unpublished work
//          and contain valuable trade secrets and proprietary information
//          belonging to the University. None of the foregoing material may be
//          copied or duplicated or disclosed without the express, written
//          permission of University. THE UNIVERSITY EXPRESSLY DISCLAIMS ANY
//          AND ALL WARRANTIES CONCERNING THIS SOFTWARE AND DOCUMENTATION,
//          INCLUDING ANY WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//          PARTICULAR PURPOSE, AND WARRANTIES OF PERFORMANCE, AND ANY WARRANTY
//          THAT MIGHT OTHERWISE ARISE FROM COURSE OF DEALING OR USAGE OF TRADE.
//          NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH RESPECT TO THE USE OF
//          THE SOFTWARE OR DOCUMENTATION. Under no circumstances shall the
//          University be liable for incidental, special, indirect, direct or
//          consequential damages or loss of profits, interruption of business,
//          or related expenses which may arise from use of software or documentation,
//          including but not limited to those resulting from defects in software
//          and/or documentation, or loss or inaccuracy of data of any kind.
//
//      Purpose                 : Declares a Generalized Inverse class that uses the Jacobian inverse
//                                                to compute an inverse position solution.  
//
//----------------------------------------------------------------------------
//
//      $Revisions$
//
//      $Log: IKJacobian.h,v $
//      Revision 1.10  2007/02/09 22:47:56  chetan
//      Some methods were not declared virtual
//
//      Revision 1.9  2005/03/14 21:53:30  pmarch
//      Added to namespace OSCAR and removed "RR" from front of class names.
//
//      Revision 1.8  2005/01/11 16:08:09  pmarch
//      Set default template parameter to FKJacobian and added additional commenting.
//
//      Revision 1.7  2005/01/10 18:53:59  chetan
//      Fixed documentation
//
//      Revision 1.6  2005/01/10 17:35:58  pmarch
//      Added template parameter to IKJacobian-based objects to allow user to supply custom forward kinematics object.
//
//      Revision 1.5  2004/07/29 20:15:52  chetan
//      Minor changes to compile under g++ with -Wall and -pedantic warning flags enabled
//
//      Revision 1.4  2004/07/23 22:20:26  chetan
//      Made changes to compile with Warning Level 4 and also under the latest C++ standard
//
//      Revision 1.3  2004/05/26 20:15:35  pmarch
//      Added /defgroup and /ingroup tags.
//
//      Revision 1.2  2004/04/22 18:08:23  eswint
//      - Changed constructor of IKJacobian to take const JointVector, reflected in changes to constructors for IKJReconfig & IKJAvoidLimits and IJKAvoidLimits::computeWeightingMatrix
//
//      Revision 1.1  2003/08/18 21:04:08  mtisius
//      Initial commit of inverse kinematics
//
//
#ifndef IKJacobian_hpp
#define IKJacobian_hpp

#include "Math/HandPose.h"
#include "Math/EqnSolver.h"
#include "ForwardKinematics/FKJacobian.h"
#include "InverseKinematics/IKVelocity.h"

namespace OSCAR {

  class DHData;

  template <class JacobianType=FKJacobian>
  class IKJacobian : public IKVelocity, IKPosition
  {

  public:
  
    IKJacobian(const JointVector& initialJointPosition, 
                  JacobianType* fkJacobian, 
                  OSCARError& err = DUMMY_ERROR(noError),
                  EqnSolver* solver = 0, double maxError = 0.1, 
                  double rtScale = 1000.0);

          IKJacobian(const IKJacobian& rhs);

    IKJacobian& operator=(const IKJacobian& rhs);

      virtual ~IKJacobian();

      virtual bool GetJointPosition(const Xform& desiredHandMatrix, JointVector& jointPosition);
    
      virtual bool GetJointPosition(const HandPose& desiredHand, JointVector& jointPosition);

      virtual bool GetJointVelocity(const HandPose& handVelocity, JointVector& jointVelocitySolution);

      virtual bool GetJointPosition(JointVector& jointPosition) const;  
    
      virtual bool SetJointPosition(const JointVector& jointPosition);

      void SetMinimumMOT(double minMOT);

      double GetMinimumMOT() const;

      void SetMaximumIterations(unsigned int noIterations);

      unsigned int GetMaximumIterations(void) const;

      bool SetErrorTolerance(double maxErrorVal, double rotScale);

      bool GetErrorTolerance(double& maxErrorVal, double& rotScale) const;

      double GetSolutionProperties(void) const;

      double GetSolutionProperties(unsigned int& iterationCount) const;

      double GetSolutionProperties(double& errorMagnitude) const;

      double GetSolutionProperties(Matrix& jacobian) const;

      double GetSolutionProperties(Xform& currentHandPos) const;
    
  protected:

      unsigned int    DOF;
      unsigned int    maxIterations;
      unsigned int    currentIteration;     //these are intended to be used in converge
      double                        maxError;
      double                        rotationScale;
      double                        minimumMOT;
      double          MOT;
      double            errorMag;
      Xform         desiredXform;

      JointVector         *currentJointVector;
      JointVector         *previousJointVector;
      JointVector         *initialJointVector;
      JointVector         *differentialJointVector;
      JointVector         *jointVelocity;
    
      HandPose      errorHandVector;
      const Xform   *currentHand;
      const Matrix      *currentJacobian;
      JacobianType   *fowkin;
      EqnSolver     *solver;
    
      virtual bool      converge(const Xform& desiredHandMatrix);

      virtual double    calculateErrorMagnitude(const Xform& desired, 
                                                const Xform* current, 
                                                HandPose& error);
      virtual void      updateKinematicState(JointVector& jointPosition);
      virtual bool      inverse();


      bool internalSolverFlag;
  };

  #include "InverseKinematics/IKJacobian.ipp"

}
#endif  // IKJacobian_hpp

RRG Homepage

OSCAR Overview

OSCAR Tutorials

Simulations