@foxglove/schemas 1.6.2 → 1.6.3

package/schemas/flatbuffer/CylinderPrimitive.fbs

@@ -9,19 +9,19 @@ namespace foxglove;
 /// A primitive representing a cylinder, elliptic cylinder, or truncated cone
 table CylinderPrimitive {
   /// Position of the center of the cylinder and orientation of the cylinder. The flat face(s) are perpendicular to the z-axis.
-  pose:foxglove.Pose;
+  pose:foxglove.Pose (id: 0);
 
   /// Size of the cylinder's bounding box
-  size:foxglove.Vector3;
+  size:foxglove.Vector3 (id: 1);
 
   /// 0-1, ratio of the diameter of the cylinder's bottom face (min z) to the bottom of the bounding box
-  bottom_scale:double;
+  bottom_scale:double (id: 2);
 
   /// 0-1, ratio of the diameter of the cylinder's top face (max z) to the top of the bounding box
-  top_scale:double;
+  top_scale:double (id: 3);
 
   /// Color of the cylinder
-  color:foxglove.Color;
+  color:foxglove.Color (id: 4);
 }
 
 root_type CylinderPrimitive;

package/schemas/flatbuffer/Duration.fbs

@@ -4,7 +4,7 @@ namespace foxglove;
 struct Duration {
   /// Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive.
   sec:int32;
-  /// if sec === 0 : -999,999,999 <= nsec <= +999,999,999 
+  /// if sec === 0 : -999,999,999 <= nsec <= +999,999,999
   /// otherwise sign of sec must match sign of nsec or be 0 and abs(nsec) <= 999,999,999
   nsec:int32;
 }

package/schemas/flatbuffer/FrameTransform.fbs

@@ -9,19 +9,19 @@ namespace foxglove;
 /// A transform between two reference frames in 3D space
 table FrameTransform {
   /// Timestamp of transform
-  timestamp:Time;
+  timestamp:Time (id: 0);
 
   /// Name of the parent frame
-  parent_frame_id:string;
+  parent_frame_id:string (id: 1);
 
   /// Name of the child frame
-  child_frame_id:string;
+  child_frame_id:string (id: 2);
 
   /// Translation component of the transform
-  translation:foxglove.Vector3;
+  translation:foxglove.Vector3 (id: 3);
 
   /// Rotation component of the transform
-  rotation:foxglove.Quaternion;
+  rotation:foxglove.Quaternion (id: 4);
 }
 
 root_type FrameTransform;

package/schemas/flatbuffer/FrameTransforms.fbs

@@ -7,7 +7,7 @@ namespace foxglove;
 /// An array of FrameTransform messages
 table FrameTransforms {
   /// Array of transforms
-  transforms:[foxglove.FrameTransform];
+  transforms:[foxglove.FrameTransform] (id: 0);
 }
 
 root_type FrameTransforms;

package/schemas/flatbuffer/GeoJSON.fbs

@@ -5,7 +5,7 @@ namespace foxglove;
 /// GeoJSON data for annotating maps
 table GeoJSON {
   /// GeoJSON data encoded as a UTF-8 string
-  geojson:string;
+  geojson:string (id: 0);
 }
 
 root_type GeoJSON;

package/schemas/flatbuffer/Grid.fbs

@@ -10,31 +10,31 @@ namespace foxglove;
 /// A 2D grid of data
 table Grid {
   /// Timestamp of grid
-  timestamp:Time;
+  timestamp:Time (id: 0);
 
   /// Frame of reference
-  frame_id:string;
+  frame_id:string (id: 1);
 
   /// Origin of grid's corner relative to frame of reference; grid is positioned in the x-y plane relative to this origin
-  pose:foxglove.Pose;
+  pose:foxglove.Pose (id: 2);
 
   /// Number of grid columns
-  column_count:uint32;
+  column_count:uint32 (id: 3);
 
   /// Size of single grid cell along x and y axes, relative to `pose`
-  cell_size:foxglove.Vector2;
+  cell_size:foxglove.Vector2 (id: 4);
 
   /// Number of bytes between rows in `data`
-  row_stride:uint32;
+  row_stride:uint32 (id: 5);
 
   /// Number of bytes between cells within a row in `data`
-  cell_stride:uint32;
+  cell_stride:uint32 (id: 6);
 
   /// Fields in `data`. `red`, `green`, `blue`, and `alpha` are optional for customizing the grid's color.
-  fields:[foxglove.PackedElementField];
+  fields:[foxglove.PackedElementField] (id: 7);
 
   /// Grid cell data, interpreted using `fields`, in row-major (y-major) order
-  data:[uint8];
+  data:[uint8] (id: 8);
 }
 
 root_type Grid;

