altransformhelpers.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012 Aldebaran Robotics. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the COPYING file.
 */


#pragma once
#ifndef _LIBALMATH_ALMATH_TOOLS_ALTRANSFORMHELPERS_H_
#define _LIBALMATH_ALMATH_TOOLS_ALTRANSFORMHELPERS_H_

#include <almath/types/alposition2d.h>
#include <almath/types/alposition3d.h>
#include <almath/types/alposition6d.h>
#include <almath/types/alrotation.h>
#include <almath/types/alrotation3d.h>
#include <almath/types/alvelocity6d.h>
#include <almath/types/altransform.h>
#include <almath/types/alaxismask.h>
#include <almath/types/alpose2d.h>
#include <almath/types/alquaternion.h>
#include <almath/types/aldisplacement.h>

namespace AL {
  namespace Math {



  ALMATH_API void transformLogarithmInPlace(
    const Transform& pT,
    Velocity6D&      pVel);



    ALMATH_API Velocity6D transformLogarithm(const Transform& pT);



    ALMATH_API Transform velocityExponential(const Velocity6D& pVel);

    // TODO: Add to doc or set private.
    ALMATH_API void velocityExponentialInPlace(
      const Velocity6D& pVel,
      Transform&        pT);


    ALMATH_API void changeReferenceVelocity6D(
      const Transform&  pT,
      const Velocity6D& pVelIn,
      Velocity6D&       pVelOut);


    ALMATH_API void changeReferencePosition6D(
      const Transform&  pT,
      const Position6D& pPosIn,
      Position6D&       pPosOut);

    // TODO: rename argument.
    ALMATH_API void changeReferencePosition3DInPlace(
      const Transform& pT,
      Position3D&      pPosOut);

    // TODO: rename argument.
    ALMATH_API void changeReferenceTransposePosition3DInPlace(
      const Transform& pT,
      Position3D&      pPosOut);


    ALMATH_API void changeReferencePosition3D(
      const Transform&  pT,
      const Position3D& pPosIn,
      Position3D&       pPosOut);


    ALMATH_API void changeReferenceTransposePosition3D(
      const Transform&  pT,
      const Position3D& pPosIn,
      Position3D&       pPosOut);


    ALMATH_API void changeReferenceTransform(
      const Transform& pT,
      const Transform& pTIn,
      Transform&       pTOut);


    ALMATH_API void changeReferenceTransposeTransform(
      const Transform& pT,
      const Transform& pTIn,
      Transform&       pTOut);



    ALMATH_API void changeReferenceTransposeVelocity6D(
      const Transform&  pT,
      const Velocity6D& pVelIn,
      Velocity6D&       pVelOut);


    ALMATH_API void changeReferenceTransposePosition6D(
      const Transform&  pT,
      const Position6D& pPosIn,
      Position6D&       pPosOut);

    ALMATH_API void transformMeanInPlace(
      const Transform& pTIn1,
      const Transform& pTIn2,
      const float&     pVal,
      Transform&       pTOut);

    ALMATH_API Transform transformMean(
      const Transform& pTIn1,
      const Transform& pTIn2,
      const float&     pVal = 0.5f);


    ALMATH_API Transform transformFromRotationPosition3D(
      const Rotation& pRot,
      const float&    pX,
      const float&    pY,
      const float&    pZ);


    ALMATH_API Transform transformFromRotationPosition3D(
      const Rotation&   pRot,
      const Position3D& pPos);


    ALMATH_API void transformFromPosition3DInPlace(
      const Position3D& pPosition,
      Transform&        pTransform);


    ALMATH_API Transform transformFromPosition3D(const Position3D& pPosition);


    ALMATH_API void transformFromRotationInPlace(
      const Rotation& pRotation,
      Transform&      pTransform);


    ALMATH_API Transform transformFromRotation(const Rotation& pRotation);

    ALMATH_API void rotationFromTransformInPlace(
      const Transform& pTransform,
      Rotation&        pRotation);

    ALMATH_API Rotation rotationFromTransform(const Transform& pTransform);

