---

FKVelocity.h

Go to the documentation of this file.

//
//       Title      : FKVelocity.h
//       Project    : OSCAR
//       Created    : Thu Feb  8 10:15:06 1996
//       Author     : Chetan Kapoor
//       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 University.  None of the foregoing material may be
//                    copied  or duplicated or disclosed without the express, written
//                    permission of University.  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
//                    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    : Class to compute Translational and Rotational G functions
//
//----------------------------------------------------------------------------
//
//       Classes:
//               <none>
//
//       Global Functions:
//               <none>
//
//       Global Variables:
//               <none>
//
//----------------------------------------------------------------------------
//
//       $Revisions$
//    4-30-97: Troy Harden. I got rid of the local var Pl since it wasted
//        space. Changed SetLinkPoints(local_positions) function to convert
//        the local positions to global positions by calling the 
//        calculateGlobalPosition() function  and then store them in Pg.
//        calculateTranslationalGfunctions(int joint_no) no longer calls
//        calculateGlobalPosition() since it is no longer necessary.
//
//        Also added a new function SetGlLinkPoints(global_positions) which
//        directly sets Pg if the user has global instead of local positions.
//
//    5-5-97: Troy Harden. I added two new functions that calculate and 
//       return G functions for a single link instead of all links. The 
//       two functions are:  
//         GetTranslationalGfunction(int joint_no)
//         GetTranslationalGfunction(int joint_no, const Vector& joint_angles)
//
//       $Log: FKVelocity.h,v $
//       Revision 1.8  2007/03/30 20:33:48  aspencer
//       Added functionality to change link points for G and H function calculation one frame at a time.
//
//       Revision 1.7  2005/03/17 21:27:52  chetan
//       Changed RRReferenceFrame to ReferenceFrame
//
//       Revision 1.6  2005/03/14 21:53:04  pmarch
//       Added to namespace OSCAR and removed "RR" from front of class names.
//
//       Revision 1.5  2004/07/23 22:19:54  chetan
//       Made changes to compile with Warning Level 4 and also under the latest C++ standard
//
//       Revision 1.4  2004/05/26 20:10:08  pmarch
//       Added /defgroup and /ingroup tags.
//
//       Revision 1.3  2004/05/11 21:31:27  eswint
//       - Added comments
//
//       Revision 1.2  2003/09/09 19:38:54  rctaylor
//       Modified calculation of translational G functions to use the ReferenceFrame enum. This allows the calculations to be done using global or local linkPoints based on the current mode. The default is using local linkPoints set to all zero thus matching the Jacobian.
//
//       Revision 1.1  2003/08/18 20:32:12  pmarch
//       Initial commit of ForwardKinematics
//
//

#ifndef FKVelcoity_hpp
#define FKVelcoity_hpp

#include "ForwardKinematics/FKJacobian.h"
#include "Math/Tensor.h"


namespace OSCAR {
  class FKVelocity : public FKPosition
  {

  public:
    FKVelocity(const String& DHfilename, OSCARError& err = DUMMY_ERROR(noError));


    FKVelocity(const DHData& dhParams, OSCARError& err = DUMMY_ERROR(noError));



    FKVelocity(const FKVelocity& fkv);


    FKVelocity& operator=(const FKVelocity& fkv);


    void SetLinkPoints(const ReferenceFrame frame);


    bool SetLinkPoints(const Matrix& linkPoints, const ReferenceFrame frame=Local);

    bool SetLinkPoint(const Vector3& newPoint, unsigned int frameNum);


    const Tensor*       GetRotationalGfunctions(void);

    const Tensor*       GetRotationalGfunctions(const Vector& jointVector);


    const Tensor*       GetTranslationalGfunctions(void);

    const Tensor*       GetTranslationalGfunctions(const Vector& jointVector);


    const Matrix* GetTranslationalGfunction(unsigned int jointNo);


    const Matrix* GetTranslationalGfunction(unsigned int jointNo, const Vector& jointVector);


    virtual ~FKVelocity();

  protected:
    ReferenceFrame frameMode; 

    Matrix *localLinkPoints;    
                                                                                // for which trans_g_func is to be calculated.

    Matrix *globalLinkPoints;   
                                                                                // for which trans_g_func is to be calculated.

    Tensor *rot_g_func; 
                                                                                                  // first-order influence coefficients, i.e. [Gjk]n.

    Tensor *trans_g_func;  
                             // translational first-order influence
                                               // coefficients, i.e. [Gp]n

    void        calculateGlobalPosition(unsigned int joint_no, Vector3* calcGlob);
    void  calculateRotationalGfunctions(void);
    void  calculateTranslationalGfunctions(unsigned int joint_no);

  };

  #include "ForwardKinematics/FKVelocity.ipp"

}
#endif  // FKVelocity_hpp

RRG Homepage

OSCAR Overview

OSCAR Tutorials

Simulations