@blueyerobotics/protocol-definitions 3.4.0-8187f91a → 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 +402 -2
- package/dist/message_formats.js +2044 -2
- package/dist/req_rep.d.ts +120 -1
- package/dist/req_rep.js +791 -1
- package/dist/telemetry.d.ts +60 -1
- package/dist/telemetry.js +309 -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 {
|
|
@@ -1651,7 +1736,7 @@ export interface DvlVelocity {
|
|
|
1651
1736
|
deltaTime: number;
|
|
1652
1737
|
/** Figure of merit, a measure of the accuracy of the velocities (m/s). */
|
|
1653
1738
|
fom: number;
|
|
1654
|
-
/** Velocity, x forward, y
|
|
1739
|
+
/** Velocity, x forward, y right, z down (m/s). */
|
|
1655
1740
|
velocity: Vector3 | undefined;
|
|
1656
1741
|
/** Water tracking status. */
|
|
1657
1742
|
isWaterTracking: boolean;
|
|
@@ -1981,6 +2066,13 @@ export interface DroneInfo {
|
|
|
1981
2066
|
powerSource: PowerSource;
|
|
1982
2067
|
/** Intrinsic calibration of the main camera. Unset when unknown. */
|
|
1983
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;
|
|
1984
2076
|
}
|
|
1985
2077
|
/** Known error states for the drone. */
|
|
1986
2078
|
export interface ErrorFlags {
|
|
@@ -3017,7 +3109,26 @@ export interface ObjectDetection {
|
|
|
3017
3109
|
/** Instance segmentation mask (absent if model has no segmentation). */
|
|
3018
3110
|
mask: SegmentationMask | undefined;
|
|
3019
3111
|
}
|
|
3020
|
-
/**
|
|
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
|
+
*/
|
|
3021
3132
|
export interface ModelDetections {
|
|
3022
3133
|
/** List of detections in the frame. */
|
|
3023
3134
|
detections: ObjectDetection[];
|
|
@@ -3029,6 +3140,11 @@ export interface ModelDetections {
|
|
|
3029
3140
|
imageHeight: number;
|
|
3030
3141
|
/** Name of the computer vision model that produced the detections. */
|
|
3031
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;
|
|
3032
3148
|
}
|
|
3033
3149
|
/** Generic filter settings. */
|
|
3034
3150
|
export interface FilterMessage {
|
|
@@ -3094,6 +3210,11 @@ export interface SotState {
|
|
|
3094
3210
|
vs: number;
|
|
3095
3211
|
/** Kalman rate of change of the bounding box aspect ratio, width / height (1/s). */
|
|
3096
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;
|
|
3097
3218
|
}
|
|
3098
3219
|
/** Current state of the SOT tracker. */
|
|
3099
3220
|
export declare enum SotState_State {
|
|
@@ -3140,6 +3261,270 @@ export interface Annotation {
|
|
|
3140
3261
|
/** Origin of the annotation; the app sets APP, the drone sets DRONE for its own. */
|
|
3141
3262
|
source: AnnotationSource;
|
|
3142
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
|
+
}
|
|
3143
3528
|
export declare const BinlogRecord: MessageFns<BinlogRecord>;
|
|
3144
3529
|
export declare const LogEntry: MessageFns<LogEntry>;
|
|
3145
3530
|
export declare const KernelLogEntry: MessageFns<KernelLogEntry>;
|
|
@@ -3270,6 +3655,21 @@ export declare const CameraPanTiltZoom: MessageFns<CameraPanTiltZoom>;
|
|
|
3270
3655
|
export declare const OperatorInfo: MessageFns<OperatorInfo>;
|
|
3271
3656
|
export declare const SotState: MessageFns<SotState>;
|
|
3272
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>;
|
|
3273
3673
|
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
|
|
3274
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 {} ? {
|
|
3275
3675
|
[K in keyof T]?: DeepPartial<T[K]>;
|