BROS-I standard: draft proposal 29 AUG 2004

Here is the BROS-I draft.

Herman

-- 
   K.U.Leuven, Mechanical Engineering, Robotics Research Group
<http://people.mech.kuleuven.ac.be/~bruyninc> Tel: +32 16 322480
=================================================================

BROS-I  --- Basic Robotics Standards, Level 1
Primitive data structures (numerical representations) for motion (position,
velocity, acceleration), force, and derived quantities.
Herman Bruyninckx, 29 AUG 2004

This document is released in the public domain. The presented standards can
be used without any restriction, except that the names "BROS" and "Basic
Robotics Standards" can only be used to refer to the material in this and
related documents, and in later versions thereof.

Introduction
-----------
This document is part of a multi-level standardisation effort launched by
several Free Software and Open Source robotics projects. This first
level of the standard is limited to the definition of numerical
representations of common primitive concepts in robotics. "Primitive"
means: consisting of only the basic numerical types "float" and "int".

These representations are completely free of any special interpretation in
whatever robotics application domain.

All defined objects live in the three-dimensional Euclidean space.

To Be Discussed:
If two-dimensional ("planar") objects are needed, the suffix "2D" could be
added to the data structure names; for example, "RotMatrix2D".

All physical units are in SI (Systeme International d'Unites, International
System of Units, <http://physics.nist.gov/cuu/Units/>). More in particular:
distances in meter, angles in radians, forces in Newton, time in seconds.

When encoded in a programming language, the "argument namess" given in each
object can become the fields in a data structure in the language. For
example, if T is a HomTrans matrix, then T.Rxx is the top-left element of T.

Mathematical representations
----------------------------

Point:
  x: float
  y: float
Coordinates of a point in the 3D Euclidean space.

Vector:
  x: float
  y: float
  z: float
Coordinates of the directed line segment from one Point to another
Point. No distinction is made between "free vectors" (not bound to any
particular line), "line vectors" (bound to a particular line), or "point
vectors" (bound to a particular point).

UnitVector:
  x: float with range [-1,1]
  y: float with range [-1,1]
  z: float with range [-1,1]
vector whose coordinates must satisfy the constraint X^2 + y^2 + z^2 = 1.

RotationAngle:
  float, with unlimited range.

OrientationAngle:
  float, with range [-pi,+pi]

HeadingAngle:
  float, with range [-pi/2,+pi/2]

To Be Discussed: there are no basic numerical types that impose the ranges
of the two above-mentioned objects. Is this a reason not to include them in
this level of the standards?

RotMatrix:
  Rxx: float
  Rxy: float
  Rxz: float
  Ryx: float
  Ryy: float
  Ryz: float
  Rzx: float
  Rzx: float
  Rzz: float
nine floats representing the 3 x 3 matrix with the direction cosines of the
unit vectors of one orthogonal, right-handed reference frame with respect
to another orthogonal, right-handed reference frame:
              | Rxx Ryx Rzx |
  RotMatrix = | Rxy Ryy Rzy |
              | Rxz Ryz Rzz |
All rows and colums are orthogonal UnitVectors.

RotX:
  a: float
RotMatrix representing a rotation about the X axis over an angle a:
            | 1   0     0 |
  RotX(a) = | 0  ca   -sa |
            | 0  sa    ca |

RotY:
  a: float
RotMatrix representing a rotation about the Y axis over an angle a:
            |  ca  0  -sa |
  RotY(a) = |   0  1    0 |
            | -sa  0   ca |

RotX:
  a: float
RotMatrix representing a rotation about the Z axis over an angle a:
            | ca  -sa   0 |
  RotZ(a) = | sa   ca   0 |
            |  0    0   1 |

EulerMovingXYZ:
   a: float
   b: float
   c: float
Sequence of three rotations about moving frame axes.
(Alternative name: "EulerXYZ", because most literature defines Euler angles
  around moving axis.)
The magnitudes of angles are limited, but the three angles do not have the
same limits.
The angle "a" belongs to the rotation around the first named axis, "b" to
the second named axis, and "c" to the last named axis; for example, in
EulerMovingXYZ(a,b,c), the rotation around "X" is over the angle "a", the
rotation about "Y" is over the angle "b", and the rotation about "Z" is
over the angle "c".
There are twelve possible combinations of Euler angles:
EulerMovingXYZ(a,b,c) = RotZ(c) RotY(b) RotX(a), and similarly for
EulerMovingXZY, EulerMovingXYX, EulerMovingXZX, EulerMovingYXZ,
EulerMovingYZX, EulerMovingYXY, EulerMovingYZY, EulerMovingZXY,
EulerMovingZYX, EulerMovingZXZ, EulerMovingZYZ

EulerFixedXYZ:
   r: float
   p: float
   y: float
Sequence of three rotations about fixed frame axes:
(Alternative name: RPY_XYZ ("roll-pitch-yaw").)
EulerFixedXYZ(a,b,c) = RotX(a) RotY(b) RotZ(c), and similarly for
EulerFixedXZY, EulerFixedXYX, EulerFixedXZX, EulerFixedYXZ,
EulerFixedYZX, EulerFixedYXY, EulerFixedYZY, EulerFixedZXY,
EulerFixedZYX, EulerFixedZXZ, EulerFixedZYZ.

Quaternion:
  V: Vector
  s: float
Ordered couple of a Vector (representing the axis around which to rotate),
and a scalar (representing the magnitude of a rotation).
s is not the angle of rotation itself, but the cosine of the half of that
angle; the Vector is not the direction (unit vector) of the rotation axis
itself, but this direction unit vector multiplied by the sine of the half
of that angle. The major reason for the existence of Quaternions is that
they do not have algebraic singularities, which all Euler angles do have.
The coordinates of a Quaternion satisfy the following constraints:
  Vx^2 + Vy^2 + Vz^2 + s^2 = 1.

HomTrans:
  Rxx: float
  Rxy: float
  Rxz: float
  Ryx: float
  Ryy: float
  Ryz: float
  Rzx: float
  Rzx: float
  Rzz: float
  Px:  float
  Py:  float
  Pz:  float
Twelve floats representing an homogeneous transformation matrix, i.e., 4 x
4 matrix of floats containing a RotMatrix and a Point in the following
form:
             | Rxx Ryx Rzx Px |
             | Rxy Ryy Rzy Py |
  HomTrans = | Rxz Ryz Rzz Pz |
             |  0   0   0  1  |

Velocity: Vector representing the velocity of a Point
  Vx: float
  Vy: float
  Vz: float

Acceleration: Vector representing the acceleration of a Point
  Vx: float
  Vy: float
  Vz: float

AngularVelocity: Vector representing the angular velocity of a rigid body
  Ax: float
  Ay: float
  Az: float

AngularAcceleration: Vector representing the angular acceleration of a
rigid body
  Ox: float
  Oy: float
  Oz: float

Force: Vector representing a linear force
  Fx: float
  Fy: float
  Fz: float

Moment: Vector representing a force moment
  Mx: float
  My: float
  Mz: float

Twist: ordered couple (V,W) of two Vectors:
  V: Velocity
  W: AngularVelocity
V is the velocity vector of the "velocity reference point", which is the
origin of the frame in which the coordinates are expressed. W is an
angular velocity vector.
(Note: using a velocity reference point that is not the origin requires
extra information to be given, i.c. the Position of that velocity reference
point.)

Wrench: ordered couple (F,M) of two Vectors:
  F: Vector (F: Fx Fy Fz)
  M: Vector (M: Mx My Mz)
F is a linear force vector. M is the moment vector at the "moment reference
point", which is the origin of the frame in which the coordinates are
expressed.

AccelerationTwist: ordered couple (A,O) of two Vectors:
  A: Acceleration
  O: AngularAcceleration
V is the velocity vector of the "velocity reference point", which is the
origin of the frame in which the coordinates are expressed. W is an
angular velocity vector.

To Be Discussed: the following two objects (TwistTrans and WrenchTrans) are
easily constructed from a HomTrans, and less frequently used in data
exchanges. So, they could be removed from the standard.

TwistTrans:
  Rxx:  float
  Rxy:  float
  Rxz:  float
  Ryx:  float
  Ryy:  float
  Ryz:  float
  Rzx:  float
  Rzx:  float
  Rzz:  float
  RPxx: float
  RPxy: float
  RPxz: float
  RPyx: float
  RPyy: float
  RPyz: float
  RPzx: float
  RPzy: float
  RPzz: float
18 floats, representing the 6 x 6 matrix of floats that transforms a Twist
from one frame to another frame. It is constructed with minimal operations
from the HomTrans (R,p) between both frames:
               | R  R p^ |
  TwistTrans = |         |
               | 0   R   |
with
       |  0  -pz   py |
  p^ = |  pz   0  -px |
       | -py  px   0  |

WrenchTrans: similar to TwistTrans, but now the 6 x 6 matrix of floats that
transforms a Wrench from one frame to another frame. It is constructed with
minimal operations from the HomTrans between both frames.
                |  R   0 |
  WrenchTrans = |        |
                | R p^ R |

To Be Discussed:
The following paragraphs just list a set of objects to be standardized,
together with a list of commonly used representations. We should discuss
what alternative representations to standardize, what names are given to
the objects, and, possibly, whether separate names should be given to the
same objects with different representations.
My suggestion is to use different names, because this is the only way to
avoid on-line interpretation of the data.

Line:
- (Point, Direction)
- (Point, Point)
- (Plane, Plane) (intersection)
- (Screw) (ordered couple of free vector and line vector, with two
     constraints between both)
Suggestion: LinePD, LinePoPo, LinePlPl, LineS.

LineSegment:
- (Point, Direction, Length)
- (Point, Point)
Suggestion: LineSegmentPDL, LineSegmentPoPo

Orientation:
- RotAxis(line,angle): rotation around the (directed!) "line" through the
   origin of the current frame, over a given "angle"
- RotMatrix
- set of the 24 Euler angle sets
- Quaternion
Suggestion: OrientationA, OrientationM, OrientationE, OrientationQ.

Frame: 
- HomTrans
- (Point, Orientation)
- (Point, RotMatrix)
- (Point, Quaternion)
- (Point, one of the 24 Euler angle sets)
Suggestion: FrameT, FramePO, FramePM, FramePQ, FramePE.

Pose, Displacement, Offset: synonyms for Frame, so with same represenation
and similar naming.