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;
  };
 
  #pragma keylist TimedRGBColour
  #pragma keylist TimedPoint2D
  #pragma keylist TimedVector2D
  #pragma keylist TimedPose2D
  #pragma keylist TimedVelocity2D
  #pragma keylist TimedAcceleration2D
  #pragma keylist TimedPoseVel2D
  #pragma keylist TimedSize2D
  #pragma keylist TimedGeometry2D
  #pragma keylist TimedCovariance2D
  #pragma keylist TimedPointCovariance2D
  #pragma keylist TimedCarlike
  #pragma keylist TimedSpeedHeading2D
  #pragma keylist TimedPoint3D
  #pragma keylist TimedVector3D
  #pragma keylist TimedOrientation3D
  #pragma keylist TimedPose3D
  #pragma keylist TimedVelocity3D
  #pragma keylist TimedAngularVelocity3D
  #pragma keylist TimedAcceleration3D
  #pragma keylist TimedAngularAcceleration3D
  #pragma keylist TimedPoseVel3D
  #pragma keylist TimedSize3D
  #pragma keylist TimedGeometry3D
  #pragma keylist TimedCovariance3D
  #pragma keylist TimedSpeedHeading3D
  #pragma keylist TimedOAP
};
 
#endif // ExtendedDataTypes_idl