@blueyerobotics/protocol-definitions 3.4.0-sonar3d-slam.4e329580 → 3.4.0-sonar3d-slam.1bd69578
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 +38 -4
- package/dist/message_formats.js +166 -4
- package/dist/req_rep.d.ts +6 -3
- package/dist/req_rep.js +19 -2
- package/package.json +1 -1
|
@@ -3297,6 +3297,11 @@ export interface SlamSensor {
|
|
|
3297
3297
|
fovVertical: number;
|
|
3298
3298
|
/** Range the sensor is set to (m). */
|
|
3299
3299
|
maxRange: number;
|
|
3300
|
+
/**
|
|
3301
|
+
* The sensor as a guest port device (e.g. GUEST_PORT_DEVICE_ID_WATERLINKED_SONAR_3D15), for a client
|
|
3302
|
+
* to show the device itself; GUEST_PORT_DEVICE_ID_UNSPECIFIED when it is not one (a simulated sensor).
|
|
3303
|
+
*/
|
|
3304
|
+
deviceId: GuestPortDeviceID;
|
|
3300
3305
|
}
|
|
3301
3306
|
/**
|
|
3302
3307
|
* A recording of the SLAM, as the SLAM reports it.
|
|
@@ -3383,15 +3388,18 @@ export interface SlamPoseEstimate {
|
|
|
3383
3388
|
pose: SlamPose | undefined;
|
|
3384
3389
|
/** Host time the scan was received. */
|
|
3385
3390
|
time: Date | undefined;
|
|
3386
|
-
/** Points of the scan used for matching. */
|
|
3391
|
+
/** Points (or cells) of the scan used for matching. */
|
|
3387
3392
|
scanPoints: number;
|
|
3388
|
-
/** Share of those
|
|
3393
|
+
/** Share of those matched to the map (0..1). */
|
|
3389
3394
|
matchInlierRatio: number;
|
|
3390
|
-
/**
|
|
3395
|
+
/**
|
|
3396
|
+
* Root mean square residual of the matched points against the map (m); for a 3D sonar, their distance to the
|
|
3397
|
+
* map's planes.
|
|
3398
|
+
*/
|
|
3391
3399
|
matchRms: number;
|
|
3392
3400
|
/** Keyframes in the map. */
|
|
3393
3401
|
keyframeCount: number;
|
|
3394
|
-
/** Points in the map. */
|
|
3402
|
+
/** Points (or cells) in the map. */
|
|
3395
3403
|
mapPointCount: number;
|
|
3396
3404
|
/**
|
|
3397
3405
|
* Depth used for the scan (m), when there was one: the sensor's, from the drone's depth sensor
|
|
@@ -3445,6 +3453,25 @@ export interface SlamSubmapPoints {
|
|
|
3445
3453
|
/** Sensor the points come from (SlamSensor.id). */
|
|
3446
3454
|
sensorId: string;
|
|
3447
3455
|
}
|
|
3456
|
+
/**
|
|
3457
|
+
* A loop closure: a keyframe's scan matched to the map where the trajectory had
|
|
3458
|
+
* been before, which corrected the trajectory. The keyframes the correction moved
|
|
3459
|
+
* come in the same update, so a client that held the map before has the
|
|
3460
|
+
* trajectory as it was.
|
|
3461
|
+
*/
|
|
3462
|
+
export interface SlamLoopClosure {
|
|
3463
|
+
/** Keyframe whose scan closed the loop. */
|
|
3464
|
+
keyframeId: number;
|
|
3465
|
+
/** Earlier keyframe it was matched near. */
|
|
3466
|
+
matchedKeyframeId: number;
|
|
3467
|
+
/** How far the correction moved the keyframe that closed the loop (m). */
|
|
3468
|
+
positionCorrection: number;
|
|
3469
|
+
/**
|
|
3470
|
+
* How far it turned that keyframe about the map's z axis (°, positive clockwise seen from
|
|
3471
|
+
* above in a gravity-aligned map).
|
|
3472
|
+
*/
|
|
3473
|
+
headingCorrection: number;
|
|
3474
|
+
}
|
|
3448
3475
|
/**
|
|
3449
3476
|
* A change to the SLAM map.
|
|
3450
3477
|
*
|
|
@@ -3466,6 +3493,8 @@ export interface SlamMapUpdate {
|
|
|
3466
3493
|
* learns more of it: a recording cut short has it without its last SlamMapTel.
|
|
3467
3494
|
*/
|
|
3468
3495
|
frame: SlamMapFrame | undefined;
|
|
3496
|
+
/** Loop closures whose correction moved the keyframes. */
|
|
3497
|
+
loopClosures: SlamLoopClosure[];
|
|
3469
3498
|
}
|
|
3470
3499
|
/**
|
|
3471
3500
|
* How a SLAM map's frame lies in the world, for placing the map on a chart.
|
|
@@ -3511,6 +3540,8 @@ export interface SlamMap {
|
|
|
3511
3540
|
submaps: SlamSubmapPoints[];
|
|
3512
3541
|
/** How the map's frame lies in the world (unset before the first scan). */
|
|
3513
3542
|
frame: SlamMapFrame | undefined;
|
|
3543
|
+
/** Every loop closure, in the order they were made. */
|
|
3544
|
+
loopClosures: SlamLoopClosure[];
|
|
3514
3545
|
}
|
|
3515
3546
|
/** The latest scan of a sensor, as the SLAM placed it. */
|
|
3516
3547
|
export interface SlamScan {
|
|
@@ -3524,6 +3555,8 @@ export interface SlamScan {
|
|
|
3524
3555
|
sensor: SlamSensor | undefined;
|
|
3525
3556
|
/** The sensor's pose on the platform at the scan. Unset when the platform is the sensor. */
|
|
3526
3557
|
mount: SlamPose | undefined;
|
|
3558
|
+
/** Host time the scan was received (as SlamPoseEstimate.time). */
|
|
3559
|
+
time: Date | undefined;
|
|
3527
3560
|
}
|
|
3528
3561
|
export declare const BinlogRecord: MessageFns<BinlogRecord>;
|
|
3529
3562
|
export declare const LogEntry: MessageFns<LogEntry>;
|
|
@@ -3666,6 +3699,7 @@ export declare const SlamPose: MessageFns<SlamPose>;
|
|
|
3666
3699
|
export declare const SlamPoseEstimate: MessageFns<SlamPoseEstimate>;
|
|
3667
3700
|
export declare const SlamKeyframe: MessageFns<SlamKeyframe>;
|
|
3668
3701
|
export declare const SlamSubmapPoints: MessageFns<SlamSubmapPoints>;
|
|
3702
|
+
export declare const SlamLoopClosure: MessageFns<SlamLoopClosure>;
|
|
3669
3703
|
export declare const SlamMapUpdate: MessageFns<SlamMapUpdate>;
|
|
3670
3704
|
export declare const SlamMapFrame: MessageFns<SlamMapFrame>;
|
|
3671
3705
|
export declare const SlamMap: MessageFns<SlamMap>;
|
package/dist/message_formats.js
CHANGED
|
@@ -21211,7 +21211,7 @@ export const PointCloud = {
|
|
|
21211
21211
|
},
|
|
21212
21212
|
};
|
|
21213
21213
|
function createBaseSlamSensor() {
|
|
21214
|
-
return { id: "", type: 0, fovHorizontal: 0, fovVertical: 0, maxRange: 0 };
|
|
21214
|
+
return { id: "", type: 0, fovHorizontal: 0, fovVertical: 0, maxRange: 0, deviceId: 0 };
|
|
21215
21215
|
}
|
|
21216
21216
|
export const SlamSensor = {
|
|
21217
21217
|
encode(message, writer = new BinaryWriter()) {
|
|
@@ -21230,6 +21230,9 @@ export const SlamSensor = {
|
|
|
21230
21230
|
if (message.maxRange !== 0) {
|
|
21231
21231
|
writer.uint32(45).float(message.maxRange);
|
|
21232
21232
|
}
|
|
21233
|
+
if (message.deviceId !== 0) {
|
|
21234
|
+
writer.uint32(48).int32(message.deviceId);
|
|
21235
|
+
}
|
|
21233
21236
|
return writer;
|
|
21234
21237
|
},
|
|
21235
21238
|
decode(input, length) {
|
|
@@ -21274,6 +21277,13 @@ export const SlamSensor = {
|
|
|
21274
21277
|
message.maxRange = reader.float();
|
|
21275
21278
|
continue;
|
|
21276
21279
|
}
|
|
21280
|
+
case 6: {
|
|
21281
|
+
if (tag !== 48) {
|
|
21282
|
+
break;
|
|
21283
|
+
}
|
|
21284
|
+
message.deviceId = reader.int32();
|
|
21285
|
+
continue;
|
|
21286
|
+
}
|
|
21277
21287
|
}
|
|
21278
21288
|
if ((tag & 7) === 4 || tag === 0) {
|
|
21279
21289
|
break;
|
|
@@ -21289,6 +21299,7 @@ export const SlamSensor = {
|
|
|
21289
21299
|
fovHorizontal: isSet(object.fovHorizontal) ? gt.Number(object.fovHorizontal) : 0,
|
|
21290
21300
|
fovVertical: isSet(object.fovVertical) ? gt.Number(object.fovVertical) : 0,
|
|
21291
21301
|
maxRange: isSet(object.maxRange) ? gt.Number(object.maxRange) : 0,
|
|
21302
|
+
deviceId: isSet(object.deviceId) ? guestPortDeviceIDFromJSON(object.deviceId) : 0,
|
|
21292
21303
|
};
|
|
21293
21304
|
},
|
|
21294
21305
|
toJSON(message) {
|
|
@@ -21308,6 +21319,9 @@ export const SlamSensor = {
|
|
|
21308
21319
|
if (message.maxRange !== 0) {
|
|
21309
21320
|
obj.maxRange = message.maxRange;
|
|
21310
21321
|
}
|
|
21322
|
+
if (message.deviceId !== 0) {
|
|
21323
|
+
obj.deviceId = guestPortDeviceIDToJSON(message.deviceId);
|
|
21324
|
+
}
|
|
21311
21325
|
return obj;
|
|
21312
21326
|
},
|
|
21313
21327
|
create(base) {
|
|
@@ -21320,6 +21334,7 @@ export const SlamSensor = {
|
|
|
21320
21334
|
message.fovHorizontal = object.fovHorizontal ?? 0;
|
|
21321
21335
|
message.fovVertical = object.fovVertical ?? 0;
|
|
21322
21336
|
message.maxRange = object.maxRange ?? 0;
|
|
21337
|
+
message.deviceId = object.deviceId ?? 0;
|
|
21323
21338
|
return message;
|
|
21324
21339
|
},
|
|
21325
21340
|
};
|
|
@@ -22238,8 +22253,106 @@ export const SlamSubmapPoints = {
|
|
|
22238
22253
|
return message;
|
|
22239
22254
|
},
|
|
22240
22255
|
};
|
|
22256
|
+
function createBaseSlamLoopClosure() {
|
|
22257
|
+
return { keyframeId: 0, matchedKeyframeId: 0, positionCorrection: 0, headingCorrection: 0 };
|
|
22258
|
+
}
|
|
22259
|
+
export const SlamLoopClosure = {
|
|
22260
|
+
encode(message, writer = new BinaryWriter()) {
|
|
22261
|
+
if (message.keyframeId !== 0) {
|
|
22262
|
+
writer.uint32(8).uint32(message.keyframeId);
|
|
22263
|
+
}
|
|
22264
|
+
if (message.matchedKeyframeId !== 0) {
|
|
22265
|
+
writer.uint32(16).uint32(message.matchedKeyframeId);
|
|
22266
|
+
}
|
|
22267
|
+
if (message.positionCorrection !== 0) {
|
|
22268
|
+
writer.uint32(29).float(message.positionCorrection);
|
|
22269
|
+
}
|
|
22270
|
+
if (message.headingCorrection !== 0) {
|
|
22271
|
+
writer.uint32(37).float(message.headingCorrection);
|
|
22272
|
+
}
|
|
22273
|
+
return writer;
|
|
22274
|
+
},
|
|
22275
|
+
decode(input, length) {
|
|
22276
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
22277
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
22278
|
+
const message = createBaseSlamLoopClosure();
|
|
22279
|
+
while (reader.pos < end) {
|
|
22280
|
+
const tag = reader.uint32();
|
|
22281
|
+
switch (tag >>> 3) {
|
|
22282
|
+
case 1: {
|
|
22283
|
+
if (tag !== 8) {
|
|
22284
|
+
break;
|
|
22285
|
+
}
|
|
22286
|
+
message.keyframeId = reader.uint32();
|
|
22287
|
+
continue;
|
|
22288
|
+
}
|
|
22289
|
+
case 2: {
|
|
22290
|
+
if (tag !== 16) {
|
|
22291
|
+
break;
|
|
22292
|
+
}
|
|
22293
|
+
message.matchedKeyframeId = reader.uint32();
|
|
22294
|
+
continue;
|
|
22295
|
+
}
|
|
22296
|
+
case 3: {
|
|
22297
|
+
if (tag !== 29) {
|
|
22298
|
+
break;
|
|
22299
|
+
}
|
|
22300
|
+
message.positionCorrection = reader.float();
|
|
22301
|
+
continue;
|
|
22302
|
+
}
|
|
22303
|
+
case 4: {
|
|
22304
|
+
if (tag !== 37) {
|
|
22305
|
+
break;
|
|
22306
|
+
}
|
|
22307
|
+
message.headingCorrection = reader.float();
|
|
22308
|
+
continue;
|
|
22309
|
+
}
|
|
22310
|
+
}
|
|
22311
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
22312
|
+
break;
|
|
22313
|
+
}
|
|
22314
|
+
reader.skip(tag & 7);
|
|
22315
|
+
}
|
|
22316
|
+
return message;
|
|
22317
|
+
},
|
|
22318
|
+
fromJSON(object) {
|
|
22319
|
+
return {
|
|
22320
|
+
keyframeId: isSet(object.keyframeId) ? gt.Number(object.keyframeId) : 0,
|
|
22321
|
+
matchedKeyframeId: isSet(object.matchedKeyframeId) ? gt.Number(object.matchedKeyframeId) : 0,
|
|
22322
|
+
positionCorrection: isSet(object.positionCorrection) ? gt.Number(object.positionCorrection) : 0,
|
|
22323
|
+
headingCorrection: isSet(object.headingCorrection) ? gt.Number(object.headingCorrection) : 0,
|
|
22324
|
+
};
|
|
22325
|
+
},
|
|
22326
|
+
toJSON(message) {
|
|
22327
|
+
const obj = {};
|
|
22328
|
+
if (message.keyframeId !== 0) {
|
|
22329
|
+
obj.keyframeId = Math.round(message.keyframeId);
|
|
22330
|
+
}
|
|
22331
|
+
if (message.matchedKeyframeId !== 0) {
|
|
22332
|
+
obj.matchedKeyframeId = Math.round(message.matchedKeyframeId);
|
|
22333
|
+
}
|
|
22334
|
+
if (message.positionCorrection !== 0) {
|
|
22335
|
+
obj.positionCorrection = message.positionCorrection;
|
|
22336
|
+
}
|
|
22337
|
+
if (message.headingCorrection !== 0) {
|
|
22338
|
+
obj.headingCorrection = message.headingCorrection;
|
|
22339
|
+
}
|
|
22340
|
+
return obj;
|
|
22341
|
+
},
|
|
22342
|
+
create(base) {
|
|
22343
|
+
return SlamLoopClosure.fromPartial(base ?? {});
|
|
22344
|
+
},
|
|
22345
|
+
fromPartial(object) {
|
|
22346
|
+
const message = createBaseSlamLoopClosure();
|
|
22347
|
+
message.keyframeId = object.keyframeId ?? 0;
|
|
22348
|
+
message.matchedKeyframeId = object.matchedKeyframeId ?? 0;
|
|
22349
|
+
message.positionCorrection = object.positionCorrection ?? 0;
|
|
22350
|
+
message.headingCorrection = object.headingCorrection ?? 0;
|
|
22351
|
+
return message;
|
|
22352
|
+
},
|
|
22353
|
+
};
|
|
22241
22354
|
function createBaseSlamMapUpdate() {
|
|
22242
|
-
return { mapId: 0, sequence: 0, keyframes: [], points: [], frame: undefined };
|
|
22355
|
+
return { mapId: 0, sequence: 0, keyframes: [], points: [], frame: undefined, loopClosures: [] };
|
|
22243
22356
|
}
|
|
22244
22357
|
export const SlamMapUpdate = {
|
|
22245
22358
|
encode(message, writer = new BinaryWriter()) {
|
|
@@ -22258,6 +22371,9 @@ export const SlamMapUpdate = {
|
|
|
22258
22371
|
if (message.frame !== undefined) {
|
|
22259
22372
|
SlamMapFrame.encode(message.frame, writer.uint32(42).fork()).join();
|
|
22260
22373
|
}
|
|
22374
|
+
for (const v of message.loopClosures) {
|
|
22375
|
+
SlamLoopClosure.encode(v, writer.uint32(50).fork()).join();
|
|
22376
|
+
}
|
|
22261
22377
|
return writer;
|
|
22262
22378
|
},
|
|
22263
22379
|
decode(input, length) {
|
|
@@ -22302,6 +22418,13 @@ export const SlamMapUpdate = {
|
|
|
22302
22418
|
message.frame = SlamMapFrame.decode(reader, reader.uint32());
|
|
22303
22419
|
continue;
|
|
22304
22420
|
}
|
|
22421
|
+
case 6: {
|
|
22422
|
+
if (tag !== 50) {
|
|
22423
|
+
break;
|
|
22424
|
+
}
|
|
22425
|
+
message.loopClosures.push(SlamLoopClosure.decode(reader, reader.uint32()));
|
|
22426
|
+
continue;
|
|
22427
|
+
}
|
|
22305
22428
|
}
|
|
22306
22429
|
if ((tag & 7) === 4 || tag === 0) {
|
|
22307
22430
|
break;
|
|
@@ -22317,6 +22440,9 @@ export const SlamMapUpdate = {
|
|
|
22317
22440
|
keyframes: gt.Array.isArray(object?.keyframes) ? object.keyframes.map((e) => SlamKeyframe.fromJSON(e)) : [],
|
|
22318
22441
|
points: gt.Array.isArray(object?.points) ? object.points.map((e) => SlamSubmapPoints.fromJSON(e)) : [],
|
|
22319
22442
|
frame: isSet(object.frame) ? SlamMapFrame.fromJSON(object.frame) : undefined,
|
|
22443
|
+
loopClosures: gt.Array.isArray(object?.loopClosures)
|
|
22444
|
+
? object.loopClosures.map((e) => SlamLoopClosure.fromJSON(e))
|
|
22445
|
+
: [],
|
|
22320
22446
|
};
|
|
22321
22447
|
},
|
|
22322
22448
|
toJSON(message) {
|
|
@@ -22336,6 +22462,9 @@ export const SlamMapUpdate = {
|
|
|
22336
22462
|
if (message.frame !== undefined) {
|
|
22337
22463
|
obj.frame = SlamMapFrame.toJSON(message.frame);
|
|
22338
22464
|
}
|
|
22465
|
+
if (message.loopClosures?.length) {
|
|
22466
|
+
obj.loopClosures = message.loopClosures.map((e) => SlamLoopClosure.toJSON(e));
|
|
22467
|
+
}
|
|
22339
22468
|
return obj;
|
|
22340
22469
|
},
|
|
22341
22470
|
create(base) {
|
|
@@ -22350,6 +22479,7 @@ export const SlamMapUpdate = {
|
|
|
22350
22479
|
message.frame = (object.frame !== undefined && object.frame !== null)
|
|
22351
22480
|
? SlamMapFrame.fromPartial(object.frame)
|
|
22352
22481
|
: undefined;
|
|
22482
|
+
message.loopClosures = object.loopClosures?.map((e) => SlamLoopClosure.fromPartial(e)) || [];
|
|
22353
22483
|
return message;
|
|
22354
22484
|
},
|
|
22355
22485
|
};
|
|
@@ -22489,7 +22619,7 @@ export const SlamMapFrame = {
|
|
|
22489
22619
|
},
|
|
22490
22620
|
};
|
|
22491
22621
|
function createBaseSlamMap() {
|
|
22492
|
-
return { mapId: 0, sequence: 0, keyframes: [], submaps: [], frame: undefined };
|
|
22622
|
+
return { mapId: 0, sequence: 0, keyframes: [], submaps: [], frame: undefined, loopClosures: [] };
|
|
22493
22623
|
}
|
|
22494
22624
|
export const SlamMap = {
|
|
22495
22625
|
encode(message, writer = new BinaryWriter()) {
|
|
@@ -22508,6 +22638,9 @@ export const SlamMap = {
|
|
|
22508
22638
|
if (message.frame !== undefined) {
|
|
22509
22639
|
SlamMapFrame.encode(message.frame, writer.uint32(42).fork()).join();
|
|
22510
22640
|
}
|
|
22641
|
+
for (const v of message.loopClosures) {
|
|
22642
|
+
SlamLoopClosure.encode(v, writer.uint32(50).fork()).join();
|
|
22643
|
+
}
|
|
22511
22644
|
return writer;
|
|
22512
22645
|
},
|
|
22513
22646
|
decode(input, length) {
|
|
@@ -22552,6 +22685,13 @@ export const SlamMap = {
|
|
|
22552
22685
|
message.frame = SlamMapFrame.decode(reader, reader.uint32());
|
|
22553
22686
|
continue;
|
|
22554
22687
|
}
|
|
22688
|
+
case 6: {
|
|
22689
|
+
if (tag !== 50) {
|
|
22690
|
+
break;
|
|
22691
|
+
}
|
|
22692
|
+
message.loopClosures.push(SlamLoopClosure.decode(reader, reader.uint32()));
|
|
22693
|
+
continue;
|
|
22694
|
+
}
|
|
22555
22695
|
}
|
|
22556
22696
|
if ((tag & 7) === 4 || tag === 0) {
|
|
22557
22697
|
break;
|
|
@@ -22567,6 +22707,9 @@ export const SlamMap = {
|
|
|
22567
22707
|
keyframes: gt.Array.isArray(object?.keyframes) ? object.keyframes.map((e) => SlamKeyframe.fromJSON(e)) : [],
|
|
22568
22708
|
submaps: gt.Array.isArray(object?.submaps) ? object.submaps.map((e) => SlamSubmapPoints.fromJSON(e)) : [],
|
|
22569
22709
|
frame: isSet(object.frame) ? SlamMapFrame.fromJSON(object.frame) : undefined,
|
|
22710
|
+
loopClosures: gt.Array.isArray(object?.loopClosures)
|
|
22711
|
+
? object.loopClosures.map((e) => SlamLoopClosure.fromJSON(e))
|
|
22712
|
+
: [],
|
|
22570
22713
|
};
|
|
22571
22714
|
},
|
|
22572
22715
|
toJSON(message) {
|
|
@@ -22586,6 +22729,9 @@ export const SlamMap = {
|
|
|
22586
22729
|
if (message.frame !== undefined) {
|
|
22587
22730
|
obj.frame = SlamMapFrame.toJSON(message.frame);
|
|
22588
22731
|
}
|
|
22732
|
+
if (message.loopClosures?.length) {
|
|
22733
|
+
obj.loopClosures = message.loopClosures.map((e) => SlamLoopClosure.toJSON(e));
|
|
22734
|
+
}
|
|
22589
22735
|
return obj;
|
|
22590
22736
|
},
|
|
22591
22737
|
create(base) {
|
|
@@ -22600,11 +22746,12 @@ export const SlamMap = {
|
|
|
22600
22746
|
message.frame = (object.frame !== undefined && object.frame !== null)
|
|
22601
22747
|
? SlamMapFrame.fromPartial(object.frame)
|
|
22602
22748
|
: undefined;
|
|
22749
|
+
message.loopClosures = object.loopClosures?.map((e) => SlamLoopClosure.fromPartial(e)) || [];
|
|
22603
22750
|
return message;
|
|
22604
22751
|
},
|
|
22605
22752
|
};
|
|
22606
22753
|
function createBaseSlamScan() {
|
|
22607
|
-
return { mapId: 0, pose: undefined, points: undefined, sensor: undefined, mount: undefined };
|
|
22754
|
+
return { mapId: 0, pose: undefined, points: undefined, sensor: undefined, mount: undefined, time: undefined };
|
|
22608
22755
|
}
|
|
22609
22756
|
export const SlamScan = {
|
|
22610
22757
|
encode(message, writer = new BinaryWriter()) {
|
|
@@ -22623,6 +22770,9 @@ export const SlamScan = {
|
|
|
22623
22770
|
if (message.mount !== undefined) {
|
|
22624
22771
|
SlamPose.encode(message.mount, writer.uint32(42).fork()).join();
|
|
22625
22772
|
}
|
|
22773
|
+
if (message.time !== undefined) {
|
|
22774
|
+
Timestamp.encode(toTimestamp(message.time), writer.uint32(50).fork()).join();
|
|
22775
|
+
}
|
|
22626
22776
|
return writer;
|
|
22627
22777
|
},
|
|
22628
22778
|
decode(input, length) {
|
|
@@ -22667,6 +22817,13 @@ export const SlamScan = {
|
|
|
22667
22817
|
message.mount = SlamPose.decode(reader, reader.uint32());
|
|
22668
22818
|
continue;
|
|
22669
22819
|
}
|
|
22820
|
+
case 6: {
|
|
22821
|
+
if (tag !== 50) {
|
|
22822
|
+
break;
|
|
22823
|
+
}
|
|
22824
|
+
message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
22825
|
+
continue;
|
|
22826
|
+
}
|
|
22670
22827
|
}
|
|
22671
22828
|
if ((tag & 7) === 4 || tag === 0) {
|
|
22672
22829
|
break;
|
|
@@ -22682,6 +22839,7 @@ export const SlamScan = {
|
|
|
22682
22839
|
points: isSet(object.points) ? PointCloud.fromJSON(object.points) : undefined,
|
|
22683
22840
|
sensor: isSet(object.sensor) ? SlamSensor.fromJSON(object.sensor) : undefined,
|
|
22684
22841
|
mount: isSet(object.mount) ? SlamPose.fromJSON(object.mount) : undefined,
|
|
22842
|
+
time: isSet(object.time) ? fromJsonTimestamp(object.time) : undefined,
|
|
22685
22843
|
};
|
|
22686
22844
|
},
|
|
22687
22845
|
toJSON(message) {
|
|
@@ -22701,6 +22859,9 @@ export const SlamScan = {
|
|
|
22701
22859
|
if (message.mount !== undefined) {
|
|
22702
22860
|
obj.mount = SlamPose.toJSON(message.mount);
|
|
22703
22861
|
}
|
|
22862
|
+
if (message.time !== undefined) {
|
|
22863
|
+
obj.time = message.time.toISOString();
|
|
22864
|
+
}
|
|
22704
22865
|
return obj;
|
|
22705
22866
|
},
|
|
22706
22867
|
create(base) {
|
|
@@ -22719,6 +22880,7 @@ export const SlamScan = {
|
|
|
22719
22880
|
message.mount = (object.mount !== undefined && object.mount !== null)
|
|
22720
22881
|
? SlamPose.fromPartial(object.mount)
|
|
22721
22882
|
: undefined;
|
|
22883
|
+
message.time = object.time ?? undefined;
|
|
22722
22884
|
return message;
|
|
22723
22885
|
},
|
|
22724
22886
|
};
|
package/dist/req_rep.d.ts
CHANGED
|
@@ -385,13 +385,16 @@ export interface SetSlamRecordingRep {
|
|
|
385
385
|
/**
|
|
386
386
|
* Request to change the settings of a SLAM sensor.
|
|
387
387
|
*
|
|
388
|
-
* The settings go to the
|
|
389
|
-
* unspecified stay as they are. A change of a
|
|
390
|
-
* map, as the map's resolution follows the
|
|
388
|
+
* The settings go to the sensor named by sensor_id, or without one to the SLAM's
|
|
389
|
+
* sensor of their kind, and those left unspecified stay as they are. A change of a
|
|
390
|
+
* sonar's mode or range begins a new map, as the map's resolution follows the
|
|
391
|
+
* sensor's range.
|
|
391
392
|
*/
|
|
392
393
|
export interface SetSlamSensorSettingsReq {
|
|
393
394
|
/** The settings to change. */
|
|
394
395
|
settings: SlamSensorSettings | undefined;
|
|
396
|
+
/** The sensor to change (SlamSensor.id); empty: the SLAM's sensor of the settings' kind. */
|
|
397
|
+
sensorId: string;
|
|
395
398
|
}
|
|
396
399
|
/** Response after changing the settings of a SLAM sensor. */
|
|
397
400
|
export interface SetSlamSensorSettingsRep {
|
package/dist/req_rep.js
CHANGED
|
@@ -3354,13 +3354,16 @@ export const SetSlamRecordingRep = {
|
|
|
3354
3354
|
},
|
|
3355
3355
|
};
|
|
3356
3356
|
function createBaseSetSlamSensorSettingsReq() {
|
|
3357
|
-
return { settings: undefined };
|
|
3357
|
+
return { settings: undefined, sensorId: "" };
|
|
3358
3358
|
}
|
|
3359
3359
|
export const SetSlamSensorSettingsReq = {
|
|
3360
3360
|
encode(message, writer = new BinaryWriter()) {
|
|
3361
3361
|
if (message.settings !== undefined) {
|
|
3362
3362
|
SlamSensorSettings.encode(message.settings, writer.uint32(10).fork()).join();
|
|
3363
3363
|
}
|
|
3364
|
+
if (message.sensorId !== "") {
|
|
3365
|
+
writer.uint32(18).string(message.sensorId);
|
|
3366
|
+
}
|
|
3364
3367
|
return writer;
|
|
3365
3368
|
},
|
|
3366
3369
|
decode(input, length) {
|
|
@@ -3377,6 +3380,13 @@ export const SetSlamSensorSettingsReq = {
|
|
|
3377
3380
|
message.settings = SlamSensorSettings.decode(reader, reader.uint32());
|
|
3378
3381
|
continue;
|
|
3379
3382
|
}
|
|
3383
|
+
case 2: {
|
|
3384
|
+
if (tag !== 18) {
|
|
3385
|
+
break;
|
|
3386
|
+
}
|
|
3387
|
+
message.sensorId = reader.string();
|
|
3388
|
+
continue;
|
|
3389
|
+
}
|
|
3380
3390
|
}
|
|
3381
3391
|
if ((tag & 7) === 4 || tag === 0) {
|
|
3382
3392
|
break;
|
|
@@ -3386,13 +3396,19 @@ export const SetSlamSensorSettingsReq = {
|
|
|
3386
3396
|
return message;
|
|
3387
3397
|
},
|
|
3388
3398
|
fromJSON(object) {
|
|
3389
|
-
return {
|
|
3399
|
+
return {
|
|
3400
|
+
settings: isSet(object.settings) ? SlamSensorSettings.fromJSON(object.settings) : undefined,
|
|
3401
|
+
sensorId: isSet(object.sensorId) ? gt.String(object.sensorId) : "",
|
|
3402
|
+
};
|
|
3390
3403
|
},
|
|
3391
3404
|
toJSON(message) {
|
|
3392
3405
|
const obj = {};
|
|
3393
3406
|
if (message.settings !== undefined) {
|
|
3394
3407
|
obj.settings = SlamSensorSettings.toJSON(message.settings);
|
|
3395
3408
|
}
|
|
3409
|
+
if (message.sensorId !== "") {
|
|
3410
|
+
obj.sensorId = message.sensorId;
|
|
3411
|
+
}
|
|
3396
3412
|
return obj;
|
|
3397
3413
|
},
|
|
3398
3414
|
create(base) {
|
|
@@ -3403,6 +3419,7 @@ export const SetSlamSensorSettingsReq = {
|
|
|
3403
3419
|
message.settings = (object.settings !== undefined && object.settings !== null)
|
|
3404
3420
|
? SlamSensorSettings.fromPartial(object.settings)
|
|
3405
3421
|
: undefined;
|
|
3422
|
+
message.sensorId = object.sensorId ?? "";
|
|
3406
3423
|
return message;
|
|
3407
3424
|
},
|
|
3408
3425
|
};
|
package/package.json
CHANGED