package/schemas/flatbuffer/ImageAnnotations.fbs

@@ -9,13 +9,13 @@ namespace foxglove;
 /// Array of annotations for a 2D image
 table ImageAnnotations {
   /// Circle annotations
-  circles:[foxglove.CircleAnnotation];
+  circles:[foxglove.CircleAnnotation] (id: 0);
 
   /// Points annotations
-  points:[foxglove.PointsAnnotation];
+  points:[foxglove.PointsAnnotation] (id: 1);
 
   /// Text annotations
-  texts:[foxglove.TextAnnotation];
+  texts:[foxglove.TextAnnotation] (id: 2);
 }
 
 root_type ImageAnnotations;

package/schemas/flatbuffer/KeyValuePair.fbs

@@ -5,10 +5,10 @@ namespace foxglove;
 /// A key with its associated value
 table KeyValuePair {
   /// Key
-  key:string;
+  key:string (id: 0);
 
   /// Value
-  value:string;
+  value:string (id: 1);
 }
 
 root_type KeyValuePair;

package/schemas/flatbuffer/LaserScan.fbs

@@ -8,25 +8,25 @@ namespace foxglove;
 /// A single scan from a planar laser range-finder
 table LaserScan {
   /// Timestamp of scan
-  timestamp:Time;
+  timestamp:Time (id: 0);
 
   /// Frame of reference
-  frame_id:string;
+  frame_id:string (id: 1);
 
   /// Origin of scan relative to frame of reference; points are positioned in the x-y plane relative to this origin; angles are interpreted as counterclockwise rotations around the z axis with 0 rad being in the +x direction
-  pose:foxglove.Pose;
+  pose:foxglove.Pose (id: 2);
 
   /// Bearing of first point, in radians
-  start_angle:double;
+  start_angle:double (id: 3);
 
   /// Bearing of last point, in radians
-  end_angle:double;
+  end_angle:double (id: 4);
 
   /// Distance of detections from origin; assumed to be at equally-spaced angles between `start_angle` and `end_angle`
-  ranges:[double];
+  ranges:[double] (id: 5);
 
   /// Intensity of detections
-  intensities:[double];
+  intensities:[double] (id: 6);
 }
 
 root_type LaserScan;

package/schemas/flatbuffer/LinePrimitive.fbs