    ALMATH_API Rotation3D rotation3DFromRotation(const Rotation& pRotation);

    ALMATH_API Rotation rotationFromAxesXY(const Position3D& pX, const Position3D& pY);

    ALMATH_API Rotation rotationFromAxesXZ(const Position3D& pX, const Position3D& pZ);

    ALMATH_API Rotation rotationFromAxesYZ(const Position3D& pY, const Position3D& pZ);

    ALMATH_API Rotation rotationFromAxesXYZ(const Position3D& pX, const Position3D& pY, const Position3D& pZ);


    ALMATH_API void position6DFromTransformInPlace(
        const Transform& pT,
        Position6D&      pPos);

    ALMATH_API Position6D position6DFromTransform(const Transform& pT);

    ALMATH_API void transformFromPose2DInPlace(
        const Pose2D& pPose,
        Transform&    pT);

    ALMATH_API Transform transformFromPose2D(const Pose2D& pPose);

    ALMATH_API void pose2DFromTransformInPlace(
        const Transform& pT,
        Pose2D&          pPos);

    ALMATH_API Pose2D pose2DFromTransform(const Transform& pT);

    ALMATH_API void position2DFromTransformInPlace(
        const Transform&     pT,
        Position2D&          pPos);

    ALMATH_API Position2D position2DFromTransform(const Transform& pT);

    ALMATH_API Transform transformFromRotation3D(const Rotation3D& pRotation);

    ALMATH_API Transform transformFromPosition6D(const Position6D& pPosition6D);

    ALMATH_API void position6DFromTransformDiffInPlace(
      const Transform& pCurrent,
      const Transform& pTarget,
      Position6D&      result);

    ALMATH_API Position6D position6DFromTransformDiff(
      const Transform& pCurrent,
      const Transform& pTarget);


    ALMATH_API void position3DFromTransformInPlace(
      const Transform& pT,
      Position3D&      pPos);


    ALMATH_API Position3D position3DFromTransform(const Transform& pT);


    ALMATH_API Rotation3D rotation3DFromTransform(const Transform& pT);

    ALMATH_API void transformFromRotVecInPlace(
      const int         pAxis,
      const float       pTheta,
      const Position3D& pPos,
      Transform&        pT);

    ALMATH_API Transform transformFromRotVec(
      const int         pAxis,
      const float       pTheta,
      const Position3D& pPos);


    ALMATH_API void transformFromRotVecInPlace(
      const Position3D& pPos,
      Transform&        pT);

    ALMATH_API Transform transformFromRotVec(const Position3D& pPos);


    ALMATH_API Transform transformFromRotVec(
      const int&   pAxis,
      const float& pTheta);

    ALMATH_API Position3D operator*(
      const Transform&  pT,
      const Position2D& pPos);

    ALMATH_API Position3D operator*(
      const Transform&  pT,
      const Position3D& pPos);

    ALMATH_API Transform axisRotationProjection(
      const Position3D& pAxis,
      const Transform&  pT);

    ALMATH_API Rotation axisRotationProjection(
      const Position3D& pAxis,
      const Rotation&   pRot);


    ALMATH_API void axisRotationProjectionInPlace(
      const Position3D& pAxis,
      Transform&        pT);

    ALMATH_API void axisRotationProjectionInPlace(
      const Position3D& pAxis,
      Rotation&         pRot);

    ALMATH_API void orthogonalSpace(
      const Position3D& pPos,
      Transform&        pTf);

    ALMATH_API Transform orthogonalSpace(const Position3D& pPos);

    ALMATH_API Transform transformFromQuaternion(
      const Quaternion& pQua);

    ALMATH_API Quaternion quaternionFromTransform(
      const Transform& pT);

    ALMATH_API Transform transformFromDisplacement(const Displacement& pDisp);

    ALMATH_API Displacement displacementFromTransform(const Transform& pTrans);

  } // namespace Math
} // namespace AL
#endif  // _LIBALMATH_ALMATH_TOOLS_ALTRANSFORMHELPERS_H_