ExtendedDataTypes.idl

Go to the documentation of this file.

// -*- IDL -*-
#ifndef ExtendedDataTypes_idl
#define ExtendedDataTypes_idl

#include "BasicDataType.idl"

module RTC {
    struct RGBColour
    {
        double r;
        double g;
        double b;
    };

    //------------------------------------------------------------
    // 2D data types
    //------------------------------------------------------------

    struct Point2D
    {
        double x;
        double y;
    };

    struct Vector2D
    {
        double x;
        double y;
    };

    struct Pose2D
    {
        Point2D position;
        double heading;
    };

    struct Velocity2D
    {
        double vx;
        double vy;
        double va;
    };

    struct Acceleration2D
    {
        double ax;
        double ay;
    };

    struct PoseVel2D
    {
        Pose2D pose;
        Velocity2D velocities;
    };

    struct Size2D
    {
        double l;
        double w;
    };

    struct Geometry2D
    {
        Pose2D pose;
        Size2D size;
    };

    struct Covariance2D
    {
        double xx;
        double xy;
        double xt;
        double yy;
        double yt;
        double tt;
    };

    struct PointCovariance2D
    {
        double xx;
        double xy;
        double yy;
    };

    struct Carlike
    {
        double speed;
        double steeringAngle;
    };

    struct SpeedHeading2D
    {
        double speed;
        double heading;
    };

    //------------------------------------------------------------
    // 3D data types
    //------------------------------------------------------------

    struct Point3D
    {
        double x;
        double y;
        double z;
    };

    struct Vector3D
    {
        double x;
        double y;
        double z;
    };

    struct Orientation3D
    {
        double r;
        double p;
        double y;
    };

    struct Pose3D
    {
        Point3D position;
        Orientation3D orientation;
    };

    struct Velocity3D
    {
        double vx;
        double vy;
        double vz;
        double vr;
        double vp;
        double va;
    };

    struct AngularVelocity3D
    {
        double avx;
        double avy;
        double avz;
    };

    struct Acceleration3D
    {
        double ax;
        double ay;
        double az;
    };

    struct AngularAcceleration3D
    {
        double aax;
        double aay;
        double aaz;
    };

    struct PoseVel3D
    {
        Pose3D pose;
        Velocity3D velocities;
    };

    struct Size3D
    {
        double l;
        double w;
        double h;
    };

    struct Geometry3D
    {
        Pose3D pose;
        Size3D size;
    };

    struct Covariance3D
    {
        double xx;
        double xy;
        double xz;
        double xr;
        double xp;
        double xa;
        double yy;
        double yz;
        double yr;
        double yp;
        double ya;
        double zz;
        double zr;
        double zp;
        double za;
        double rr;
        double rp;
        double ra;
        double pp;
        double pa;
        double aa;
    };

    struct SpeedHeading3D
    {
        double speed;
        Orientation3D direction;
    };

    struct OAP
    {
        Vector3D orientation;
        Vector3D approach;
        Vector3D position;
    };

    //------------------------------------------------------------
    // Timed data types
    //------------------------------------------------------------

    struct TimedRGBColour
    {
        Time tm;
        RGBColour data;
    };

    struct TimedPoint2D
    {
        Time tm;
        Point2D data;
    };

    struct TimedVector2D
    {
        Time tm;
        Vector2D data;
    };

    struct TimedPose2D
    {
        Time tm;
        Pose2D data;
    };

    struct TimedVelocity2D
    {
        Time tm;
        Velocity2D data;
    };

    struct TimedAcceleration2D
    {
        Time tm;
        Acceleration2D data;
    };

    struct TimedPoseVel2D
    {
        Time tm;
        PoseVel2D data;
    };

    struct TimedSize2D
    {
        Time tm;
        Size2D data;
    };

    struct TimedGeometry2D
    {
        Time tm;
        Geometry2D data;
    };

    struct TimedCovariance2D
    {
        Time tm;
        Covariance2D data;
    };

    struct TimedPointCovariance2D
    {
        Time tm;
        PointCovariance2D data;
    };

    struct TimedCarlike
    {
        Time tm;
        Carlike data;
    };

    struct TimedSpeedHeading2D
    {
        Time tm;
        SpeedHeading2D data;
    };

    struct TimedPoint3D
    {
        Time tm;
        Point3D data;
    };

    struct TimedVector3D
    {
        Time tm;
        Vector3D data;
    };

    struct TimedOrientation3D
    {
        Time tm;
        Orientation3D data;
    };

    struct TimedPose3D
    {
        Time tm;
        Pose3D data;
    };

    struct TimedVelocity3D
    {
        Time tm;
        Velocity3D data;
    };

    struct TimedAngularVelocity3D
    {
        Time tm;
        AngularVelocity3D data;
    };

    struct TimedAcceleration3D
    {
        Time tm;
        Acceleration3D data;
    };

    struct TimedAngularAcceleration3D
    {
        Time tm;
        AngularAcceleration3D data;
    };

    struct TimedPoseVel3D
    {
        Time tm;
        PoseVel3D data;
    };

    struct TimedSize3D
    {
        Time tm;
        Size3D data;
    };

    struct TimedGeometry3D
    {
        Time tm;
        Geometry3D data;
    };

    struct TimedCovariance3D
    {
        Time tm;
        Covariance3D data;
    };

    struct TimedSpeedHeading3D
    {
        Time tm;
        SpeedHeading3D data;
    };

    struct TimedOAP
    {
        Time tm;
        OAP data;
    };

  struct Quaternion
  {
    double x;
    double y;
    double z;
    double w;
  };

  struct TimedQuaternion
  {
    Time tm;
    Quaternion data;
  };
};

#endif // ExtendedDataTypes_idl