@@ -20,30 +20,30 @@ enum LineType : ubyte {
 /// A primitive representing a series of points connected by lines
 table LinePrimitive {
   /// Drawing primitive to use for lines
-  type:LineType;
+  type:LineType (id: 0);
 
   /// Origin of lines relative to reference frame
-  pose:foxglove.Pose;
+  pose:foxglove.Pose (id: 1);
 
   /// Line thickness
-  thickness:double;
+  thickness:double (id: 2);
 
   /// Indicates whether `thickness` is a fixed size in screen pixels (true), or specified in world coordinates and scales with distance from the camera (false)
-  scale_invariant:bool;
+  scale_invariant:bool (id: 3);
 
   /// Points along the line
-  points:[foxglove.Point3];
+  points:[foxglove.Point3] (id: 4);
 
   /// Solid color to use for the whole line. One of `color` or `colors` must be provided.
-  color:foxglove.Color;
+  color:foxglove.Color (id: 5);
 
   /// Per-point colors (if specified, must have the same length as `points`). One of `color` or `colors` must be provided.
-  colors:[foxglove.Color];
+  colors:[foxglove.Color] (id: 6);
 
   /// Indices into the `points` and `colors` attribute arrays, which can be used to avoid duplicating attribute data.
   /// 
   /// If omitted or empty, indexing will not be used. This default behavior is equivalent to specifying [0, 1, ..., N-1] for the indices (where N is the number of `points` provided).
-  indices:[uint32];
+  indices:[uint32] (id: 7);
 }
 
 root_type LinePrimitive;

package/schemas/flatbuffer/LocationFix.fbs

@@ -17,26 +17,26 @@ enum PositionCovarianceType : ubyte {
 /// A navigation satellite fix for any Global Navigation Satellite System
 table LocationFix {
   /// Timestamp of the message
-  timestamp:Time;
+  timestamp:Time (id: 0);
 
   /// Frame for the sensor. Latitude and longitude readings are at the origin of the frame.
-  frame_id:string;
+  frame_id:string (id: 1);
 
   /// Latitude in degrees
-  latitude:double;
+  latitude:double (id: 2);
 
   /// Longitude in degrees
-  longitude:double;
+  longitude:double (id: 3);
 
   /// Altitude in meters
-  altitude:double;
+  altitude:double (id: 4);
 
   /// Position covariance (m^2) defined relative to a tangential plane through the reported position. The components are East, North, and Up (ENU), in row-major order.
   /// length 9
-  position_covariance:[double];
+  position_covariance:[double] (id: 5);
 
   /// If `position_covariance` is available, `position_covariance_type` must be set to indicate the type of covariance.
-  position_covariance_type:PositionCovarianceType;
+  position_covariance_type:PositionCovarianceType (id: 6);
 }
 
 root_type LocationFix;

package/schemas/flatbuffer/Log.fbs

@@ -21,22 +21,22 @@ enum LogLevel : ubyte {
 /// A log message
 table Log {
   /// Timestamp of log message
-  timestamp:Time;
+  timestamp:Time (id: 0);
 
   /// Log level
-  level:LogLevel;
+  level:LogLevel (id: 1);
 
   /// Log message
-  message:string;
+  message:string (id: 2);
 
   /// Process or node name
-  name:string;
+  name:string (id: 3);
 
   /// Filename
-  file:string;
+  file:string (id: 4);
 
   /// Line number in the file
-  line:uint32;
+  line:uint32 (id: 5);
 }
 
 root_type Log;

package/schemas/flatbuffer/ModelPrimitive.fbs

@@ -9,25 +9,25 @@ namespace foxglove;
 /// A primitive representing a 3D model file loaded from an external URL or embedded data
 table ModelPrimitive {
   /// Origin of model relative to reference frame
-  pose:foxglove.Pose;
+  pose:foxglove.Pose (id: 0);
 
   /// Scale factor to apply to the model along each axis
-  scale:foxglove.Vector3;
+  scale:foxglove.Vector3 (id: 1);
 
   /// Solid color to use for the whole model if `override_color` is true.
-  color:foxglove.Color;
+  color:foxglove.Color (id: 2);
 
   /// Whether to use the color specified in `color` instead of any materials embedded in the original model.
-  override_color:bool;
+  override_color:bool (id: 3);
 
   /// URL pointing to model file. One of `url` or `data` should be provided.
-  url:string;
+  url:string (id: 4);
 
   /// [Media type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types) of embedded model (e.g. `model/gltf-binary`). Required if `data` is provided instead of `url`. Overrides the inferred media type if `url` is provided.
-  media_type:string;
+  media_type:string (id: 5);
 
   /// Embedded model. One of `url` or `data` should be provided. If `data` is provided, `media_type` must be set to indicate the type of the data.
-  data:[uint8];
+  data:[uint8] (id: 6);
 }
 
 root_type ModelPrimitive;

package/schemas/flatbuffer/PackedElementField.fbs

@@ -25,13 +25,13 @@ enum NumericType : ubyte {
 /// A field present within each element in a byte array of packed elements.
 table PackedElementField {
   /// Name of the field
-  name:string;
+  name:string (id: 0);
 
   /// Byte offset from start of data buffer
-  offset:uint32;
+  offset:uint32 (id: 1);
 
   /// Type of data in the field. Integers are stored using little-endian byte order.
-  type:NumericType;
+  type:NumericType (id: 2);
 }
 
 root_type PackedElementField;

package/schemas/flatbuffer/Point2.fbs

@@ -5,10 +5,10 @@ namespace foxglove;
 /// A point representing a position in 2D space
 table Point2 {
   /// x coordinate position
-  x:double;
+  x:double (id: 0);
 
   /// y coordinate position
-  y:double;
+  y:double (id: 1);
 }
 
 root_type Point2;

package/schemas/flatbuffer/Point3.fbs

@@ -5,13 +5,13 @@ namespace foxglove;
 /// A point representing a position in 3D space
 table Point3 {
   /// x coordinate position
-  x:double;
+  x:double (id: 0);
 
   /// y coordinate position
-  y:double;
+  y:double (id: 1);
 
   /// z coordinate position
-  z:double;
+  z:double (id: 2);
 }
 
 root_type Point3;

package/schemas/flatbuffer/PointCloud.fbs

@@ -9,22 +9,22 @@ namespace foxglove;
 /// A collection of N-dimensional points, which may contain additional fields with information like normals, intensity, etc.
 table PointCloud {
   /// Timestamp of point cloud
-  timestamp:Time;
+  timestamp:Time (id: 0);
 
   /// Frame of reference
-  frame_id:string;
+  frame_id:string (id: 1);
 
   /// The origin of the point cloud relative to the frame of reference
-  pose:foxglove.Pose;
+  pose:foxglove.Pose (id: 2);
 
   /// Number of bytes between points in the `data`
-  point_stride:uint32;
+  point_stride:uint32 (id: 3);
 
   /// Fields in `data`. At least 2 coordinate fields from `x`, `y`, and `z` are required for each point's position; `red`, `green`, `blue`, and `alpha` are optional for customizing each point's color.
-  fields:[foxglove.PackedElementField];
+  fields:[foxglove.PackedElementField] (id: 4);
 
   /// Point data, interpreted using `fields`
-  data:[uint8];
+  data:[uint8] (id: 5);
 }
 
 root_type PointCloud;

package/schemas/flatbuffer/PointsAnnotation.fbs

@@ -25,25 +25,26 @@ enum PointsAnnotationType : ubyte {
 /// An array of points on a 2D image
 table PointsAnnotation {
   /// Timestamp of annotation
-  timestamp:Time;
+  timestamp:Time (id: 0);
 
   /// Type of points annotation to draw
-  type:PointsAnnotationType;
+  type:PointsAnnotationType (id: 1);
 
-  /// Points in 2D image coordinates (pixels)
-  points:[foxglove.Point2];
+  /// Points in 2D image coordinates (pixels).
+  /// These coordinates use the top-left corner of the top-left pixel of the image as the origin.
+  points:[foxglove.Point2] (id: 2);
 
   /// Outline color
-  outline_color:foxglove.Color;
+  outline_color:foxglove.Color (id: 3);
 
   /// Per-point colors, if `type` is `POINTS`, or per-segment stroke colors, if `type` is `LINE_LIST`, `LINE_STRIP` or `LINE_LOOP`.
-  outline_colors:[foxglove.Color];
+  outline_colors:[foxglove.Color] (id: 4);
 
   /// Fill color
-  fill_color:foxglove.Color;
+  fill_color:foxglove.Color (id: 5);
 
   /// Stroke thickness in pixels
-  thickness:double;
+  thickness:double (id: 6);
 }
 
 root_type PointsAnnotation;

package/schemas/flatbuffer/Pose.fbs

@@ -8,10 +8,10 @@ namespace foxglove;
 /// A position and orientation for an object or reference frame in 3D space
 table Pose {
   /// Point denoting position in 3D space
-  position:foxglove.Vector3;
+  position:foxglove.Vector3 (id: 0);
 
   /// Quaternion denoting orientation in 3D space
-  orientation:foxglove.Quaternion;
+  orientation:foxglove.Quaternion (id: 1);
 }
 
 root_type Pose;

package/schemas/flatbuffer/PoseInFrame.fbs

@@ -8,13 +8,13 @@ namespace foxglove;
 /// A timestamped pose for an object or reference frame in 3D space
 table PoseInFrame {
   /// Timestamp of pose
-  timestamp:Time;
+  timestamp:Time (id: 0);
 
   /// Frame of reference for pose position and orientation
-  frame_id:string;
+  frame_id:string (id: 1);
 
   /// Pose in 3D space
-  pose:foxglove.Pose;
+  pose:foxglove.Pose (id: 2);
 }
 
 root_type PoseInFrame;

package/schemas/flatbuffer/PosesInFrame.fbs

@@ -8,13 +8,13 @@ namespace foxglove;
 /// An array of timestamped poses for an object or reference frame in 3D space
 table PosesInFrame {
   /// Timestamp of pose
-  timestamp:Time;
+  timestamp:Time (id: 0);
 
   /// Frame of reference for pose position and orientation
-  frame_id:string;
+  frame_id:string (id: 1);
 
   /// Poses in 3D space
-  poses:[foxglove.Pose];
+  poses:[foxglove.Pose] (id: 2);
 }
 
 root_type PosesInFrame;

package/schemas/flatbuffer/Quaternion.fbs

@@ -5,16 +5,16 @@ namespace foxglove;
 /// A [quaternion](https://eater.net/quaternions) representing a rotation in 3D space
 table Quaternion {
   /// x value
-  x:double;
+  x:double (id: 0);
 
   /// y value
-  y:double;
+  y:double (id: 1);
 
   /// z value
-  z:double;
+  z:double (id: 2);
 
   /// w value
-  w:double = 1.0;
+  w:double = 1.0 (id: 3);
 }
 
 root_type Quaternion;

package/schemas/flatbuffer/RawImage.fbs

@@ -7,27 +7,27 @@ namespace foxglove;
 /// A raw image
 table RawImage {
   /// Timestamp of image
-  timestamp:Time;
+  timestamp:Time (id: 0);
 
   /// Frame of reference for the image. The origin of the frame is the optical center of the camera. +x points to the right in the image, +y points down, and +z points into the plane of the image.
-  frame_id:string;
+  frame_id:string (id: 1);
 
   /// Image width
-  width:uint32;
+  width:uint32 (id: 2);
 
   /// Image height
-  height:uint32;
+  height:uint32 (id: 3);
 
   /// Encoding of the raw image data
   /// 
   /// Supported values: `8UC1`, `8UC3`, `16UC1`, `32FC1`, `bayer_bggr8`, `bayer_gbrg8`, `bayer_grbg8`, `bayer_rggb8`, `bgr8`, `bgra8`, `mono8`, `mono16`, `rgb8`, `rgba8`, `uyvy` or `yuv422`, `yuyv` or `yuv422_yuy2`
-  encoding:string;
+  encoding:string (id: 4);
 
   /// Byte length of a single row
-  step:uint32;
+  step:uint32 (id: 5);
 
   /// Raw image data
-  data:[uint8];
+  data:[uint8] (id: 6);
 }
 
 root_type RawImage;

package/schemas/flatbuffer/SceneEntity.fbs

@@ -17,46 +17,46 @@ namespace foxglove;
 /// A visual element in a 3D scene. An entity may be composed of multiple primitives which all share the same frame of reference.
 table SceneEntity {
   /// Timestamp of the entity
-  timestamp:Time;
+  timestamp:Time (id: 0);
 
   /// Frame of reference
-  frame_id:string;
+  frame_id:string (id: 1);
 
   /// Identifier for the entity. A entity will replace any prior entity on the same topic with the same `id`.
-  id:string;
+  id:string (id: 2);
 
   /// Length of time (relative to `timestamp`) after which the entity should be automatically removed. Zero value indicates the entity should remain visible until it is replaced or deleted.
-  lifetime:Duration;
+  lifetime:Duration (id: 3);
 
   /// Whether the entity should keep its location in the fixed frame (false) or follow the frame specified in `frame_id` as it moves relative to the fixed frame (true)
-  frame_locked:bool;
+  frame_locked:bool (id: 4);
 
   /// Additional user-provided metadata associated with the entity. Keys must be unique.
-  metadata:[foxglove.KeyValuePair];
+  metadata:[foxglove.KeyValuePair] (id: 5);
 
   /// Arrow primitives
-  arrows:[foxglove.ArrowPrimitive];
+  arrows:[foxglove.ArrowPrimitive] (id: 6);
 
   /// Cube primitives
-  cubes:[foxglove.CubePrimitive];
+  cubes:[foxglove.CubePrimitive] (id: 7);
 
   /// Sphere primitives
-  spheres:[foxglove.SpherePrimitive];
+  spheres:[foxglove.SpherePrimitive] (id: 8);
 
   /// Cylinder primitives
-  cylinders:[foxglove.CylinderPrimitive];
+  cylinders:[foxglove.CylinderPrimitive] (id: 9);
 
   /// Line primitives
-  lines:[foxglove.LinePrimitive];
+  lines:[foxglove.LinePrimitive] (id: 10);
 
   /// Triangle list primitives
-  triangles:[foxglove.TriangleListPrimitive];
+  triangles:[foxglove.TriangleListPrimitive] (id: 11);
 
   /// Text primitives
-  texts:[foxglove.TextPrimitive];
+  texts:[foxglove.TextPrimitive] (id: 12);
 
   /// Model primitives
-  models:[foxglove.ModelPrimitive];
+  models:[foxglove.ModelPrimitive] (id: 13);
 }
 
 root_type SceneEntity;

package/schemas/flatbuffer/SceneEntityDeletion.fbs

@@ -15,13 +15,13 @@ enum SceneEntityDeletionType : ubyte {
 /// Command to remove previously published entities
 table SceneEntityDeletion {
   /// Timestamp of the deletion. Only matching entities earlier than this timestamp will be deleted.
-  timestamp:Time;
+  timestamp:Time (id: 0);
 
   /// Type of deletion action to perform
-  type:SceneEntityDeletionType;
+  type:SceneEntityDeletionType (id: 1);
 
   /// Identifier which must match if `type` is `MATCHING_ID`.
-  id:string;
+  id:string (id: 2);
 }
 
 root_type SceneEntityDeletion;

package/schemas/flatbuffer/SceneUpdate.fbs

@@ -8,10 +8,10 @@ namespace foxglove;
 /// An update to the entities displayed in a 3D scene
 table SceneUpdate {
   /// Scene entities to delete
-  deletions:[foxglove.SceneEntityDeletion];
+  deletions:[foxglove.SceneEntityDeletion] (id: 0);
 
   /// Scene entities to add or replace
-  entities:[foxglove.SceneEntity];
+  entities:[foxglove.SceneEntity] (id: 1);
 }
 
 root_type SceneUpdate;

package/schemas/flatbuffer/SpherePrimitive.fbs

@@ -9,13 +9,13 @@ namespace foxglove;
 /// A primitive representing a sphere or ellipsoid
 table SpherePrimitive {
   /// Position of the center of the sphere and orientation of the sphere
-  pose:foxglove.Pose;
+  pose:foxglove.Pose (id: 0);
 
   /// Size (diameter) of the sphere along each axis
-  size:foxglove.Vector3;
+  size:foxglove.Vector3 (id: 1);
 
   /// Color of the sphere
-  color:foxglove.Color;
+  color:foxglove.Color (id: 2);
 }
 
 root_type SpherePrimitive;