@blueyerobotics/protocol-definitions 3.4.0-618bf0b0 → 3.4.0-sonar3d-slam.4e329580
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/message_formats.d.ts +510 -2
- package/dist/message_formats.js +11290 -8463
- package/dist/req_rep.d.ts +120 -1
- package/dist/req_rep.js +791 -1
- package/dist/telemetry.d.ts +78 -1
- package/dist/telemetry.js +419 -1
- package/package.json +1 -1
|
@@ -516,6 +516,12 @@ export declare enum GuestPortDeviceID {
|
|
|
516
516
|
GUEST_PORT_DEVICE_ID_OUTLAND_TECHNOLOGY_MP200 = 51,
|
|
517
517
|
/** GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5 - Reach Robotics Reach Alpha 5 Manipulator. */
|
|
518
518
|
GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5 = 52,
|
|
519
|
+
/** GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3 - Blueye Multibeam Skid Servo V3. */
|
|
520
|
+
GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3 = 53,
|
|
521
|
+
/** GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2 - Detachable Blue Robotics Newton V2. */
|
|
522
|
+
GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2 = 54,
|
|
523
|
+
/** GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2 - Blueye Scaling Laser V2. */
|
|
524
|
+
GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2 = 55,
|
|
519
525
|
UNRECOGNIZED = -1
|
|
520
526
|
}
|
|
521
527
|
export declare function guestPortDeviceIDFromJSON(object: any): GuestPortDeviceID;
|
|
@@ -563,6 +569,10 @@ export declare enum GuestPortCapability {
|
|
|
563
569
|
GUEST_PORT_CAPABILITY_PWM = 6,
|
|
564
570
|
/** GUEST_PORT_CAPABILITY_ETHERNET_1G - Gigabit Ethernet. */
|
|
565
571
|
GUEST_PORT_CAPABILITY_ETHERNET_1G = 7,
|
|
572
|
+
/** GUEST_PORT_CAPABILITY_I2C_IO - TCA9536 I/O expander. */
|
|
573
|
+
GUEST_PORT_CAPABILITY_I2C_IO = 8,
|
|
574
|
+
/** GUEST_PORT_CAPABILITY_I2C_IO_V2 - PCA9554A I/O expander. */
|
|
575
|
+
GUEST_PORT_CAPABILITY_I2C_IO_V2 = 9,
|
|
566
576
|
UNRECOGNIZED = -1
|
|
567
577
|
}
|
|
568
578
|
export declare function guestPortCapabilityFromJSON(object: any): GuestPortCapability;
|
|
@@ -708,6 +718,76 @@ export declare enum AnnotationSource {
|
|
|
708
718
|
}
|
|
709
719
|
export declare function annotationSourceFromJSON(object: any): AnnotationSource;
|
|
710
720
|
export declare function annotationSourceToJSON(object: AnnotationSource): string;
|
|
721
|
+
/** State of the SLAM (simultaneous localization and mapping). */
|
|
722
|
+
export declare enum SlamState {
|
|
723
|
+
/** SLAM_STATE_UNSPECIFIED - Unspecified. */
|
|
724
|
+
SLAM_STATE_UNSPECIFIED = 0,
|
|
725
|
+
/** SLAM_STATE_WAITING - Waiting for the first scan and orientation. */
|
|
726
|
+
SLAM_STATE_WAITING = 1,
|
|
727
|
+
/** SLAM_STATE_TRACKING - The latest scan was matched against the map. */
|
|
728
|
+
SLAM_STATE_TRACKING = 2,
|
|
729
|
+
/** SLAM_STATE_COASTING - The latest scan could not be matched; the pose follows the motion model. */
|
|
730
|
+
SLAM_STATE_COASTING = 3,
|
|
731
|
+
UNRECOGNIZED = -1
|
|
732
|
+
}
|
|
733
|
+
export declare function slamStateFromJSON(object: any): SlamState;
|
|
734
|
+
export declare function slamStateToJSON(object: SlamState): string;
|
|
735
|
+
/** Kind of sensor a SLAM scan comes from. */
|
|
736
|
+
export declare enum SlamSensorType {
|
|
737
|
+
/** SLAM_SENSOR_TYPE_UNSPECIFIED - Unspecified. */
|
|
738
|
+
SLAM_SENSOR_TYPE_UNSPECIFIED = 0,
|
|
739
|
+
/** SLAM_SENSOR_TYPE_SONAR_3D - A 3D imaging sonar, e.g. the Water Linked Sonar 3D-15. */
|
|
740
|
+
SLAM_SENSOR_TYPE_SONAR_3D = 1,
|
|
741
|
+
/** SLAM_SENSOR_TYPE_STEREO_CAMERA - A stereo camera's depth. */
|
|
742
|
+
SLAM_SENSOR_TYPE_STEREO_CAMERA = 2,
|
|
743
|
+
/** SLAM_SENSOR_TYPE_SIMULATED - A simulated sensor. */
|
|
744
|
+
SLAM_SENSOR_TYPE_SIMULATED = 3,
|
|
745
|
+
UNRECOGNIZED = -1
|
|
746
|
+
}
|
|
747
|
+
export declare function slamSensorTypeFromJSON(object: any): SlamSensorType;
|
|
748
|
+
export declare function slamSensorTypeToJSON(object: SlamSensorType): string;
|
|
749
|
+
/** What the SLAM's poses are the poses of: its platform. */
|
|
750
|
+
export declare enum SlamPlatform {
|
|
751
|
+
/** SLAM_PLATFORM_UNSPECIFIED - Not known. */
|
|
752
|
+
SLAM_PLATFORM_UNSPECIFIED = 0,
|
|
753
|
+
/**
|
|
754
|
+
* SLAM_PLATFORM_DRONE - The drone, its body frame x forward, y right, z down from the middle of the hull. Each
|
|
755
|
+
* sensor is on it through its mount (SlamPose mount in the messages that carry one).
|
|
756
|
+
*/
|
|
757
|
+
SLAM_PLATFORM_DRONE = 1,
|
|
758
|
+
/** SLAM_PLATFORM_SENSOR - The sensor itself: the SLAM did not know how the sensor is mounted. */
|
|
759
|
+
SLAM_PLATFORM_SENSOR = 2,
|
|
760
|
+
UNRECOGNIZED = -1
|
|
761
|
+
}
|
|
762
|
+
export declare function slamPlatformFromJSON(object: any): SlamPlatform;
|
|
763
|
+
export declare function slamPlatformToJSON(object: SlamPlatform): string;
|
|
764
|
+
/** Frequency mode of a 3D imaging sonar. */
|
|
765
|
+
export declare enum Sonar3dFrequencyMode {
|
|
766
|
+
/** SONAR_3D_FREQUENCY_MODE_UNSPECIFIED - Unspecified: left as it is. */
|
|
767
|
+
SONAR_3D_FREQUENCY_MODE_UNSPECIFIED = 0,
|
|
768
|
+
/** SONAR_3D_FREQUENCY_MODE_LOW - Wide view, long range (3D-15: 90° x 40°, 15 m, 5 scans/s). */
|
|
769
|
+
SONAR_3D_FREQUENCY_MODE_LOW = 1,
|
|
770
|
+
/** SONAR_3D_FREQUENCY_MODE_HIGH - Narrow view, short range, fine detail (3D-15: 40° x 40°, 4 m, 20 scans/s). */
|
|
771
|
+
SONAR_3D_FREQUENCY_MODE_HIGH = 2,
|
|
772
|
+
UNRECOGNIZED = -1
|
|
773
|
+
}
|
|
774
|
+
export declare function sonar3dFrequencyModeFromJSON(object: any): Sonar3dFrequencyMode;
|
|
775
|
+
export declare function sonar3dFrequencyModeToJSON(object: Sonar3dFrequencyMode): string;
|
|
776
|
+
/** What the x axis of a SLAM map's frame points along. */
|
|
777
|
+
export declare enum SlamHeadingReference {
|
|
778
|
+
/** SLAM_HEADING_REFERENCE_UNSPECIFIED - Not known. */
|
|
779
|
+
SLAM_HEADING_REFERENCE_UNSPECIFIED = 0,
|
|
780
|
+
/**
|
|
781
|
+
* SLAM_HEADING_REFERENCE_FIRST_SCAN - The platform's heading at the map's first scan; without gravity alignment, the
|
|
782
|
+
* platform's frame at the first scan as it is.
|
|
783
|
+
*/
|
|
784
|
+
SLAM_HEADING_REFERENCE_FIRST_SCAN = 1,
|
|
785
|
+
/** SLAM_HEADING_REFERENCE_DRONE_COMPASS - North, as the drone's compass heading (AttitudeTel yaw) gave it at the map's first scan. */
|
|
786
|
+
SLAM_HEADING_REFERENCE_DRONE_COMPASS = 2,
|
|
787
|
+
UNRECOGNIZED = -1
|
|
788
|
+
}
|
|
789
|
+
export declare function slamHeadingReferenceFromJSON(object: any): SlamHeadingReference;
|
|
790
|
+
export declare function slamHeadingReferenceToJSON(object: SlamHeadingReference): string;
|
|
711
791
|
/**
|
|
712
792
|
* Wrapper message for each entry in the drone telemetry logfile.
|
|
713
793
|
*
|
|
@@ -881,6 +961,11 @@ export interface LaserDetection {
|
|
|
881
961
|
correctedPixelDistance: number;
|
|
882
962
|
/** Estimated subject distance (m). */
|
|
883
963
|
estimatedDistance: number;
|
|
964
|
+
/**
|
|
965
|
+
* Id of the camera frame the detection was computed from, 0 if unknown. Matches the frame id
|
|
966
|
+
* embedded in recorded video; ModelDetections describes the format.
|
|
967
|
+
*/
|
|
968
|
+
frameId: number;
|
|
884
969
|
}
|
|
885
970
|
/** Latitude and longitude position in WGS 84 decimal degrees format. */
|
|
886
971
|
export interface LatLongPosition {
|
|
@@ -1091,6 +1176,110 @@ export interface Gripper {
|
|
|
1091
1176
|
/** Named pose the arm is moving towards, if any. */
|
|
1092
1177
|
movingTo: ManipulatorPose;
|
|
1093
1178
|
}
|
|
1179
|
+
/**
|
|
1180
|
+
* Hardware status flags a device of a Reach Robotics gripper raises about itself, named as Reach names them.
|
|
1181
|
+
* A gripper of another make would need flags of its own.
|
|
1182
|
+
*/
|
|
1183
|
+
export interface ReachHardwareStatus {
|
|
1184
|
+
/** Reading the device's flash memory failed. */
|
|
1185
|
+
flashFailedRead: boolean;
|
|
1186
|
+
/** Humidity in the housing is too high: water may have got in. */
|
|
1187
|
+
overHumidity: boolean;
|
|
1188
|
+
/** The housing is too hot. */
|
|
1189
|
+
overTemperature: boolean;
|
|
1190
|
+
/** Error on the serial line. */
|
|
1191
|
+
commsSerialError: boolean;
|
|
1192
|
+
/** A packet failed its checksum. */
|
|
1193
|
+
commsCrcError: boolean;
|
|
1194
|
+
/** The motor driver reports a fault. */
|
|
1195
|
+
motorDriverFault: boolean;
|
|
1196
|
+
/** The position encoder reads an invalid position. */
|
|
1197
|
+
encoderPositionError: boolean;
|
|
1198
|
+
/** The position encoder is not detected. */
|
|
1199
|
+
encoderNotDetected: boolean;
|
|
1200
|
+
/** Another device has the same axis. */
|
|
1201
|
+
deviceAxisConflict: boolean;
|
|
1202
|
+
/** The motor is not connected. */
|
|
1203
|
+
motorNotConnected: boolean;
|
|
1204
|
+
/** The motor draws too much current. */
|
|
1205
|
+
motorOverCurrent: boolean;
|
|
1206
|
+
/** The input encoder reads an invalid position. */
|
|
1207
|
+
inputEncoderPositionError: boolean;
|
|
1208
|
+
/** Another device has the same ID. */
|
|
1209
|
+
deviceIdConflict: boolean;
|
|
1210
|
+
/** Pressure in the housing is too high: the seal may have failed. */
|
|
1211
|
+
overPressure: boolean;
|
|
1212
|
+
/** Over current or under voltage in the motor driver. */
|
|
1213
|
+
motorDriverOverCurrentAndUnderVoltage: boolean;
|
|
1214
|
+
/** The motor driver is too hot. */
|
|
1215
|
+
motorDriverOverTemperature: boolean;
|
|
1216
|
+
/** The device is due for service. */
|
|
1217
|
+
jointServiceDue: boolean;
|
|
1218
|
+
/** The position encoder reports a fault. */
|
|
1219
|
+
encoderFault: boolean;
|
|
1220
|
+
/** The supply voltage is too low. */
|
|
1221
|
+
lowSupplyVoltage: boolean;
|
|
1222
|
+
/** A position report the device waits for has not arrived. */
|
|
1223
|
+
positionReportNotReceived: boolean;
|
|
1224
|
+
}
|
|
1225
|
+
/**
|
|
1226
|
+
* Health of one device of a gripper: a joint, or a device of its own.
|
|
1227
|
+
*
|
|
1228
|
+
* A value the device did not report is 0, with its is_*_valid false.
|
|
1229
|
+
*/
|
|
1230
|
+
export interface GripperDeviceDiagnostics {
|
|
1231
|
+
/** Address of the device on the gripper's bus. On a Reach Robotics arm, 1 is the jaws. */
|
|
1232
|
+
address: number;
|
|
1233
|
+
/** Supply voltage (V). */
|
|
1234
|
+
supplyVoltage: number;
|
|
1235
|
+
/** True when the device reported its supply voltage. */
|
|
1236
|
+
isSupplyVoltageValid: boolean;
|
|
1237
|
+
/** Temperature in the housing (°C). */
|
|
1238
|
+
temperature: number;
|
|
1239
|
+
/** True when the device reported the temperature in its housing. */
|
|
1240
|
+
isTemperatureValid: boolean;
|
|
1241
|
+
/** Relative humidity in the housing (%). */
|
|
1242
|
+
humidity: number;
|
|
1243
|
+
/** True when the device reported the humidity in its housing. */
|
|
1244
|
+
isHumidityValid: boolean;
|
|
1245
|
+
/** Absolute pressure in the housing (bar), a partial vacuum: a rise can mean a leak. */
|
|
1246
|
+
internalPressure: number;
|
|
1247
|
+
/** True when the device reported the pressure in its housing. */
|
|
1248
|
+
isInternalPressureValid: boolean;
|
|
1249
|
+
/** Motor current (A). */
|
|
1250
|
+
current: number;
|
|
1251
|
+
/** True when the device reported its motor current. */
|
|
1252
|
+
isCurrentValid: boolean;
|
|
1253
|
+
/**
|
|
1254
|
+
* Flags the device reported, and those it raised since the last report.
|
|
1255
|
+
* Not set if the device sent no hardware status.
|
|
1256
|
+
*/
|
|
1257
|
+
hardwareStatus: ReachHardwareStatus | undefined;
|
|
1258
|
+
}
|
|
1259
|
+
/**
|
|
1260
|
+
* Identity of a gripper: what it is, and what it reports of itself.
|
|
1261
|
+
*
|
|
1262
|
+
* A value the gripper does not report is empty.
|
|
1263
|
+
*/
|
|
1264
|
+
export interface GripperInfo {
|
|
1265
|
+
/** Guest port the gripper is on. */
|
|
1266
|
+
guestPortNumber: GuestPortNumber;
|
|
1267
|
+
/** What the gripper is, as its guest-port connector names it. */
|
|
1268
|
+
deviceId: GuestPortDeviceID;
|
|
1269
|
+
/** Serial number of the gripper, such as 5854. */
|
|
1270
|
+
serialNumber: string;
|
|
1271
|
+
/** Model number of the gripper, such as 5001 for a Reach Alpha 5 or 2130 for a Reach Alpha 2. */
|
|
1272
|
+
modelNumber: string;
|
|
1273
|
+
/** Firmware version of the gripper, such as 5.2.0. */
|
|
1274
|
+
firmwareVersion: string;
|
|
1275
|
+
}
|
|
1276
|
+
/** Health of a gripper and its devices, for diagnostics. */
|
|
1277
|
+
export interface GripperDiagnostics {
|
|
1278
|
+
/** One for each device of the gripper that answered. */
|
|
1279
|
+
devices: GripperDeviceDiagnostics[];
|
|
1280
|
+
/** Guest port the gripper is on. */
|
|
1281
|
+
guestPortNumber: GuestPortNumber;
|
|
1282
|
+
}
|
|
1094
1283
|
/** Information about a remote client. */
|
|
1095
1284
|
export interface ClientInfo {
|
|
1096
1285
|
/** The type of client (such as Blueye App, Observer App, SDK, etc). */
|
|
@@ -1547,7 +1736,7 @@ export interface DvlVelocity {
|
|
|
1547
1736
|
deltaTime: number;
|
|
1548
1737
|
/** Figure of merit, a measure of the accuracy of the velocities (m/s). */
|
|
1549
1738
|
fom: number;
|
|
1550
|
-
/** Velocity, x forward, y
|
|
1739
|
+
/** Velocity, x forward, y right, z down (m/s). */
|
|
1551
1740
|
velocity: Vector3 | undefined;
|
|
1552
1741
|
/** Water tracking status. */
|
|
1553
1742
|
isWaterTracking: boolean;
|
|
@@ -1877,6 +2066,13 @@ export interface DroneInfo {
|
|
|
1877
2066
|
powerSource: PowerSource;
|
|
1878
2067
|
/** Intrinsic calibration of the main camera. Unset when unknown. */
|
|
1879
2068
|
mainCameraCalibration: CameraCalibration | undefined;
|
|
2069
|
+
/** Dive number, the counter at the end of the logfile name. 0 when unknown. */
|
|
2070
|
+
diveNumber: number;
|
|
2071
|
+
/**
|
|
2072
|
+
* Name of the dive logfile without extension (e.g. BYEDP070012_ea9ac92e040aa9d4_00231).
|
|
2073
|
+
* Unlike dive_number it stays unique when the counter restarts, e.g. after the storage is replaced.
|
|
2074
|
+
*/
|
|
2075
|
+
logName: string;
|
|
1880
2076
|
}
|
|
1881
2077
|
/** Known error states for the drone. */
|
|
1882
2078
|
export interface ErrorFlags {
|
|
@@ -2913,7 +3109,26 @@ export interface ObjectDetection {
|
|
|
2913
3109
|
/** Instance segmentation mask (absent if model has no segmentation). */
|
|
2914
3110
|
mask: SegmentationMask | undefined;
|
|
2915
3111
|
}
|
|
2916
|
-
/**
|
|
3112
|
+
/**
|
|
3113
|
+
* A list of object detections from a single model for a single video frame.
|
|
3114
|
+
*
|
|
3115
|
+
* frame_id matches detections to the exact frame of a recording. The video pipeline on the X3 Ultra
|
|
3116
|
+
* assigns an id to each camera frame once, passes it to the computer vision models and the recorder,
|
|
3117
|
+
* and writes it into the recorded video. An id is never reused within one boot of the drone, and stays
|
|
3118
|
+
* below 2^53, so it is exact as a JavaScript number. The models do not process every frame, so the ids
|
|
3119
|
+
* of successive results can skip.
|
|
3120
|
+
*
|
|
3121
|
+
* Recorded video carries the id in a user_data_unregistered SEI message (payload type 5), one per access
|
|
3122
|
+
* unit, placed before the first slice: NAL unit type 6 in H.264 and PREFIX_SEI_NUT (type 39) in H.265.
|
|
3123
|
+
* The payload is 32 bytes, counted after the emulation prevention bytes are removed:
|
|
3124
|
+
*
|
|
3125
|
+
* - Bytes 0-15: UUID 6b1e2f0c-935d-4a8e-b17a-52d40e3c91f6, in the byte order written.
|
|
3126
|
+
* - Bytes 16-23: frame_id, uint64 big-endian.
|
|
3127
|
+
* - Bytes 24-31: capture time of the frame in CLOCK_MONOTONIC on the drone (ns), uint64 big-endian, 0 if unknown.
|
|
3128
|
+
*
|
|
3129
|
+
* A frame that the recorder repeats to keep the frame rate carries the id of the frame it repeats.
|
|
3130
|
+
* Re-encoding the video drops the SEI, so only the original recording carries the ids.
|
|
3131
|
+
*/
|
|
2917
3132
|
export interface ModelDetections {
|
|
2918
3133
|
/** List of detections in the frame. */
|
|
2919
3134
|
detections: ObjectDetection[];
|
|
@@ -2925,6 +3140,11 @@ export interface ModelDetections {
|
|
|
2925
3140
|
imageHeight: number;
|
|
2926
3141
|
/** Name of the computer vision model that produced the detections. */
|
|
2927
3142
|
modelName: string;
|
|
3143
|
+
/**
|
|
3144
|
+
* Id of the camera frame the detections were computed from, 0 if unknown. Matches the frame id
|
|
3145
|
+
* embedded in recorded video; the message description gives the format.
|
|
3146
|
+
*/
|
|
3147
|
+
frameId: number;
|
|
2928
3148
|
}
|
|
2929
3149
|
/** Generic filter settings. */
|
|
2930
3150
|
export interface FilterMessage {
|
|
@@ -2990,6 +3210,11 @@ export interface SotState {
|
|
|
2990
3210
|
vs: number;
|
|
2991
3211
|
/** Kalman rate of change of the bounding box aspect ratio, width / height (1/s). */
|
|
2992
3212
|
vr: number;
|
|
3213
|
+
/**
|
|
3214
|
+
* Id of the camera frame the state was computed from, 0 if unknown. Matches the frame id embedded
|
|
3215
|
+
* in recorded video; ModelDetections describes the format.
|
|
3216
|
+
*/
|
|
3217
|
+
frameId: number;
|
|
2993
3218
|
}
|
|
2994
3219
|
/** Current state of the SOT tracker. */
|
|
2995
3220
|
export declare enum SotState_State {
|
|
@@ -3036,6 +3261,270 @@ export interface Annotation {
|
|
|
3036
3261
|
/** Origin of the annotation; the app sets APP, the drone sets DRONE for its own. */
|
|
3037
3262
|
source: AnnotationSource;
|
|
3038
3263
|
}
|
|
3264
|
+
/** Unit quaternion describing a rotation. */
|
|
3265
|
+
export interface Quaternion {
|
|
3266
|
+
/** X-component of the vector part. */
|
|
3267
|
+
x: number;
|
|
3268
|
+
/** Y-component of the vector part. */
|
|
3269
|
+
y: number;
|
|
3270
|
+
/** Z-component of the vector part. */
|
|
3271
|
+
z: number;
|
|
3272
|
+
/** Scalar part. */
|
|
3273
|
+
w: number;
|
|
3274
|
+
}
|
|
3275
|
+
/**
|
|
3276
|
+
* Points packed for use as typed arrays without decoding them one by one.
|
|
3277
|
+
*
|
|
3278
|
+
* The frame the positions are in is the one the enclosing message names.
|
|
3279
|
+
*/
|
|
3280
|
+
export interface PointCloud {
|
|
3281
|
+
/** Number of points. */
|
|
3282
|
+
count: number;
|
|
3283
|
+
/** count x, y, z triplets of little-endian float32 (m): 12 bytes per point. */
|
|
3284
|
+
positions: Uint8Array;
|
|
3285
|
+
/** count signal strengths, one byte each (0 to 255), or empty when unknown. */
|
|
3286
|
+
intensities: Uint8Array;
|
|
3287
|
+
}
|
|
3288
|
+
/** A sensor whose scans feed the SLAM, and its field of view. */
|
|
3289
|
+
export interface SlamSensor {
|
|
3290
|
+
/** Sensor id, e.g. "waterlinked-sonar-3d15". */
|
|
3291
|
+
id: string;
|
|
3292
|
+
/** Kind of sensor. */
|
|
3293
|
+
type: SlamSensorType;
|
|
3294
|
+
/** Horizontal field of view, about the sensor's z axis (°). */
|
|
3295
|
+
fovHorizontal: number;
|
|
3296
|
+
/** Vertical field of view, about the sensor's y axis (°). */
|
|
3297
|
+
fovVertical: number;
|
|
3298
|
+
/** Range the sensor is set to (m). */
|
|
3299
|
+
maxRange: number;
|
|
3300
|
+
}
|
|
3301
|
+
/**
|
|
3302
|
+
* A recording of the SLAM, as the SLAM reports it.
|
|
3303
|
+
*
|
|
3304
|
+
* A recording is a .sbez file (a binlog) with the SLAM's output: the map at its
|
|
3305
|
+
* start, the poses, the map updates and the status, and the whole map as the last
|
|
3306
|
+
* record. With sensor data it also has the sensor's raw data beside it (for a 3D
|
|
3307
|
+
* sonar a .sonar file), and the drone's dive log logs its telemetry at higher
|
|
3308
|
+
* rates while it runs, so the SLAM can be run again on both without the drone.
|
|
3309
|
+
*/
|
|
3310
|
+
export interface SlamRecordingState {
|
|
3311
|
+
/** True while recording. */
|
|
3312
|
+
isRecording: boolean;
|
|
3313
|
+
/** File name of the .sbez, without its folder. */
|
|
3314
|
+
name: string;
|
|
3315
|
+
/** Time recorded (s). */
|
|
3316
|
+
seconds: number;
|
|
3317
|
+
/** Size of the recording's files so far (bytes). */
|
|
3318
|
+
size: number;
|
|
3319
|
+
/** True if the sensor's raw data is recorded too. */
|
|
3320
|
+
sensorData: boolean;
|
|
3321
|
+
/** Where the recording is stored. */
|
|
3322
|
+
storageLocation: StorageLocation;
|
|
3323
|
+
}
|
|
3324
|
+
/**
|
|
3325
|
+
* Settings of a 3D imaging sonar that feeds the SLAM.
|
|
3326
|
+
*
|
|
3327
|
+
* In a request, unspecified or 0 leaves a setting as it is; in a report, it
|
|
3328
|
+
* means the sonar does not say (e.g. a firmware without frequency modes).
|
|
3329
|
+
*/
|
|
3330
|
+
export interface SlamSonar3dSettings {
|
|
3331
|
+
/** Frequency mode. */
|
|
3332
|
+
frequencyMode: Sonar3dFrequencyMode;
|
|
3333
|
+
/** Maximum range (m). */
|
|
3334
|
+
maxRange: number;
|
|
3335
|
+
}
|
|
3336
|
+
/**
|
|
3337
|
+
* Settings of a sensor that feeds the SLAM.
|
|
3338
|
+
*
|
|
3339
|
+
* One message for each kind of sensor, so a client shows the settings of the
|
|
3340
|
+
* sensors the SLAM has, and a sensor takes only its own.
|
|
3341
|
+
*/
|
|
3342
|
+
export interface SlamSensorSettings {
|
|
3343
|
+
/** A 3D imaging sonar's settings. */
|
|
3344
|
+
sonar3d?: SlamSonar3dSettings | undefined;
|
|
3345
|
+
}
|
|
3346
|
+
/** A sensor that feeds the SLAM, as the SLAM reports it. */
|
|
3347
|
+
export interface SlamSensorStatus {
|
|
3348
|
+
/** The sensor, as its latest scan described it (before its first scan, its id and type only). */
|
|
3349
|
+
sensor: SlamSensor | undefined;
|
|
3350
|
+
/** The sensor's settings, unset when it has none or they cannot be read. */
|
|
3351
|
+
settings: SlamSensorSettings | undefined;
|
|
3352
|
+
/**
|
|
3353
|
+
* The sensor's pose on the platform now: its mount, at the mount's tilt now. Unset when the
|
|
3354
|
+
* platform is the sensor.
|
|
3355
|
+
*/
|
|
3356
|
+
mount: SlamPose | undefined;
|
|
3357
|
+
/** Tilt of the sensor's mount (°, positive up), for a mount that tilts. */
|
|
3358
|
+
mountTilt?: number | undefined;
|
|
3359
|
+
}
|
|
3360
|
+
/**
|
|
3361
|
+
* A pose: of a body in the SLAM map frame, or of a sensor on the platform.
|
|
3362
|
+
*
|
|
3363
|
+
* The map frame is fixed where the map was started (see SlamMapFrame): z down, x
|
|
3364
|
+
* along the heading the map started with (north when a compass heading was used),
|
|
3365
|
+
* y to the right of it, in metres. The body is the one the field names (the
|
|
3366
|
+
* platform, or a sensor), its frame x forward, y right, z down. A mount is a
|
|
3367
|
+
* sensor's pose in the platform's frame instead: the sensor is in the map at the
|
|
3368
|
+
* platform's pose times its mount.
|
|
3369
|
+
*/
|
|
3370
|
+
export interface SlamPose {
|
|
3371
|
+
/** Position of the body (m). */
|
|
3372
|
+
position: Vector3 | undefined;
|
|
3373
|
+
/** Rotation from the body's frame to the frame it is placed in. */
|
|
3374
|
+
orientation: Quaternion | undefined;
|
|
3375
|
+
}
|
|
3376
|
+
/** The SLAM estimate of its platform's pose, published for every scan. */
|
|
3377
|
+
export interface SlamPoseEstimate {
|
|
3378
|
+
/** Identifier of the map; a new one is chosen whenever the map restarts. */
|
|
3379
|
+
mapId: number;
|
|
3380
|
+
/** State of the SLAM. */
|
|
3381
|
+
state: SlamState;
|
|
3382
|
+
/** Pose of the platform (SlamMapFrame.platform) at the scan. */
|
|
3383
|
+
pose: SlamPose | undefined;
|
|
3384
|
+
/** Host time the scan was received. */
|
|
3385
|
+
time: Date | undefined;
|
|
3386
|
+
/** Points of the scan used for matching. */
|
|
3387
|
+
scanPoints: number;
|
|
3388
|
+
/** Share of those points matched to the map (0..1). */
|
|
3389
|
+
matchInlierRatio: number;
|
|
3390
|
+
/** Root mean square point-to-plane distance of the matched points (m). */
|
|
3391
|
+
matchRms: number;
|
|
3392
|
+
/** Keyframes in the map. */
|
|
3393
|
+
keyframeCount: number;
|
|
3394
|
+
/** Points in the map. */
|
|
3395
|
+
mapPointCount: number;
|
|
3396
|
+
/**
|
|
3397
|
+
* Depth used for the scan (m), when there was one: the sensor's, from the drone's depth sensor
|
|
3398
|
+
* through the mount (without a mount, the depth sensor's own).
|
|
3399
|
+
*/
|
|
3400
|
+
depth?: number | undefined;
|
|
3401
|
+
/** Sensor whose scan was placed (SlamSensor.id). */
|
|
3402
|
+
sensorId: string;
|
|
3403
|
+
/**
|
|
3404
|
+
* The sensor's pose on the platform at the scan: the sensor was at pose times mount.
|
|
3405
|
+
* Unset when the platform is the sensor.
|
|
3406
|
+
*/
|
|
3407
|
+
mount: SlamPose | undefined;
|
|
3408
|
+
/**
|
|
3409
|
+
* Covariance of pose as the scan's match placed it against the map, given the
|
|
3410
|
+
* prediction: 6 x 6, row by row, of a rotation about the map's x, y and z axes
|
|
3411
|
+
* (rad) and then a position along them (m). It says how well this scan fixed the
|
|
3412
|
+
* pose, not how far the map has drifted. Empty when the scan was not matched.
|
|
3413
|
+
*/
|
|
3414
|
+
covarianceElements: number[];
|
|
3415
|
+
}
|
|
3416
|
+
/** A keyframe: a scan kept in the map, the nodes of the SLAM trajectory. */
|
|
3417
|
+
export interface SlamKeyframe {
|
|
3418
|
+
/** Keyframe id, increasing along the trajectory. */
|
|
3419
|
+
id: number;
|
|
3420
|
+
/** Submap whose points the keyframe added to. */
|
|
3421
|
+
submapId: number;
|
|
3422
|
+
/** Pose of the platform at the keyframe. It moves when the trajectory is corrected. */
|
|
3423
|
+
pose: SlamPose | undefined;
|
|
3424
|
+
/** Host time the keyframe's scan was received. */
|
|
3425
|
+
time: Date | undefined;
|
|
3426
|
+
/** Sensor whose scan the keyframe is (SlamSensor.id). */
|
|
3427
|
+
sensorId: string;
|
|
3428
|
+
/** The sensor's pose on the platform at the keyframe. Unset when the platform is the sensor. */
|
|
3429
|
+
mount: SlamPose | undefined;
|
|
3430
|
+
}
|
|
3431
|
+
/**
|
|
3432
|
+
* Points of a submap, in the platform's frame at its anchor keyframe.
|
|
3433
|
+
*
|
|
3434
|
+
* A submap moves rigidly with its anchor keyframe, so a correction of the
|
|
3435
|
+
* trajectory moves its points without sending them again. A submap holds one
|
|
3436
|
+
* sensor's points.
|
|
3437
|
+
*/
|
|
3438
|
+
export interface SlamSubmapPoints {
|
|
3439
|
+
/** Submap id. */
|
|
3440
|
+
submapId: number;
|
|
3441
|
+
/** Keyframe whose platform frame the points are in. */
|
|
3442
|
+
anchorKeyframeId: number;
|
|
3443
|
+
/** Points in the platform's frame at the anchor keyframe. */
|
|
3444
|
+
points: PointCloud | undefined;
|
|
3445
|
+
/** Sensor the points come from (SlamSensor.id). */
|
|
3446
|
+
sensorId: string;
|
|
3447
|
+
}
|
|
3448
|
+
/**
|
|
3449
|
+
* A change to the SLAM map.
|
|
3450
|
+
*
|
|
3451
|
+
* Updates are numbered: a client that has the map at sequence N applies the
|
|
3452
|
+
* update with sequence N + 1 next, and asks for the whole map again (GetSlamMapReq)
|
|
3453
|
+
* when it misses one or the map id changes.
|
|
3454
|
+
*/
|
|
3455
|
+
export interface SlamMapUpdate {
|
|
3456
|
+
/** Identifier of the map. */
|
|
3457
|
+
mapId: number;
|
|
3458
|
+
/** Sequence number of this update, from 1. */
|
|
3459
|
+
sequence: number;
|
|
3460
|
+
/** Keyframes added or moved. */
|
|
3461
|
+
keyframes: SlamKeyframe[];
|
|
3462
|
+
/** Points appended to submaps. */
|
|
3463
|
+
points: SlamSubmapPoints[];
|
|
3464
|
+
/**
|
|
3465
|
+
* The map's frame, on the update that adds the first keyframe and on any that
|
|
3466
|
+
* learns more of it: a recording cut short has it without its last SlamMapTel.
|
|
3467
|
+
*/
|
|
3468
|
+
frame: SlamMapFrame | undefined;
|
|
3469
|
+
}
|
|
3470
|
+
/**
|
|
3471
|
+
* How a SLAM map's frame lies in the world, for placing the map on a chart.
|
|
3472
|
+
*
|
|
3473
|
+
* The frame is right-handed: x along the heading reference, y to its right, z
|
|
3474
|
+
* down (north-east-down with SLAM_HEADING_REFERENCE_DRONE_COMPASS). The origin is
|
|
3475
|
+
* the platform's position at the map's first scan. The map's heading may drift
|
|
3476
|
+
* from its reference over a dive: placing a map on a chart fits it to the drone's
|
|
3477
|
+
* positions (PositionEstimateTel in the dive log).
|
|
3478
|
+
*/
|
|
3479
|
+
export interface SlamMapFrame {
|
|
3480
|
+
/** True if z is down and x and y level; false: the first scan's platform frame. */
|
|
3481
|
+
gravityAligned: boolean;
|
|
3482
|
+
/** What x points along. */
|
|
3483
|
+
headingReference: SlamHeadingReference;
|
|
3484
|
+
/**
|
|
3485
|
+
* The magnetic declination the drone applied to its compass heading at the
|
|
3486
|
+
* map's first scan (°, as MagneticDeclination.declination; 0 when it applied
|
|
3487
|
+
* none), with SLAM_HEADING_REFERENCE_DRONE_COMPASS: x then points the place's
|
|
3488
|
+
* declination less this east of true north (0 when the drone applied the
|
|
3489
|
+
* place's). Unset when not known.
|
|
3490
|
+
*/
|
|
3491
|
+
magneticDeclination?: number | undefined;
|
|
3492
|
+
/**
|
|
3493
|
+
* Depth of the origin below the surface (m), for a gravity-aligned map: a point
|
|
3494
|
+
* at z in the map is at depth origin_depth + z. Unset without a depth.
|
|
3495
|
+
*/
|
|
3496
|
+
originDepth?: number | undefined;
|
|
3497
|
+
/** Host time of the map's first scan (its first keyframe's). */
|
|
3498
|
+
startTime: Date | undefined;
|
|
3499
|
+
/** What the map's poses are the poses of. */
|
|
3500
|
+
platform: SlamPlatform;
|
|
3501
|
+
}
|
|
3502
|
+
/** The whole SLAM map. */
|
|
3503
|
+
export interface SlamMap {
|
|
3504
|
+
/** Identifier of the map (0 before the first scan). */
|
|
3505
|
+
mapId: number;
|
|
3506
|
+
/** Sequence number of the last update the map includes (0 for none). */
|
|
3507
|
+
sequence: number;
|
|
3508
|
+
/** Every keyframe, in id order. */
|
|
3509
|
+
keyframes: SlamKeyframe[];
|
|
3510
|
+
/** Every submap's points. */
|
|
3511
|
+
submaps: SlamSubmapPoints[];
|
|
3512
|
+
/** How the map's frame lies in the world (unset before the first scan). */
|
|
3513
|
+
frame: SlamMapFrame | undefined;
|
|
3514
|
+
}
|
|
3515
|
+
/** The latest scan of a sensor, as the SLAM placed it. */
|
|
3516
|
+
export interface SlamScan {
|
|
3517
|
+
/** Identifier of the map. */
|
|
3518
|
+
mapId: number;
|
|
3519
|
+
/** Pose of the platform at the scan. */
|
|
3520
|
+
pose: SlamPose | undefined;
|
|
3521
|
+
/** Points of the scan in the sensor frame: in the map at pose times mount. */
|
|
3522
|
+
points: PointCloud | undefined;
|
|
3523
|
+
/** Sensor the scan comes from. */
|
|
3524
|
+
sensor: SlamSensor | undefined;
|
|
3525
|
+
/** The sensor's pose on the platform at the scan. Unset when the platform is the sensor. */
|
|
3526
|
+
mount: SlamPose | undefined;
|
|
3527
|
+
}
|
|
3039
3528
|
export declare const BinlogRecord: MessageFns<BinlogRecord>;
|
|
3040
3529
|
export declare const LogEntry: MessageFns<LogEntry>;
|
|
3041
3530
|
export declare const KernelLogEntry: MessageFns<KernelLogEntry>;
|
|
@@ -3066,6 +3555,10 @@ export declare const CartesianManipulatorInput: MessageFns<CartesianManipulatorI
|
|
|
3066
3555
|
export declare const CylindricalManipulatorInput: MessageFns<CylindricalManipulatorInput>;
|
|
3067
3556
|
export declare const KnownPoseManipulatorInput: MessageFns<KnownPoseManipulatorInput>;
|
|
3068
3557
|
export declare const Gripper: MessageFns<Gripper>;
|
|
3558
|
+
export declare const ReachHardwareStatus: MessageFns<ReachHardwareStatus>;
|
|
3559
|
+
export declare const GripperDeviceDiagnostics: MessageFns<GripperDeviceDiagnostics>;
|
|
3560
|
+
export declare const GripperInfo: MessageFns<GripperInfo>;
|
|
3561
|
+
export declare const GripperDiagnostics: MessageFns<GripperDiagnostics>;
|
|
3069
3562
|
export declare const ClientInfo: MessageFns<ClientInfo>;
|
|
3070
3563
|
export declare const ConnectedClient: MessageFns<ConnectedClient>;
|
|
3071
3564
|
export declare const RecordState: MessageFns<RecordState>;
|
|
@@ -3162,6 +3655,21 @@ export declare const CameraPanTiltZoom: MessageFns<CameraPanTiltZoom>;
|
|
|
3162
3655
|
export declare const OperatorInfo: MessageFns<OperatorInfo>;
|
|
3163
3656
|
export declare const SotState: MessageFns<SotState>;
|
|
3164
3657
|
export declare const Annotation: MessageFns<Annotation>;
|
|
3658
|
+
export declare const Quaternion: MessageFns<Quaternion>;
|
|
3659
|
+
export declare const PointCloud: MessageFns<PointCloud>;
|
|
3660
|
+
export declare const SlamSensor: MessageFns<SlamSensor>;
|
|
3661
|
+
export declare const SlamRecordingState: MessageFns<SlamRecordingState>;
|
|
3662
|
+
export declare const SlamSonar3dSettings: MessageFns<SlamSonar3dSettings>;
|
|
3663
|
+
export declare const SlamSensorSettings: MessageFns<SlamSensorSettings>;
|
|
3664
|
+
export declare const SlamSensorStatus: MessageFns<SlamSensorStatus>;
|
|
3665
|
+
export declare const SlamPose: MessageFns<SlamPose>;
|
|
3666
|
+
export declare const SlamPoseEstimate: MessageFns<SlamPoseEstimate>;
|
|
3667
|
+
export declare const SlamKeyframe: MessageFns<SlamKeyframe>;
|
|
3668
|
+
export declare const SlamSubmapPoints: MessageFns<SlamSubmapPoints>;
|
|
3669
|
+
export declare const SlamMapUpdate: MessageFns<SlamMapUpdate>;
|
|
3670
|
+
export declare const SlamMapFrame: MessageFns<SlamMapFrame>;
|
|
3671
|
+
export declare const SlamMap: MessageFns<SlamMap>;
|
|
3672
|
+
export declare const SlamScan: MessageFns<SlamScan>;
|
|
3165
3673
|
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
|
|
3166
3674
|
type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
|
|
3167
3675
|
[K in keyof T]?: DeepPartial<T[K]>;
|