@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
package/dist/message_formats.js
CHANGED
|
@@ -1456,6 +1456,12 @@ export var GuestPortDeviceID;
|
|
|
1456
1456
|
GuestPortDeviceID[GuestPortDeviceID["GUEST_PORT_DEVICE_ID_OUTLAND_TECHNOLOGY_MP200"] = 51] = "GUEST_PORT_DEVICE_ID_OUTLAND_TECHNOLOGY_MP200";
|
|
1457
1457
|
/** GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5 - Reach Robotics Reach Alpha 5 Manipulator. */
|
|
1458
1458
|
GuestPortDeviceID[GuestPortDeviceID["GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5"] = 52] = "GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5";
|
|
1459
|
+
/** GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3 - Blueye Multibeam Skid Servo V3. */
|
|
1460
|
+
GuestPortDeviceID[GuestPortDeviceID["GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3"] = 53] = "GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3";
|
|
1461
|
+
/** GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2 - Detachable Blue Robotics Newton V2. */
|
|
1462
|
+
GuestPortDeviceID[GuestPortDeviceID["GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2"] = 54] = "GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2";
|
|
1463
|
+
/** GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2 - Blueye Scaling Laser V2. */
|
|
1464
|
+
GuestPortDeviceID[GuestPortDeviceID["GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2"] = 55] = "GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2";
|
|
1459
1465
|
GuestPortDeviceID[GuestPortDeviceID["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
1460
1466
|
})(GuestPortDeviceID || (GuestPortDeviceID = {}));
|
|
1461
1467
|
export function guestPortDeviceIDFromJSON(object) {
|
|
@@ -1619,6 +1625,15 @@ export function guestPortDeviceIDFromJSON(object) {
|
|
|
1619
1625
|
case 52:
|
|
1620
1626
|
case "GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5":
|
|
1621
1627
|
return GuestPortDeviceID.GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5;
|
|
1628
|
+
case 53:
|
|
1629
|
+
case "GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3":
|
|
1630
|
+
return GuestPortDeviceID.GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3;
|
|
1631
|
+
case 54:
|
|
1632
|
+
case "GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2":
|
|
1633
|
+
return GuestPortDeviceID.GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2;
|
|
1634
|
+
case 55:
|
|
1635
|
+
case "GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2":
|
|
1636
|
+
return GuestPortDeviceID.GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2;
|
|
1622
1637
|
case -1:
|
|
1623
1638
|
case "UNRECOGNIZED":
|
|
1624
1639
|
default:
|
|
@@ -1733,6 +1748,12 @@ export function guestPortDeviceIDToJSON(object) {
|
|
|
1733
1748
|
return "GUEST_PORT_DEVICE_ID_OUTLAND_TECHNOLOGY_MP200";
|
|
1734
1749
|
case GuestPortDeviceID.GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5:
|
|
1735
1750
|
return "GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5";
|
|
1751
|
+
case GuestPortDeviceID.GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3:
|
|
1752
|
+
return "GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3";
|
|
1753
|
+
case GuestPortDeviceID.GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2:
|
|
1754
|
+
return "GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2";
|
|
1755
|
+
case GuestPortDeviceID.GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2:
|
|
1756
|
+
return "GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2";
|
|
1736
1757
|
case GuestPortDeviceID.UNRECOGNIZED:
|
|
1737
1758
|
default:
|
|
1738
1759
|
return "UNRECOGNIZED";
|
|
@@ -1831,6 +1852,10 @@ export var GuestPortCapability;
|
|
|
1831
1852
|
GuestPortCapability[GuestPortCapability["GUEST_PORT_CAPABILITY_PWM"] = 6] = "GUEST_PORT_CAPABILITY_PWM";
|
|
1832
1853
|
/** GUEST_PORT_CAPABILITY_ETHERNET_1G - Gigabit Ethernet. */
|
|
1833
1854
|
GuestPortCapability[GuestPortCapability["GUEST_PORT_CAPABILITY_ETHERNET_1G"] = 7] = "GUEST_PORT_CAPABILITY_ETHERNET_1G";
|
|
1855
|
+
/** GUEST_PORT_CAPABILITY_I2C_IO - TCA9536 I/O expander. */
|
|
1856
|
+
GuestPortCapability[GuestPortCapability["GUEST_PORT_CAPABILITY_I2C_IO"] = 8] = "GUEST_PORT_CAPABILITY_I2C_IO";
|
|
1857
|
+
/** GUEST_PORT_CAPABILITY_I2C_IO_V2 - PCA9554A I/O expander. */
|
|
1858
|
+
GuestPortCapability[GuestPortCapability["GUEST_PORT_CAPABILITY_I2C_IO_V2"] = 9] = "GUEST_PORT_CAPABILITY_I2C_IO_V2";
|
|
1834
1859
|
GuestPortCapability[GuestPortCapability["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
1835
1860
|
})(GuestPortCapability || (GuestPortCapability = {}));
|
|
1836
1861
|
export function guestPortCapabilityFromJSON(object) {
|
|
@@ -1859,6 +1884,12 @@ export function guestPortCapabilityFromJSON(object) {
|
|
|
1859
1884
|
case 7:
|
|
1860
1885
|
case "GUEST_PORT_CAPABILITY_ETHERNET_1G":
|
|
1861
1886
|
return GuestPortCapability.GUEST_PORT_CAPABILITY_ETHERNET_1G;
|
|
1887
|
+
case 8:
|
|
1888
|
+
case "GUEST_PORT_CAPABILITY_I2C_IO":
|
|
1889
|
+
return GuestPortCapability.GUEST_PORT_CAPABILITY_I2C_IO;
|
|
1890
|
+
case 9:
|
|
1891
|
+
case "GUEST_PORT_CAPABILITY_I2C_IO_V2":
|
|
1892
|
+
return GuestPortCapability.GUEST_PORT_CAPABILITY_I2C_IO_V2;
|
|
1862
1893
|
case -1:
|
|
1863
1894
|
case "UNRECOGNIZED":
|
|
1864
1895
|
default:
|
|
@@ -1883,6 +1914,10 @@ export function guestPortCapabilityToJSON(object) {
|
|
|
1883
1914
|
return "GUEST_PORT_CAPABILITY_PWM";
|
|
1884
1915
|
case GuestPortCapability.GUEST_PORT_CAPABILITY_ETHERNET_1G:
|
|
1885
1916
|
return "GUEST_PORT_CAPABILITY_ETHERNET_1G";
|
|
1917
|
+
case GuestPortCapability.GUEST_PORT_CAPABILITY_I2C_IO:
|
|
1918
|
+
return "GUEST_PORT_CAPABILITY_I2C_IO";
|
|
1919
|
+
case GuestPortCapability.GUEST_PORT_CAPABILITY_I2C_IO_V2:
|
|
1920
|
+
return "GUEST_PORT_CAPABILITY_I2C_IO_V2";
|
|
1886
1921
|
case GuestPortCapability.UNRECOGNIZED:
|
|
1887
1922
|
default:
|
|
1888
1923
|
return "UNRECOGNIZED";
|
|
@@ -2366,6 +2401,231 @@ export function annotationSourceToJSON(object) {
|
|
|
2366
2401
|
return "UNRECOGNIZED";
|
|
2367
2402
|
}
|
|
2368
2403
|
}
|
|
2404
|
+
/** State of the SLAM (simultaneous localization and mapping). */
|
|
2405
|
+
export var SlamState;
|
|
2406
|
+
(function (SlamState) {
|
|
2407
|
+
/** SLAM_STATE_UNSPECIFIED - Unspecified. */
|
|
2408
|
+
SlamState[SlamState["SLAM_STATE_UNSPECIFIED"] = 0] = "SLAM_STATE_UNSPECIFIED";
|
|
2409
|
+
/** SLAM_STATE_WAITING - Waiting for the first scan and orientation. */
|
|
2410
|
+
SlamState[SlamState["SLAM_STATE_WAITING"] = 1] = "SLAM_STATE_WAITING";
|
|
2411
|
+
/** SLAM_STATE_TRACKING - The latest scan was matched against the map. */
|
|
2412
|
+
SlamState[SlamState["SLAM_STATE_TRACKING"] = 2] = "SLAM_STATE_TRACKING";
|
|
2413
|
+
/** SLAM_STATE_COASTING - The latest scan could not be matched; the pose follows the motion model. */
|
|
2414
|
+
SlamState[SlamState["SLAM_STATE_COASTING"] = 3] = "SLAM_STATE_COASTING";
|
|
2415
|
+
SlamState[SlamState["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
2416
|
+
})(SlamState || (SlamState = {}));
|
|
2417
|
+
export function slamStateFromJSON(object) {
|
|
2418
|
+
switch (object) {
|
|
2419
|
+
case 0:
|
|
2420
|
+
case "SLAM_STATE_UNSPECIFIED":
|
|
2421
|
+
return SlamState.SLAM_STATE_UNSPECIFIED;
|
|
2422
|
+
case 1:
|
|
2423
|
+
case "SLAM_STATE_WAITING":
|
|
2424
|
+
return SlamState.SLAM_STATE_WAITING;
|
|
2425
|
+
case 2:
|
|
2426
|
+
case "SLAM_STATE_TRACKING":
|
|
2427
|
+
return SlamState.SLAM_STATE_TRACKING;
|
|
2428
|
+
case 3:
|
|
2429
|
+
case "SLAM_STATE_COASTING":
|
|
2430
|
+
return SlamState.SLAM_STATE_COASTING;
|
|
2431
|
+
case -1:
|
|
2432
|
+
case "UNRECOGNIZED":
|
|
2433
|
+
default:
|
|
2434
|
+
return SlamState.UNRECOGNIZED;
|
|
2435
|
+
}
|
|
2436
|
+
}
|
|
2437
|
+
export function slamStateToJSON(object) {
|
|
2438
|
+
switch (object) {
|
|
2439
|
+
case SlamState.SLAM_STATE_UNSPECIFIED:
|
|
2440
|
+
return "SLAM_STATE_UNSPECIFIED";
|
|
2441
|
+
case SlamState.SLAM_STATE_WAITING:
|
|
2442
|
+
return "SLAM_STATE_WAITING";
|
|
2443
|
+
case SlamState.SLAM_STATE_TRACKING:
|
|
2444
|
+
return "SLAM_STATE_TRACKING";
|
|
2445
|
+
case SlamState.SLAM_STATE_COASTING:
|
|
2446
|
+
return "SLAM_STATE_COASTING";
|
|
2447
|
+
case SlamState.UNRECOGNIZED:
|
|
2448
|
+
default:
|
|
2449
|
+
return "UNRECOGNIZED";
|
|
2450
|
+
}
|
|
2451
|
+
}
|
|
2452
|
+
/** Kind of sensor a SLAM scan comes from. */
|
|
2453
|
+
export var SlamSensorType;
|
|
2454
|
+
(function (SlamSensorType) {
|
|
2455
|
+
/** SLAM_SENSOR_TYPE_UNSPECIFIED - Unspecified. */
|
|
2456
|
+
SlamSensorType[SlamSensorType["SLAM_SENSOR_TYPE_UNSPECIFIED"] = 0] = "SLAM_SENSOR_TYPE_UNSPECIFIED";
|
|
2457
|
+
/** SLAM_SENSOR_TYPE_SONAR_3D - A 3D imaging sonar, e.g. the Water Linked Sonar 3D-15. */
|
|
2458
|
+
SlamSensorType[SlamSensorType["SLAM_SENSOR_TYPE_SONAR_3D"] = 1] = "SLAM_SENSOR_TYPE_SONAR_3D";
|
|
2459
|
+
/** SLAM_SENSOR_TYPE_STEREO_CAMERA - A stereo camera's depth. */
|
|
2460
|
+
SlamSensorType[SlamSensorType["SLAM_SENSOR_TYPE_STEREO_CAMERA"] = 2] = "SLAM_SENSOR_TYPE_STEREO_CAMERA";
|
|
2461
|
+
/** SLAM_SENSOR_TYPE_SIMULATED - A simulated sensor. */
|
|
2462
|
+
SlamSensorType[SlamSensorType["SLAM_SENSOR_TYPE_SIMULATED"] = 3] = "SLAM_SENSOR_TYPE_SIMULATED";
|
|
2463
|
+
SlamSensorType[SlamSensorType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
2464
|
+
})(SlamSensorType || (SlamSensorType = {}));
|
|
2465
|
+
export function slamSensorTypeFromJSON(object) {
|
|
2466
|
+
switch (object) {
|
|
2467
|
+
case 0:
|
|
2468
|
+
case "SLAM_SENSOR_TYPE_UNSPECIFIED":
|
|
2469
|
+
return SlamSensorType.SLAM_SENSOR_TYPE_UNSPECIFIED;
|
|
2470
|
+
case 1:
|
|
2471
|
+
case "SLAM_SENSOR_TYPE_SONAR_3D":
|
|
2472
|
+
return SlamSensorType.SLAM_SENSOR_TYPE_SONAR_3D;
|
|
2473
|
+
case 2:
|
|
2474
|
+
case "SLAM_SENSOR_TYPE_STEREO_CAMERA":
|
|
2475
|
+
return SlamSensorType.SLAM_SENSOR_TYPE_STEREO_CAMERA;
|
|
2476
|
+
case 3:
|
|
2477
|
+
case "SLAM_SENSOR_TYPE_SIMULATED":
|
|
2478
|
+
return SlamSensorType.SLAM_SENSOR_TYPE_SIMULATED;
|
|
2479
|
+
case -1:
|
|
2480
|
+
case "UNRECOGNIZED":
|
|
2481
|
+
default:
|
|
2482
|
+
return SlamSensorType.UNRECOGNIZED;
|
|
2483
|
+
}
|
|
2484
|
+
}
|
|
2485
|
+
export function slamSensorTypeToJSON(object) {
|
|
2486
|
+
switch (object) {
|
|
2487
|
+
case SlamSensorType.SLAM_SENSOR_TYPE_UNSPECIFIED:
|
|
2488
|
+
return "SLAM_SENSOR_TYPE_UNSPECIFIED";
|
|
2489
|
+
case SlamSensorType.SLAM_SENSOR_TYPE_SONAR_3D:
|
|
2490
|
+
return "SLAM_SENSOR_TYPE_SONAR_3D";
|
|
2491
|
+
case SlamSensorType.SLAM_SENSOR_TYPE_STEREO_CAMERA:
|
|
2492
|
+
return "SLAM_SENSOR_TYPE_STEREO_CAMERA";
|
|
2493
|
+
case SlamSensorType.SLAM_SENSOR_TYPE_SIMULATED:
|
|
2494
|
+
return "SLAM_SENSOR_TYPE_SIMULATED";
|
|
2495
|
+
case SlamSensorType.UNRECOGNIZED:
|
|
2496
|
+
default:
|
|
2497
|
+
return "UNRECOGNIZED";
|
|
2498
|
+
}
|
|
2499
|
+
}
|
|
2500
|
+
/** What the SLAM's poses are the poses of: its platform. */
|
|
2501
|
+
export var SlamPlatform;
|
|
2502
|
+
(function (SlamPlatform) {
|
|
2503
|
+
/** SLAM_PLATFORM_UNSPECIFIED - Not known. */
|
|
2504
|
+
SlamPlatform[SlamPlatform["SLAM_PLATFORM_UNSPECIFIED"] = 0] = "SLAM_PLATFORM_UNSPECIFIED";
|
|
2505
|
+
/**
|
|
2506
|
+
* SLAM_PLATFORM_DRONE - The drone, its body frame x forward, y right, z down from the middle of the hull. Each
|
|
2507
|
+
* sensor is on it through its mount (SlamPose mount in the messages that carry one).
|
|
2508
|
+
*/
|
|
2509
|
+
SlamPlatform[SlamPlatform["SLAM_PLATFORM_DRONE"] = 1] = "SLAM_PLATFORM_DRONE";
|
|
2510
|
+
/** SLAM_PLATFORM_SENSOR - The sensor itself: the SLAM did not know how the sensor is mounted. */
|
|
2511
|
+
SlamPlatform[SlamPlatform["SLAM_PLATFORM_SENSOR"] = 2] = "SLAM_PLATFORM_SENSOR";
|
|
2512
|
+
SlamPlatform[SlamPlatform["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
2513
|
+
})(SlamPlatform || (SlamPlatform = {}));
|
|
2514
|
+
export function slamPlatformFromJSON(object) {
|
|
2515
|
+
switch (object) {
|
|
2516
|
+
case 0:
|
|
2517
|
+
case "SLAM_PLATFORM_UNSPECIFIED":
|
|
2518
|
+
return SlamPlatform.SLAM_PLATFORM_UNSPECIFIED;
|
|
2519
|
+
case 1:
|
|
2520
|
+
case "SLAM_PLATFORM_DRONE":
|
|
2521
|
+
return SlamPlatform.SLAM_PLATFORM_DRONE;
|
|
2522
|
+
case 2:
|
|
2523
|
+
case "SLAM_PLATFORM_SENSOR":
|
|
2524
|
+
return SlamPlatform.SLAM_PLATFORM_SENSOR;
|
|
2525
|
+
case -1:
|
|
2526
|
+
case "UNRECOGNIZED":
|
|
2527
|
+
default:
|
|
2528
|
+
return SlamPlatform.UNRECOGNIZED;
|
|
2529
|
+
}
|
|
2530
|
+
}
|
|
2531
|
+
export function slamPlatformToJSON(object) {
|
|
2532
|
+
switch (object) {
|
|
2533
|
+
case SlamPlatform.SLAM_PLATFORM_UNSPECIFIED:
|
|
2534
|
+
return "SLAM_PLATFORM_UNSPECIFIED";
|
|
2535
|
+
case SlamPlatform.SLAM_PLATFORM_DRONE:
|
|
2536
|
+
return "SLAM_PLATFORM_DRONE";
|
|
2537
|
+
case SlamPlatform.SLAM_PLATFORM_SENSOR:
|
|
2538
|
+
return "SLAM_PLATFORM_SENSOR";
|
|
2539
|
+
case SlamPlatform.UNRECOGNIZED:
|
|
2540
|
+
default:
|
|
2541
|
+
return "UNRECOGNIZED";
|
|
2542
|
+
}
|
|
2543
|
+
}
|
|
2544
|
+
/** Frequency mode of a 3D imaging sonar. */
|
|
2545
|
+
export var Sonar3dFrequencyMode;
|
|
2546
|
+
(function (Sonar3dFrequencyMode) {
|
|
2547
|
+
/** SONAR_3D_FREQUENCY_MODE_UNSPECIFIED - Unspecified: left as it is. */
|
|
2548
|
+
Sonar3dFrequencyMode[Sonar3dFrequencyMode["SONAR_3D_FREQUENCY_MODE_UNSPECIFIED"] = 0] = "SONAR_3D_FREQUENCY_MODE_UNSPECIFIED";
|
|
2549
|
+
/** SONAR_3D_FREQUENCY_MODE_LOW - Wide view, long range (3D-15: 90° x 40°, 15 m, 5 scans/s). */
|
|
2550
|
+
Sonar3dFrequencyMode[Sonar3dFrequencyMode["SONAR_3D_FREQUENCY_MODE_LOW"] = 1] = "SONAR_3D_FREQUENCY_MODE_LOW";
|
|
2551
|
+
/** SONAR_3D_FREQUENCY_MODE_HIGH - Narrow view, short range, fine detail (3D-15: 40° x 40°, 4 m, 20 scans/s). */
|
|
2552
|
+
Sonar3dFrequencyMode[Sonar3dFrequencyMode["SONAR_3D_FREQUENCY_MODE_HIGH"] = 2] = "SONAR_3D_FREQUENCY_MODE_HIGH";
|
|
2553
|
+
Sonar3dFrequencyMode[Sonar3dFrequencyMode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
2554
|
+
})(Sonar3dFrequencyMode || (Sonar3dFrequencyMode = {}));
|
|
2555
|
+
export function sonar3dFrequencyModeFromJSON(object) {
|
|
2556
|
+
switch (object) {
|
|
2557
|
+
case 0:
|
|
2558
|
+
case "SONAR_3D_FREQUENCY_MODE_UNSPECIFIED":
|
|
2559
|
+
return Sonar3dFrequencyMode.SONAR_3D_FREQUENCY_MODE_UNSPECIFIED;
|
|
2560
|
+
case 1:
|
|
2561
|
+
case "SONAR_3D_FREQUENCY_MODE_LOW":
|
|
2562
|
+
return Sonar3dFrequencyMode.SONAR_3D_FREQUENCY_MODE_LOW;
|
|
2563
|
+
case 2:
|
|
2564
|
+
case "SONAR_3D_FREQUENCY_MODE_HIGH":
|
|
2565
|
+
return Sonar3dFrequencyMode.SONAR_3D_FREQUENCY_MODE_HIGH;
|
|
2566
|
+
case -1:
|
|
2567
|
+
case "UNRECOGNIZED":
|
|
2568
|
+
default:
|
|
2569
|
+
return Sonar3dFrequencyMode.UNRECOGNIZED;
|
|
2570
|
+
}
|
|
2571
|
+
}
|
|
2572
|
+
export function sonar3dFrequencyModeToJSON(object) {
|
|
2573
|
+
switch (object) {
|
|
2574
|
+
case Sonar3dFrequencyMode.SONAR_3D_FREQUENCY_MODE_UNSPECIFIED:
|
|
2575
|
+
return "SONAR_3D_FREQUENCY_MODE_UNSPECIFIED";
|
|
2576
|
+
case Sonar3dFrequencyMode.SONAR_3D_FREQUENCY_MODE_LOW:
|
|
2577
|
+
return "SONAR_3D_FREQUENCY_MODE_LOW";
|
|
2578
|
+
case Sonar3dFrequencyMode.SONAR_3D_FREQUENCY_MODE_HIGH:
|
|
2579
|
+
return "SONAR_3D_FREQUENCY_MODE_HIGH";
|
|
2580
|
+
case Sonar3dFrequencyMode.UNRECOGNIZED:
|
|
2581
|
+
default:
|
|
2582
|
+
return "UNRECOGNIZED";
|
|
2583
|
+
}
|
|
2584
|
+
}
|
|
2585
|
+
/** What the x axis of a SLAM map's frame points along. */
|
|
2586
|
+
export var SlamHeadingReference;
|
|
2587
|
+
(function (SlamHeadingReference) {
|
|
2588
|
+
/** SLAM_HEADING_REFERENCE_UNSPECIFIED - Not known. */
|
|
2589
|
+
SlamHeadingReference[SlamHeadingReference["SLAM_HEADING_REFERENCE_UNSPECIFIED"] = 0] = "SLAM_HEADING_REFERENCE_UNSPECIFIED";
|
|
2590
|
+
/**
|
|
2591
|
+
* SLAM_HEADING_REFERENCE_FIRST_SCAN - The platform's heading at the map's first scan; without gravity alignment, the
|
|
2592
|
+
* platform's frame at the first scan as it is.
|
|
2593
|
+
*/
|
|
2594
|
+
SlamHeadingReference[SlamHeadingReference["SLAM_HEADING_REFERENCE_FIRST_SCAN"] = 1] = "SLAM_HEADING_REFERENCE_FIRST_SCAN";
|
|
2595
|
+
/** SLAM_HEADING_REFERENCE_DRONE_COMPASS - North, as the drone's compass heading (AttitudeTel yaw) gave it at the map's first scan. */
|
|
2596
|
+
SlamHeadingReference[SlamHeadingReference["SLAM_HEADING_REFERENCE_DRONE_COMPASS"] = 2] = "SLAM_HEADING_REFERENCE_DRONE_COMPASS";
|
|
2597
|
+
SlamHeadingReference[SlamHeadingReference["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
2598
|
+
})(SlamHeadingReference || (SlamHeadingReference = {}));
|
|
2599
|
+
export function slamHeadingReferenceFromJSON(object) {
|
|
2600
|
+
switch (object) {
|
|
2601
|
+
case 0:
|
|
2602
|
+
case "SLAM_HEADING_REFERENCE_UNSPECIFIED":
|
|
2603
|
+
return SlamHeadingReference.SLAM_HEADING_REFERENCE_UNSPECIFIED;
|
|
2604
|
+
case 1:
|
|
2605
|
+
case "SLAM_HEADING_REFERENCE_FIRST_SCAN":
|
|
2606
|
+
return SlamHeadingReference.SLAM_HEADING_REFERENCE_FIRST_SCAN;
|
|
2607
|
+
case 2:
|
|
2608
|
+
case "SLAM_HEADING_REFERENCE_DRONE_COMPASS":
|
|
2609
|
+
return SlamHeadingReference.SLAM_HEADING_REFERENCE_DRONE_COMPASS;
|
|
2610
|
+
case -1:
|
|
2611
|
+
case "UNRECOGNIZED":
|
|
2612
|
+
default:
|
|
2613
|
+
return SlamHeadingReference.UNRECOGNIZED;
|
|
2614
|
+
}
|
|
2615
|
+
}
|
|
2616
|
+
export function slamHeadingReferenceToJSON(object) {
|
|
2617
|
+
switch (object) {
|
|
2618
|
+
case SlamHeadingReference.SLAM_HEADING_REFERENCE_UNSPECIFIED:
|
|
2619
|
+
return "SLAM_HEADING_REFERENCE_UNSPECIFIED";
|
|
2620
|
+
case SlamHeadingReference.SLAM_HEADING_REFERENCE_FIRST_SCAN:
|
|
2621
|
+
return "SLAM_HEADING_REFERENCE_FIRST_SCAN";
|
|
2622
|
+
case SlamHeadingReference.SLAM_HEADING_REFERENCE_DRONE_COMPASS:
|
|
2623
|
+
return "SLAM_HEADING_REFERENCE_DRONE_COMPASS";
|
|
2624
|
+
case SlamHeadingReference.UNRECOGNIZED:
|
|
2625
|
+
default:
|
|
2626
|
+
return "UNRECOGNIZED";
|
|
2627
|
+
}
|
|
2628
|
+
}
|
|
2369
2629
|
export var LogEntry_LogLevel;
|
|
2370
2630
|
(function (LogEntry_LogLevel) {
|
|
2371
2631
|
/** LOG_LEVEL_UNSPECIFIED - Unspecified log level. */
|
|
@@ -3857,6 +4117,7 @@ function createBaseLaserDetection() {
|
|
|
3857
4117
|
laserWidth: 0,
|
|
3858
4118
|
correctedPixelDistance: 0,
|
|
3859
4119
|
estimatedDistance: 0,
|
|
4120
|
+
frameId: 0,
|
|
3860
4121
|
};
|
|
3861
4122
|
}
|
|
3862
4123
|
export const LaserDetection = {
|
|
@@ -3891,6 +4152,9 @@ export const LaserDetection = {
|
|
|
3891
4152
|
if (message.estimatedDistance !== 0) {
|
|
3892
4153
|
writer.uint32(85).float(message.estimatedDistance);
|
|
3893
4154
|
}
|
|
4155
|
+
if (message.frameId !== 0) {
|
|
4156
|
+
writer.uint32(88).uint64(message.frameId);
|
|
4157
|
+
}
|
|
3894
4158
|
return writer;
|
|
3895
4159
|
},
|
|
3896
4160
|
decode(input, length) {
|
|
@@ -3970,6 +4234,13 @@ export const LaserDetection = {
|
|
|
3970
4234
|
message.estimatedDistance = reader.float();
|
|
3971
4235
|
continue;
|
|
3972
4236
|
}
|
|
4237
|
+
case 11: {
|
|
4238
|
+
if (tag !== 88) {
|
|
4239
|
+
break;
|
|
4240
|
+
}
|
|
4241
|
+
message.frameId = longToNumber(reader.uint64());
|
|
4242
|
+
continue;
|
|
4243
|
+
}
|
|
3973
4244
|
}
|
|
3974
4245
|
if ((tag & 7) === 4 || tag === 0) {
|
|
3975
4246
|
break;
|
|
@@ -3990,6 +4261,7 @@ export const LaserDetection = {
|
|
|
3990
4261
|
laserWidth: isSet(object.laserWidth) ? gt.Number(object.laserWidth) : 0,
|
|
3991
4262
|
correctedPixelDistance: isSet(object.correctedPixelDistance) ? gt.Number(object.correctedPixelDistance) : 0,
|
|
3992
4263
|
estimatedDistance: isSet(object.estimatedDistance) ? gt.Number(object.estimatedDistance) : 0,
|
|
4264
|
+
frameId: isSet(object.frameId) ? gt.Number(object.frameId) : 0,
|
|
3993
4265
|
};
|
|
3994
4266
|
},
|
|
3995
4267
|
toJSON(message) {
|
|
@@ -4024,6 +4296,9 @@ export const LaserDetection = {
|
|
|
4024
4296
|
if (message.estimatedDistance !== 0) {
|
|
4025
4297
|
obj.estimatedDistance = message.estimatedDistance;
|
|
4026
4298
|
}
|
|
4299
|
+
if (message.frameId !== 0) {
|
|
4300
|
+
obj.frameId = Math.round(message.frameId);
|
|
4301
|
+
}
|
|
4027
4302
|
return obj;
|
|
4028
4303
|
},
|
|
4029
4304
|
create(base) {
|
|
@@ -4041,6 +4316,7 @@ export const LaserDetection = {
|
|
|
4041
4316
|
message.laserWidth = object.laserWidth ?? 0;
|
|
4042
4317
|
message.correctedPixelDistance = object.correctedPixelDistance ?? 0;
|
|
4043
4318
|
message.estimatedDistance = object.estimatedDistance ?? 0;
|
|
4319
|
+
message.frameId = object.frameId ?? 0;
|
|
4044
4320
|
return message;
|
|
4045
4321
|
},
|
|
4046
4322
|
};
|
|
@@ -11880,6 +12156,8 @@ function createBaseDroneInfo() {
|
|
|
11880
12156
|
cvModels: [],
|
|
11881
12157
|
powerSource: 0,
|
|
11882
12158
|
mainCameraCalibration: undefined,
|
|
12159
|
+
diveNumber: 0,
|
|
12160
|
+
logName: "",
|
|
11883
12161
|
};
|
|
11884
12162
|
}
|
|
11885
12163
|
export const DroneInfo = {
|
|
@@ -11926,6 +12204,12 @@ export const DroneInfo = {
|
|
|
11926
12204
|
if (message.mainCameraCalibration !== undefined) {
|
|
11927
12205
|
CameraCalibration.encode(message.mainCameraCalibration, writer.uint32(114).fork()).join();
|
|
11928
12206
|
}
|
|
12207
|
+
if (message.diveNumber !== 0) {
|
|
12208
|
+
writer.uint32(120).uint32(message.diveNumber);
|
|
12209
|
+
}
|
|
12210
|
+
if (message.logName !== "") {
|
|
12211
|
+
writer.uint32(130).string(message.logName);
|
|
12212
|
+
}
|
|
11929
12213
|
return writer;
|
|
11930
12214
|
},
|
|
11931
12215
|
decode(input, length) {
|
|
@@ -12033,6 +12317,20 @@ export const DroneInfo = {
|
|
|
12033
12317
|
message.mainCameraCalibration = CameraCalibration.decode(reader, reader.uint32());
|
|
12034
12318
|
continue;
|
|
12035
12319
|
}
|
|
12320
|
+
case 15: {
|
|
12321
|
+
if (tag !== 120) {
|
|
12322
|
+
break;
|
|
12323
|
+
}
|
|
12324
|
+
message.diveNumber = reader.uint32();
|
|
12325
|
+
continue;
|
|
12326
|
+
}
|
|
12327
|
+
case 16: {
|
|
12328
|
+
if (tag !== 130) {
|
|
12329
|
+
break;
|
|
12330
|
+
}
|
|
12331
|
+
message.logName = reader.string();
|
|
12332
|
+
continue;
|
|
12333
|
+
}
|
|
12036
12334
|
}
|
|
12037
12335
|
if ((tag & 7) === 4 || tag === 0) {
|
|
12038
12336
|
break;
|
|
@@ -12059,6 +12357,8 @@ export const DroneInfo = {
|
|
|
12059
12357
|
mainCameraCalibration: isSet(object.mainCameraCalibration)
|
|
12060
12358
|
? CameraCalibration.fromJSON(object.mainCameraCalibration)
|
|
12061
12359
|
: undefined,
|
|
12360
|
+
diveNumber: isSet(object.diveNumber) ? gt.Number(object.diveNumber) : 0,
|
|
12361
|
+
logName: isSet(object.logName) ? gt.String(object.logName) : "",
|
|
12062
12362
|
};
|
|
12063
12363
|
},
|
|
12064
12364
|
toJSON(message) {
|
|
@@ -12105,6 +12405,12 @@ export const DroneInfo = {
|
|
|
12105
12405
|
if (message.mainCameraCalibration !== undefined) {
|
|
12106
12406
|
obj.mainCameraCalibration = CameraCalibration.toJSON(message.mainCameraCalibration);
|
|
12107
12407
|
}
|
|
12408
|
+
if (message.diveNumber !== 0) {
|
|
12409
|
+
obj.diveNumber = Math.round(message.diveNumber);
|
|
12410
|
+
}
|
|
12411
|
+
if (message.logName !== "") {
|
|
12412
|
+
obj.logName = message.logName;
|
|
12413
|
+
}
|
|
12108
12414
|
return obj;
|
|
12109
12415
|
},
|
|
12110
12416
|
create(base) {
|
|
@@ -12129,6 +12435,8 @@ export const DroneInfo = {
|
|
|
12129
12435
|
(object.mainCameraCalibration !== undefined && object.mainCameraCalibration !== null)
|
|
12130
12436
|
? CameraCalibration.fromPartial(object.mainCameraCalibration)
|
|
12131
12437
|
: undefined;
|
|
12438
|
+
message.diveNumber = object.diveNumber ?? 0;
|
|
12439
|
+
message.logName = object.logName ?? "";
|
|
12132
12440
|
return message;
|
|
12133
12441
|
},
|
|
12134
12442
|
};
|
|
@@ -19935,7 +20243,7 @@ export const ObjectDetection = {
|
|
|
19935
20243
|
},
|
|
19936
20244
|
};
|
|
19937
20245
|
function createBaseModelDetections() {
|
|
19938
|
-
return { detections: [], camera: 0, imageWidth: 0, imageHeight: 0, modelName: "" };
|
|
20246
|
+
return { detections: [], camera: 0, imageWidth: 0, imageHeight: 0, modelName: "", frameId: 0 };
|
|
19939
20247
|
}
|
|
19940
20248
|
export const ModelDetections = {
|
|
19941
20249
|
encode(message, writer = new BinaryWriter()) {
|
|
@@ -19954,6 +20262,9 @@ export const ModelDetections = {
|
|
|
19954
20262
|
if (message.modelName !== "") {
|
|
19955
20263
|
writer.uint32(42).string(message.modelName);
|
|
19956
20264
|
}
|
|
20265
|
+
if (message.frameId !== 0) {
|
|
20266
|
+
writer.uint32(48).uint64(message.frameId);
|
|
20267
|
+
}
|
|
19957
20268
|
return writer;
|
|
19958
20269
|
},
|
|
19959
20270
|
decode(input, length) {
|
|
@@ -19998,6 +20309,13 @@ export const ModelDetections = {
|
|
|
19998
20309
|
message.modelName = reader.string();
|
|
19999
20310
|
continue;
|
|
20000
20311
|
}
|
|
20312
|
+
case 6: {
|
|
20313
|
+
if (tag !== 48) {
|
|
20314
|
+
break;
|
|
20315
|
+
}
|
|
20316
|
+
message.frameId = longToNumber(reader.uint64());
|
|
20317
|
+
continue;
|
|
20318
|
+
}
|
|
20001
20319
|
}
|
|
20002
20320
|
if ((tag & 7) === 4 || tag === 0) {
|
|
20003
20321
|
break;
|
|
@@ -20015,6 +20333,7 @@ export const ModelDetections = {
|
|
|
20015
20333
|
imageWidth: isSet(object.imageWidth) ? gt.Number(object.imageWidth) : 0,
|
|
20016
20334
|
imageHeight: isSet(object.imageHeight) ? gt.Number(object.imageHeight) : 0,
|
|
20017
20335
|
modelName: isSet(object.modelName) ? gt.String(object.modelName) : "",
|
|
20336
|
+
frameId: isSet(object.frameId) ? gt.Number(object.frameId) : 0,
|
|
20018
20337
|
};
|
|
20019
20338
|
},
|
|
20020
20339
|
toJSON(message) {
|
|
@@ -20034,6 +20353,9 @@ export const ModelDetections = {
|
|
|
20034
20353
|
if (message.modelName !== "") {
|
|
20035
20354
|
obj.modelName = message.modelName;
|
|
20036
20355
|
}
|
|
20356
|
+
if (message.frameId !== 0) {
|
|
20357
|
+
obj.frameId = Math.round(message.frameId);
|
|
20358
|
+
}
|
|
20037
20359
|
return obj;
|
|
20038
20360
|
},
|
|
20039
20361
|
create(base) {
|
|
@@ -20046,6 +20368,7 @@ export const ModelDetections = {
|
|
|
20046
20368
|
message.imageWidth = object.imageWidth ?? 0;
|
|
20047
20369
|
message.imageHeight = object.imageHeight ?? 0;
|
|
20048
20370
|
message.modelName = object.modelName ?? "";
|
|
20371
|
+
message.frameId = object.frameId ?? 0;
|
|
20049
20372
|
return message;
|
|
20050
20373
|
},
|
|
20051
20374
|
};
|
|
@@ -20337,7 +20660,18 @@ export const OperatorInfo = {
|
|
|
20337
20660
|
},
|
|
20338
20661
|
};
|
|
20339
20662
|
function createBaseSotState() {
|
|
20340
|
-
return {
|
|
20663
|
+
return {
|
|
20664
|
+
state: 0,
|
|
20665
|
+
boundingBox: undefined,
|
|
20666
|
+
imageWidth: 0,
|
|
20667
|
+
imageHeight: 0,
|
|
20668
|
+
confidence: 0,
|
|
20669
|
+
vx: 0,
|
|
20670
|
+
vy: 0,
|
|
20671
|
+
vs: 0,
|
|
20672
|
+
vr: 0,
|
|
20673
|
+
frameId: 0,
|
|
20674
|
+
};
|
|
20341
20675
|
}
|
|
20342
20676
|
export const SotState = {
|
|
20343
20677
|
encode(message, writer = new BinaryWriter()) {
|
|
@@ -20368,6 +20702,9 @@ export const SotState = {
|
|
|
20368
20702
|
if (message.vr !== 0) {
|
|
20369
20703
|
writer.uint32(77).float(message.vr);
|
|
20370
20704
|
}
|
|
20705
|
+
if (message.frameId !== 0) {
|
|
20706
|
+
writer.uint32(80).uint64(message.frameId);
|
|
20707
|
+
}
|
|
20371
20708
|
return writer;
|
|
20372
20709
|
},
|
|
20373
20710
|
decode(input, length) {
|
|
@@ -20440,6 +20777,13 @@ export const SotState = {
|
|
|
20440
20777
|
message.vr = reader.float();
|
|
20441
20778
|
continue;
|
|
20442
20779
|
}
|
|
20780
|
+
case 10: {
|
|
20781
|
+
if (tag !== 80) {
|
|
20782
|
+
break;
|
|
20783
|
+
}
|
|
20784
|
+
message.frameId = longToNumber(reader.uint64());
|
|
20785
|
+
continue;
|
|
20786
|
+
}
|
|
20443
20787
|
}
|
|
20444
20788
|
if ((tag & 7) === 4 || tag === 0) {
|
|
20445
20789
|
break;
|
|
@@ -20459,6 +20803,7 @@ export const SotState = {
|
|
|
20459
20803
|
vy: isSet(object.vy) ? gt.Number(object.vy) : 0,
|
|
20460
20804
|
vs: isSet(object.vs) ? gt.Number(object.vs) : 0,
|
|
20461
20805
|
vr: isSet(object.vr) ? gt.Number(object.vr) : 0,
|
|
20806
|
+
frameId: isSet(object.frameId) ? gt.Number(object.frameId) : 0,
|
|
20462
20807
|
};
|
|
20463
20808
|
},
|
|
20464
20809
|
toJSON(message) {
|
|
@@ -20490,6 +20835,9 @@ export const SotState = {
|
|
|
20490
20835
|
if (message.vr !== 0) {
|
|
20491
20836
|
obj.vr = message.vr;
|
|
20492
20837
|
}
|
|
20838
|
+
if (message.frameId !== 0) {
|
|
20839
|
+
obj.frameId = Math.round(message.frameId);
|
|
20840
|
+
}
|
|
20493
20841
|
return obj;
|
|
20494
20842
|
},
|
|
20495
20843
|
create(base) {
|
|
@@ -20508,6 +20856,7 @@ export const SotState = {
|
|
|
20508
20856
|
message.vy = object.vy ?? 0;
|
|
20509
20857
|
message.vs = object.vs ?? 0;
|
|
20510
20858
|
message.vr = object.vr ?? 0;
|
|
20859
|
+
message.frameId = object.frameId ?? 0;
|
|
20511
20860
|
return message;
|
|
20512
20861
|
},
|
|
20513
20862
|
};
|
|
@@ -20680,6 +21029,1699 @@ export const Annotation = {
|
|
|
20680
21029
|
return message;
|
|
20681
21030
|
},
|
|
20682
21031
|
};
|
|
21032
|
+
function createBaseQuaternion() {
|
|
21033
|
+
return { x: 0, y: 0, z: 0, w: 0 };
|
|
21034
|
+
}
|
|
21035
|
+
export const Quaternion = {
|
|
21036
|
+
encode(message, writer = new BinaryWriter()) {
|
|
21037
|
+
if (message.x !== 0) {
|
|
21038
|
+
writer.uint32(9).double(message.x);
|
|
21039
|
+
}
|
|
21040
|
+
if (message.y !== 0) {
|
|
21041
|
+
writer.uint32(17).double(message.y);
|
|
21042
|
+
}
|
|
21043
|
+
if (message.z !== 0) {
|
|
21044
|
+
writer.uint32(25).double(message.z);
|
|
21045
|
+
}
|
|
21046
|
+
if (message.w !== 0) {
|
|
21047
|
+
writer.uint32(33).double(message.w);
|
|
21048
|
+
}
|
|
21049
|
+
return writer;
|
|
21050
|
+
},
|
|
21051
|
+
decode(input, length) {
|
|
21052
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
21053
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
21054
|
+
const message = createBaseQuaternion();
|
|
21055
|
+
while (reader.pos < end) {
|
|
21056
|
+
const tag = reader.uint32();
|
|
21057
|
+
switch (tag >>> 3) {
|
|
21058
|
+
case 1: {
|
|
21059
|
+
if (tag !== 9) {
|
|
21060
|
+
break;
|
|
21061
|
+
}
|
|
21062
|
+
message.x = reader.double();
|
|
21063
|
+
continue;
|
|
21064
|
+
}
|
|
21065
|
+
case 2: {
|
|
21066
|
+
if (tag !== 17) {
|
|
21067
|
+
break;
|
|
21068
|
+
}
|
|
21069
|
+
message.y = reader.double();
|
|
21070
|
+
continue;
|
|
21071
|
+
}
|
|
21072
|
+
case 3: {
|
|
21073
|
+
if (tag !== 25) {
|
|
21074
|
+
break;
|
|
21075
|
+
}
|
|
21076
|
+
message.z = reader.double();
|
|
21077
|
+
continue;
|
|
21078
|
+
}
|
|
21079
|
+
case 4: {
|
|
21080
|
+
if (tag !== 33) {
|
|
21081
|
+
break;
|
|
21082
|
+
}
|
|
21083
|
+
message.w = reader.double();
|
|
21084
|
+
continue;
|
|
21085
|
+
}
|
|
21086
|
+
}
|
|
21087
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
21088
|
+
break;
|
|
21089
|
+
}
|
|
21090
|
+
reader.skip(tag & 7);
|
|
21091
|
+
}
|
|
21092
|
+
return message;
|
|
21093
|
+
},
|
|
21094
|
+
fromJSON(object) {
|
|
21095
|
+
return {
|
|
21096
|
+
x: isSet(object.x) ? gt.Number(object.x) : 0,
|
|
21097
|
+
y: isSet(object.y) ? gt.Number(object.y) : 0,
|
|
21098
|
+
z: isSet(object.z) ? gt.Number(object.z) : 0,
|
|
21099
|
+
w: isSet(object.w) ? gt.Number(object.w) : 0,
|
|
21100
|
+
};
|
|
21101
|
+
},
|
|
21102
|
+
toJSON(message) {
|
|
21103
|
+
const obj = {};
|
|
21104
|
+
if (message.x !== 0) {
|
|
21105
|
+
obj.x = message.x;
|
|
21106
|
+
}
|
|
21107
|
+
if (message.y !== 0) {
|
|
21108
|
+
obj.y = message.y;
|
|
21109
|
+
}
|
|
21110
|
+
if (message.z !== 0) {
|
|
21111
|
+
obj.z = message.z;
|
|
21112
|
+
}
|
|
21113
|
+
if (message.w !== 0) {
|
|
21114
|
+
obj.w = message.w;
|
|
21115
|
+
}
|
|
21116
|
+
return obj;
|
|
21117
|
+
},
|
|
21118
|
+
create(base) {
|
|
21119
|
+
return Quaternion.fromPartial(base ?? {});
|
|
21120
|
+
},
|
|
21121
|
+
fromPartial(object) {
|
|
21122
|
+
const message = createBaseQuaternion();
|
|
21123
|
+
message.x = object.x ?? 0;
|
|
21124
|
+
message.y = object.y ?? 0;
|
|
21125
|
+
message.z = object.z ?? 0;
|
|
21126
|
+
message.w = object.w ?? 0;
|
|
21127
|
+
return message;
|
|
21128
|
+
},
|
|
21129
|
+
};
|
|
21130
|
+
function createBasePointCloud() {
|
|
21131
|
+
return { count: 0, positions: new Uint8Array(0), intensities: new Uint8Array(0) };
|
|
21132
|
+
}
|
|
21133
|
+
export const PointCloud = {
|
|
21134
|
+
encode(message, writer = new BinaryWriter()) {
|
|
21135
|
+
if (message.count !== 0) {
|
|
21136
|
+
writer.uint32(8).uint32(message.count);
|
|
21137
|
+
}
|
|
21138
|
+
if (message.positions.length !== 0) {
|
|
21139
|
+
writer.uint32(18).bytes(message.positions);
|
|
21140
|
+
}
|
|
21141
|
+
if (message.intensities.length !== 0) {
|
|
21142
|
+
writer.uint32(26).bytes(message.intensities);
|
|
21143
|
+
}
|
|
21144
|
+
return writer;
|
|
21145
|
+
},
|
|
21146
|
+
decode(input, length) {
|
|
21147
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
21148
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
21149
|
+
const message = createBasePointCloud();
|
|
21150
|
+
while (reader.pos < end) {
|
|
21151
|
+
const tag = reader.uint32();
|
|
21152
|
+
switch (tag >>> 3) {
|
|
21153
|
+
case 1: {
|
|
21154
|
+
if (tag !== 8) {
|
|
21155
|
+
break;
|
|
21156
|
+
}
|
|
21157
|
+
message.count = reader.uint32();
|
|
21158
|
+
continue;
|
|
21159
|
+
}
|
|
21160
|
+
case 2: {
|
|
21161
|
+
if (tag !== 18) {
|
|
21162
|
+
break;
|
|
21163
|
+
}
|
|
21164
|
+
message.positions = reader.bytes();
|
|
21165
|
+
continue;
|
|
21166
|
+
}
|
|
21167
|
+
case 3: {
|
|
21168
|
+
if (tag !== 26) {
|
|
21169
|
+
break;
|
|
21170
|
+
}
|
|
21171
|
+
message.intensities = reader.bytes();
|
|
21172
|
+
continue;
|
|
21173
|
+
}
|
|
21174
|
+
}
|
|
21175
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
21176
|
+
break;
|
|
21177
|
+
}
|
|
21178
|
+
reader.skip(tag & 7);
|
|
21179
|
+
}
|
|
21180
|
+
return message;
|
|
21181
|
+
},
|
|
21182
|
+
fromJSON(object) {
|
|
21183
|
+
return {
|
|
21184
|
+
count: isSet(object.count) ? gt.Number(object.count) : 0,
|
|
21185
|
+
positions: isSet(object.positions) ? bytesFromBase64(object.positions) : new Uint8Array(0),
|
|
21186
|
+
intensities: isSet(object.intensities) ? bytesFromBase64(object.intensities) : new Uint8Array(0),
|
|
21187
|
+
};
|
|
21188
|
+
},
|
|
21189
|
+
toJSON(message) {
|
|
21190
|
+
const obj = {};
|
|
21191
|
+
if (message.count !== 0) {
|
|
21192
|
+
obj.count = Math.round(message.count);
|
|
21193
|
+
}
|
|
21194
|
+
if (message.positions.length !== 0) {
|
|
21195
|
+
obj.positions = base64FromBytes(message.positions);
|
|
21196
|
+
}
|
|
21197
|
+
if (message.intensities.length !== 0) {
|
|
21198
|
+
obj.intensities = base64FromBytes(message.intensities);
|
|
21199
|
+
}
|
|
21200
|
+
return obj;
|
|
21201
|
+
},
|
|
21202
|
+
create(base) {
|
|
21203
|
+
return PointCloud.fromPartial(base ?? {});
|
|
21204
|
+
},
|
|
21205
|
+
fromPartial(object) {
|
|
21206
|
+
const message = createBasePointCloud();
|
|
21207
|
+
message.count = object.count ?? 0;
|
|
21208
|
+
message.positions = object.positions ?? new Uint8Array(0);
|
|
21209
|
+
message.intensities = object.intensities ?? new Uint8Array(0);
|
|
21210
|
+
return message;
|
|
21211
|
+
},
|
|
21212
|
+
};
|
|
21213
|
+
function createBaseSlamSensor() {
|
|
21214
|
+
return { id: "", type: 0, fovHorizontal: 0, fovVertical: 0, maxRange: 0 };
|
|
21215
|
+
}
|
|
21216
|
+
export const SlamSensor = {
|
|
21217
|
+
encode(message, writer = new BinaryWriter()) {
|
|
21218
|
+
if (message.id !== "") {
|
|
21219
|
+
writer.uint32(10).string(message.id);
|
|
21220
|
+
}
|
|
21221
|
+
if (message.type !== 0) {
|
|
21222
|
+
writer.uint32(16).int32(message.type);
|
|
21223
|
+
}
|
|
21224
|
+
if (message.fovHorizontal !== 0) {
|
|
21225
|
+
writer.uint32(29).float(message.fovHorizontal);
|
|
21226
|
+
}
|
|
21227
|
+
if (message.fovVertical !== 0) {
|
|
21228
|
+
writer.uint32(37).float(message.fovVertical);
|
|
21229
|
+
}
|
|
21230
|
+
if (message.maxRange !== 0) {
|
|
21231
|
+
writer.uint32(45).float(message.maxRange);
|
|
21232
|
+
}
|
|
21233
|
+
return writer;
|
|
21234
|
+
},
|
|
21235
|
+
decode(input, length) {
|
|
21236
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
21237
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
21238
|
+
const message = createBaseSlamSensor();
|
|
21239
|
+
while (reader.pos < end) {
|
|
21240
|
+
const tag = reader.uint32();
|
|
21241
|
+
switch (tag >>> 3) {
|
|
21242
|
+
case 1: {
|
|
21243
|
+
if (tag !== 10) {
|
|
21244
|
+
break;
|
|
21245
|
+
}
|
|
21246
|
+
message.id = reader.string();
|
|
21247
|
+
continue;
|
|
21248
|
+
}
|
|
21249
|
+
case 2: {
|
|
21250
|
+
if (tag !== 16) {
|
|
21251
|
+
break;
|
|
21252
|
+
}
|
|
21253
|
+
message.type = reader.int32();
|
|
21254
|
+
continue;
|
|
21255
|
+
}
|
|
21256
|
+
case 3: {
|
|
21257
|
+
if (tag !== 29) {
|
|
21258
|
+
break;
|
|
21259
|
+
}
|
|
21260
|
+
message.fovHorizontal = reader.float();
|
|
21261
|
+
continue;
|
|
21262
|
+
}
|
|
21263
|
+
case 4: {
|
|
21264
|
+
if (tag !== 37) {
|
|
21265
|
+
break;
|
|
21266
|
+
}
|
|
21267
|
+
message.fovVertical = reader.float();
|
|
21268
|
+
continue;
|
|
21269
|
+
}
|
|
21270
|
+
case 5: {
|
|
21271
|
+
if (tag !== 45) {
|
|
21272
|
+
break;
|
|
21273
|
+
}
|
|
21274
|
+
message.maxRange = reader.float();
|
|
21275
|
+
continue;
|
|
21276
|
+
}
|
|
21277
|
+
}
|
|
21278
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
21279
|
+
break;
|
|
21280
|
+
}
|
|
21281
|
+
reader.skip(tag & 7);
|
|
21282
|
+
}
|
|
21283
|
+
return message;
|
|
21284
|
+
},
|
|
21285
|
+
fromJSON(object) {
|
|
21286
|
+
return {
|
|
21287
|
+
id: isSet(object.id) ? gt.String(object.id) : "",
|
|
21288
|
+
type: isSet(object.type) ? slamSensorTypeFromJSON(object.type) : 0,
|
|
21289
|
+
fovHorizontal: isSet(object.fovHorizontal) ? gt.Number(object.fovHorizontal) : 0,
|
|
21290
|
+
fovVertical: isSet(object.fovVertical) ? gt.Number(object.fovVertical) : 0,
|
|
21291
|
+
maxRange: isSet(object.maxRange) ? gt.Number(object.maxRange) : 0,
|
|
21292
|
+
};
|
|
21293
|
+
},
|
|
21294
|
+
toJSON(message) {
|
|
21295
|
+
const obj = {};
|
|
21296
|
+
if (message.id !== "") {
|
|
21297
|
+
obj.id = message.id;
|
|
21298
|
+
}
|
|
21299
|
+
if (message.type !== 0) {
|
|
21300
|
+
obj.type = slamSensorTypeToJSON(message.type);
|
|
21301
|
+
}
|
|
21302
|
+
if (message.fovHorizontal !== 0) {
|
|
21303
|
+
obj.fovHorizontal = message.fovHorizontal;
|
|
21304
|
+
}
|
|
21305
|
+
if (message.fovVertical !== 0) {
|
|
21306
|
+
obj.fovVertical = message.fovVertical;
|
|
21307
|
+
}
|
|
21308
|
+
if (message.maxRange !== 0) {
|
|
21309
|
+
obj.maxRange = message.maxRange;
|
|
21310
|
+
}
|
|
21311
|
+
return obj;
|
|
21312
|
+
},
|
|
21313
|
+
create(base) {
|
|
21314
|
+
return SlamSensor.fromPartial(base ?? {});
|
|
21315
|
+
},
|
|
21316
|
+
fromPartial(object) {
|
|
21317
|
+
const message = createBaseSlamSensor();
|
|
21318
|
+
message.id = object.id ?? "";
|
|
21319
|
+
message.type = object.type ?? 0;
|
|
21320
|
+
message.fovHorizontal = object.fovHorizontal ?? 0;
|
|
21321
|
+
message.fovVertical = object.fovVertical ?? 0;
|
|
21322
|
+
message.maxRange = object.maxRange ?? 0;
|
|
21323
|
+
return message;
|
|
21324
|
+
},
|
|
21325
|
+
};
|
|
21326
|
+
function createBaseSlamRecordingState() {
|
|
21327
|
+
return { isRecording: false, name: "", seconds: 0, size: 0, sensorData: false, storageLocation: 0 };
|
|
21328
|
+
}
|
|
21329
|
+
export const SlamRecordingState = {
|
|
21330
|
+
encode(message, writer = new BinaryWriter()) {
|
|
21331
|
+
if (message.isRecording !== false) {
|
|
21332
|
+
writer.uint32(8).bool(message.isRecording);
|
|
21333
|
+
}
|
|
21334
|
+
if (message.name !== "") {
|
|
21335
|
+
writer.uint32(18).string(message.name);
|
|
21336
|
+
}
|
|
21337
|
+
if (message.seconds !== 0) {
|
|
21338
|
+
writer.uint32(24).int32(message.seconds);
|
|
21339
|
+
}
|
|
21340
|
+
if (message.size !== 0) {
|
|
21341
|
+
writer.uint32(32).uint64(message.size);
|
|
21342
|
+
}
|
|
21343
|
+
if (message.sensorData !== false) {
|
|
21344
|
+
writer.uint32(40).bool(message.sensorData);
|
|
21345
|
+
}
|
|
21346
|
+
if (message.storageLocation !== 0) {
|
|
21347
|
+
writer.uint32(48).int32(message.storageLocation);
|
|
21348
|
+
}
|
|
21349
|
+
return writer;
|
|
21350
|
+
},
|
|
21351
|
+
decode(input, length) {
|
|
21352
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
21353
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
21354
|
+
const message = createBaseSlamRecordingState();
|
|
21355
|
+
while (reader.pos < end) {
|
|
21356
|
+
const tag = reader.uint32();
|
|
21357
|
+
switch (tag >>> 3) {
|
|
21358
|
+
case 1: {
|
|
21359
|
+
if (tag !== 8) {
|
|
21360
|
+
break;
|
|
21361
|
+
}
|
|
21362
|
+
message.isRecording = reader.bool();
|
|
21363
|
+
continue;
|
|
21364
|
+
}
|
|
21365
|
+
case 2: {
|
|
21366
|
+
if (tag !== 18) {
|
|
21367
|
+
break;
|
|
21368
|
+
}
|
|
21369
|
+
message.name = reader.string();
|
|
21370
|
+
continue;
|
|
21371
|
+
}
|
|
21372
|
+
case 3: {
|
|
21373
|
+
if (tag !== 24) {
|
|
21374
|
+
break;
|
|
21375
|
+
}
|
|
21376
|
+
message.seconds = reader.int32();
|
|
21377
|
+
continue;
|
|
21378
|
+
}
|
|
21379
|
+
case 4: {
|
|
21380
|
+
if (tag !== 32) {
|
|
21381
|
+
break;
|
|
21382
|
+
}
|
|
21383
|
+
message.size = longToNumber(reader.uint64());
|
|
21384
|
+
continue;
|
|
21385
|
+
}
|
|
21386
|
+
case 5: {
|
|
21387
|
+
if (tag !== 40) {
|
|
21388
|
+
break;
|
|
21389
|
+
}
|
|
21390
|
+
message.sensorData = reader.bool();
|
|
21391
|
+
continue;
|
|
21392
|
+
}
|
|
21393
|
+
case 6: {
|
|
21394
|
+
if (tag !== 48) {
|
|
21395
|
+
break;
|
|
21396
|
+
}
|
|
21397
|
+
message.storageLocation = reader.int32();
|
|
21398
|
+
continue;
|
|
21399
|
+
}
|
|
21400
|
+
}
|
|
21401
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
21402
|
+
break;
|
|
21403
|
+
}
|
|
21404
|
+
reader.skip(tag & 7);
|
|
21405
|
+
}
|
|
21406
|
+
return message;
|
|
21407
|
+
},
|
|
21408
|
+
fromJSON(object) {
|
|
21409
|
+
return {
|
|
21410
|
+
isRecording: isSet(object.isRecording) ? gt.Boolean(object.isRecording) : false,
|
|
21411
|
+
name: isSet(object.name) ? gt.String(object.name) : "",
|
|
21412
|
+
seconds: isSet(object.seconds) ? gt.Number(object.seconds) : 0,
|
|
21413
|
+
size: isSet(object.size) ? gt.Number(object.size) : 0,
|
|
21414
|
+
sensorData: isSet(object.sensorData) ? gt.Boolean(object.sensorData) : false,
|
|
21415
|
+
storageLocation: isSet(object.storageLocation) ? storageLocationFromJSON(object.storageLocation) : 0,
|
|
21416
|
+
};
|
|
21417
|
+
},
|
|
21418
|
+
toJSON(message) {
|
|
21419
|
+
const obj = {};
|
|
21420
|
+
if (message.isRecording !== false) {
|
|
21421
|
+
obj.isRecording = message.isRecording;
|
|
21422
|
+
}
|
|
21423
|
+
if (message.name !== "") {
|
|
21424
|
+
obj.name = message.name;
|
|
21425
|
+
}
|
|
21426
|
+
if (message.seconds !== 0) {
|
|
21427
|
+
obj.seconds = Math.round(message.seconds);
|
|
21428
|
+
}
|
|
21429
|
+
if (message.size !== 0) {
|
|
21430
|
+
obj.size = Math.round(message.size);
|
|
21431
|
+
}
|
|
21432
|
+
if (message.sensorData !== false) {
|
|
21433
|
+
obj.sensorData = message.sensorData;
|
|
21434
|
+
}
|
|
21435
|
+
if (message.storageLocation !== 0) {
|
|
21436
|
+
obj.storageLocation = storageLocationToJSON(message.storageLocation);
|
|
21437
|
+
}
|
|
21438
|
+
return obj;
|
|
21439
|
+
},
|
|
21440
|
+
create(base) {
|
|
21441
|
+
return SlamRecordingState.fromPartial(base ?? {});
|
|
21442
|
+
},
|
|
21443
|
+
fromPartial(object) {
|
|
21444
|
+
const message = createBaseSlamRecordingState();
|
|
21445
|
+
message.isRecording = object.isRecording ?? false;
|
|
21446
|
+
message.name = object.name ?? "";
|
|
21447
|
+
message.seconds = object.seconds ?? 0;
|
|
21448
|
+
message.size = object.size ?? 0;
|
|
21449
|
+
message.sensorData = object.sensorData ?? false;
|
|
21450
|
+
message.storageLocation = object.storageLocation ?? 0;
|
|
21451
|
+
return message;
|
|
21452
|
+
},
|
|
21453
|
+
};
|
|
21454
|
+
function createBaseSlamSonar3dSettings() {
|
|
21455
|
+
return { frequencyMode: 0, maxRange: 0 };
|
|
21456
|
+
}
|
|
21457
|
+
export const SlamSonar3dSettings = {
|
|
21458
|
+
encode(message, writer = new BinaryWriter()) {
|
|
21459
|
+
if (message.frequencyMode !== 0) {
|
|
21460
|
+
writer.uint32(8).int32(message.frequencyMode);
|
|
21461
|
+
}
|
|
21462
|
+
if (message.maxRange !== 0) {
|
|
21463
|
+
writer.uint32(21).float(message.maxRange);
|
|
21464
|
+
}
|
|
21465
|
+
return writer;
|
|
21466
|
+
},
|
|
21467
|
+
decode(input, length) {
|
|
21468
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
21469
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
21470
|
+
const message = createBaseSlamSonar3dSettings();
|
|
21471
|
+
while (reader.pos < end) {
|
|
21472
|
+
const tag = reader.uint32();
|
|
21473
|
+
switch (tag >>> 3) {
|
|
21474
|
+
case 1: {
|
|
21475
|
+
if (tag !== 8) {
|
|
21476
|
+
break;
|
|
21477
|
+
}
|
|
21478
|
+
message.frequencyMode = reader.int32();
|
|
21479
|
+
continue;
|
|
21480
|
+
}
|
|
21481
|
+
case 2: {
|
|
21482
|
+
if (tag !== 21) {
|
|
21483
|
+
break;
|
|
21484
|
+
}
|
|
21485
|
+
message.maxRange = reader.float();
|
|
21486
|
+
continue;
|
|
21487
|
+
}
|
|
21488
|
+
}
|
|
21489
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
21490
|
+
break;
|
|
21491
|
+
}
|
|
21492
|
+
reader.skip(tag & 7);
|
|
21493
|
+
}
|
|
21494
|
+
return message;
|
|
21495
|
+
},
|
|
21496
|
+
fromJSON(object) {
|
|
21497
|
+
return {
|
|
21498
|
+
frequencyMode: isSet(object.frequencyMode) ? sonar3dFrequencyModeFromJSON(object.frequencyMode) : 0,
|
|
21499
|
+
maxRange: isSet(object.maxRange) ? gt.Number(object.maxRange) : 0,
|
|
21500
|
+
};
|
|
21501
|
+
},
|
|
21502
|
+
toJSON(message) {
|
|
21503
|
+
const obj = {};
|
|
21504
|
+
if (message.frequencyMode !== 0) {
|
|
21505
|
+
obj.frequencyMode = sonar3dFrequencyModeToJSON(message.frequencyMode);
|
|
21506
|
+
}
|
|
21507
|
+
if (message.maxRange !== 0) {
|
|
21508
|
+
obj.maxRange = message.maxRange;
|
|
21509
|
+
}
|
|
21510
|
+
return obj;
|
|
21511
|
+
},
|
|
21512
|
+
create(base) {
|
|
21513
|
+
return SlamSonar3dSettings.fromPartial(base ?? {});
|
|
21514
|
+
},
|
|
21515
|
+
fromPartial(object) {
|
|
21516
|
+
const message = createBaseSlamSonar3dSettings();
|
|
21517
|
+
message.frequencyMode = object.frequencyMode ?? 0;
|
|
21518
|
+
message.maxRange = object.maxRange ?? 0;
|
|
21519
|
+
return message;
|
|
21520
|
+
},
|
|
21521
|
+
};
|
|
21522
|
+
function createBaseSlamSensorSettings() {
|
|
21523
|
+
return { sonar3d: undefined };
|
|
21524
|
+
}
|
|
21525
|
+
export const SlamSensorSettings = {
|
|
21526
|
+
encode(message, writer = new BinaryWriter()) {
|
|
21527
|
+
if (message.sonar3d !== undefined) {
|
|
21528
|
+
SlamSonar3dSettings.encode(message.sonar3d, writer.uint32(10).fork()).join();
|
|
21529
|
+
}
|
|
21530
|
+
return writer;
|
|
21531
|
+
},
|
|
21532
|
+
decode(input, length) {
|
|
21533
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
21534
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
21535
|
+
const message = createBaseSlamSensorSettings();
|
|
21536
|
+
while (reader.pos < end) {
|
|
21537
|
+
const tag = reader.uint32();
|
|
21538
|
+
switch (tag >>> 3) {
|
|
21539
|
+
case 1: {
|
|
21540
|
+
if (tag !== 10) {
|
|
21541
|
+
break;
|
|
21542
|
+
}
|
|
21543
|
+
message.sonar3d = SlamSonar3dSettings.decode(reader, reader.uint32());
|
|
21544
|
+
continue;
|
|
21545
|
+
}
|
|
21546
|
+
}
|
|
21547
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
21548
|
+
break;
|
|
21549
|
+
}
|
|
21550
|
+
reader.skip(tag & 7);
|
|
21551
|
+
}
|
|
21552
|
+
return message;
|
|
21553
|
+
},
|
|
21554
|
+
fromJSON(object) {
|
|
21555
|
+
return { sonar3d: isSet(object.sonar3d) ? SlamSonar3dSettings.fromJSON(object.sonar3d) : undefined };
|
|
21556
|
+
},
|
|
21557
|
+
toJSON(message) {
|
|
21558
|
+
const obj = {};
|
|
21559
|
+
if (message.sonar3d !== undefined) {
|
|
21560
|
+
obj.sonar3d = SlamSonar3dSettings.toJSON(message.sonar3d);
|
|
21561
|
+
}
|
|
21562
|
+
return obj;
|
|
21563
|
+
},
|
|
21564
|
+
create(base) {
|
|
21565
|
+
return SlamSensorSettings.fromPartial(base ?? {});
|
|
21566
|
+
},
|
|
21567
|
+
fromPartial(object) {
|
|
21568
|
+
const message = createBaseSlamSensorSettings();
|
|
21569
|
+
message.sonar3d = (object.sonar3d !== undefined && object.sonar3d !== null)
|
|
21570
|
+
? SlamSonar3dSettings.fromPartial(object.sonar3d)
|
|
21571
|
+
: undefined;
|
|
21572
|
+
return message;
|
|
21573
|
+
},
|
|
21574
|
+
};
|
|
21575
|
+
function createBaseSlamSensorStatus() {
|
|
21576
|
+
return { sensor: undefined, settings: undefined, mount: undefined, mountTilt: undefined };
|
|
21577
|
+
}
|
|
21578
|
+
export const SlamSensorStatus = {
|
|
21579
|
+
encode(message, writer = new BinaryWriter()) {
|
|
21580
|
+
if (message.sensor !== undefined) {
|
|
21581
|
+
SlamSensor.encode(message.sensor, writer.uint32(10).fork()).join();
|
|
21582
|
+
}
|
|
21583
|
+
if (message.settings !== undefined) {
|
|
21584
|
+
SlamSensorSettings.encode(message.settings, writer.uint32(18).fork()).join();
|
|
21585
|
+
}
|
|
21586
|
+
if (message.mount !== undefined) {
|
|
21587
|
+
SlamPose.encode(message.mount, writer.uint32(26).fork()).join();
|
|
21588
|
+
}
|
|
21589
|
+
if (message.mountTilt !== undefined) {
|
|
21590
|
+
writer.uint32(37).float(message.mountTilt);
|
|
21591
|
+
}
|
|
21592
|
+
return writer;
|
|
21593
|
+
},
|
|
21594
|
+
decode(input, length) {
|
|
21595
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
21596
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
21597
|
+
const message = createBaseSlamSensorStatus();
|
|
21598
|
+
while (reader.pos < end) {
|
|
21599
|
+
const tag = reader.uint32();
|
|
21600
|
+
switch (tag >>> 3) {
|
|
21601
|
+
case 1: {
|
|
21602
|
+
if (tag !== 10) {
|
|
21603
|
+
break;
|
|
21604
|
+
}
|
|
21605
|
+
message.sensor = SlamSensor.decode(reader, reader.uint32());
|
|
21606
|
+
continue;
|
|
21607
|
+
}
|
|
21608
|
+
case 2: {
|
|
21609
|
+
if (tag !== 18) {
|
|
21610
|
+
break;
|
|
21611
|
+
}
|
|
21612
|
+
message.settings = SlamSensorSettings.decode(reader, reader.uint32());
|
|
21613
|
+
continue;
|
|
21614
|
+
}
|
|
21615
|
+
case 3: {
|
|
21616
|
+
if (tag !== 26) {
|
|
21617
|
+
break;
|
|
21618
|
+
}
|
|
21619
|
+
message.mount = SlamPose.decode(reader, reader.uint32());
|
|
21620
|
+
continue;
|
|
21621
|
+
}
|
|
21622
|
+
case 4: {
|
|
21623
|
+
if (tag !== 37) {
|
|
21624
|
+
break;
|
|
21625
|
+
}
|
|
21626
|
+
message.mountTilt = reader.float();
|
|
21627
|
+
continue;
|
|
21628
|
+
}
|
|
21629
|
+
}
|
|
21630
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
21631
|
+
break;
|
|
21632
|
+
}
|
|
21633
|
+
reader.skip(tag & 7);
|
|
21634
|
+
}
|
|
21635
|
+
return message;
|
|
21636
|
+
},
|
|
21637
|
+
fromJSON(object) {
|
|
21638
|
+
return {
|
|
21639
|
+
sensor: isSet(object.sensor) ? SlamSensor.fromJSON(object.sensor) : undefined,
|
|
21640
|
+
settings: isSet(object.settings) ? SlamSensorSettings.fromJSON(object.settings) : undefined,
|
|
21641
|
+
mount: isSet(object.mount) ? SlamPose.fromJSON(object.mount) : undefined,
|
|
21642
|
+
mountTilt: isSet(object.mountTilt) ? gt.Number(object.mountTilt) : undefined,
|
|
21643
|
+
};
|
|
21644
|
+
},
|
|
21645
|
+
toJSON(message) {
|
|
21646
|
+
const obj = {};
|
|
21647
|
+
if (message.sensor !== undefined) {
|
|
21648
|
+
obj.sensor = SlamSensor.toJSON(message.sensor);
|
|
21649
|
+
}
|
|
21650
|
+
if (message.settings !== undefined) {
|
|
21651
|
+
obj.settings = SlamSensorSettings.toJSON(message.settings);
|
|
21652
|
+
}
|
|
21653
|
+
if (message.mount !== undefined) {
|
|
21654
|
+
obj.mount = SlamPose.toJSON(message.mount);
|
|
21655
|
+
}
|
|
21656
|
+
if (message.mountTilt !== undefined) {
|
|
21657
|
+
obj.mountTilt = message.mountTilt;
|
|
21658
|
+
}
|
|
21659
|
+
return obj;
|
|
21660
|
+
},
|
|
21661
|
+
create(base) {
|
|
21662
|
+
return SlamSensorStatus.fromPartial(base ?? {});
|
|
21663
|
+
},
|
|
21664
|
+
fromPartial(object) {
|
|
21665
|
+
const message = createBaseSlamSensorStatus();
|
|
21666
|
+
message.sensor = (object.sensor !== undefined && object.sensor !== null)
|
|
21667
|
+
? SlamSensor.fromPartial(object.sensor)
|
|
21668
|
+
: undefined;
|
|
21669
|
+
message.settings = (object.settings !== undefined && object.settings !== null)
|
|
21670
|
+
? SlamSensorSettings.fromPartial(object.settings)
|
|
21671
|
+
: undefined;
|
|
21672
|
+
message.mount = (object.mount !== undefined && object.mount !== null)
|
|
21673
|
+
? SlamPose.fromPartial(object.mount)
|
|
21674
|
+
: undefined;
|
|
21675
|
+
message.mountTilt = object.mountTilt ?? undefined;
|
|
21676
|
+
return message;
|
|
21677
|
+
},
|
|
21678
|
+
};
|
|
21679
|
+
function createBaseSlamPose() {
|
|
21680
|
+
return { position: undefined, orientation: undefined };
|
|
21681
|
+
}
|
|
21682
|
+
export const SlamPose = {
|
|
21683
|
+
encode(message, writer = new BinaryWriter()) {
|
|
21684
|
+
if (message.position !== undefined) {
|
|
21685
|
+
Vector3.encode(message.position, writer.uint32(10).fork()).join();
|
|
21686
|
+
}
|
|
21687
|
+
if (message.orientation !== undefined) {
|
|
21688
|
+
Quaternion.encode(message.orientation, writer.uint32(18).fork()).join();
|
|
21689
|
+
}
|
|
21690
|
+
return writer;
|
|
21691
|
+
},
|
|
21692
|
+
decode(input, length) {
|
|
21693
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
21694
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
21695
|
+
const message = createBaseSlamPose();
|
|
21696
|
+
while (reader.pos < end) {
|
|
21697
|
+
const tag = reader.uint32();
|
|
21698
|
+
switch (tag >>> 3) {
|
|
21699
|
+
case 1: {
|
|
21700
|
+
if (tag !== 10) {
|
|
21701
|
+
break;
|
|
21702
|
+
}
|
|
21703
|
+
message.position = Vector3.decode(reader, reader.uint32());
|
|
21704
|
+
continue;
|
|
21705
|
+
}
|
|
21706
|
+
case 2: {
|
|
21707
|
+
if (tag !== 18) {
|
|
21708
|
+
break;
|
|
21709
|
+
}
|
|
21710
|
+
message.orientation = Quaternion.decode(reader, reader.uint32());
|
|
21711
|
+
continue;
|
|
21712
|
+
}
|
|
21713
|
+
}
|
|
21714
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
21715
|
+
break;
|
|
21716
|
+
}
|
|
21717
|
+
reader.skip(tag & 7);
|
|
21718
|
+
}
|
|
21719
|
+
return message;
|
|
21720
|
+
},
|
|
21721
|
+
fromJSON(object) {
|
|
21722
|
+
return {
|
|
21723
|
+
position: isSet(object.position) ? Vector3.fromJSON(object.position) : undefined,
|
|
21724
|
+
orientation: isSet(object.orientation) ? Quaternion.fromJSON(object.orientation) : undefined,
|
|
21725
|
+
};
|
|
21726
|
+
},
|
|
21727
|
+
toJSON(message) {
|
|
21728
|
+
const obj = {};
|
|
21729
|
+
if (message.position !== undefined) {
|
|
21730
|
+
obj.position = Vector3.toJSON(message.position);
|
|
21731
|
+
}
|
|
21732
|
+
if (message.orientation !== undefined) {
|
|
21733
|
+
obj.orientation = Quaternion.toJSON(message.orientation);
|
|
21734
|
+
}
|
|
21735
|
+
return obj;
|
|
21736
|
+
},
|
|
21737
|
+
create(base) {
|
|
21738
|
+
return SlamPose.fromPartial(base ?? {});
|
|
21739
|
+
},
|
|
21740
|
+
fromPartial(object) {
|
|
21741
|
+
const message = createBaseSlamPose();
|
|
21742
|
+
message.position = (object.position !== undefined && object.position !== null)
|
|
21743
|
+
? Vector3.fromPartial(object.position)
|
|
21744
|
+
: undefined;
|
|
21745
|
+
message.orientation = (object.orientation !== undefined && object.orientation !== null)
|
|
21746
|
+
? Quaternion.fromPartial(object.orientation)
|
|
21747
|
+
: undefined;
|
|
21748
|
+
return message;
|
|
21749
|
+
},
|
|
21750
|
+
};
|
|
21751
|
+
function createBaseSlamPoseEstimate() {
|
|
21752
|
+
return {
|
|
21753
|
+
mapId: 0,
|
|
21754
|
+
state: 0,
|
|
21755
|
+
pose: undefined,
|
|
21756
|
+
time: undefined,
|
|
21757
|
+
scanPoints: 0,
|
|
21758
|
+
matchInlierRatio: 0,
|
|
21759
|
+
matchRms: 0,
|
|
21760
|
+
keyframeCount: 0,
|
|
21761
|
+
mapPointCount: 0,
|
|
21762
|
+
depth: undefined,
|
|
21763
|
+
sensorId: "",
|
|
21764
|
+
mount: undefined,
|
|
21765
|
+
covarianceElements: [],
|
|
21766
|
+
};
|
|
21767
|
+
}
|
|
21768
|
+
export const SlamPoseEstimate = {
|
|
21769
|
+
encode(message, writer = new BinaryWriter()) {
|
|
21770
|
+
if (message.mapId !== 0) {
|
|
21771
|
+
writer.uint32(8).uint32(message.mapId);
|
|
21772
|
+
}
|
|
21773
|
+
if (message.state !== 0) {
|
|
21774
|
+
writer.uint32(16).int32(message.state);
|
|
21775
|
+
}
|
|
21776
|
+
if (message.pose !== undefined) {
|
|
21777
|
+
SlamPose.encode(message.pose, writer.uint32(26).fork()).join();
|
|
21778
|
+
}
|
|
21779
|
+
if (message.time !== undefined) {
|
|
21780
|
+
Timestamp.encode(toTimestamp(message.time), writer.uint32(34).fork()).join();
|
|
21781
|
+
}
|
|
21782
|
+
if (message.scanPoints !== 0) {
|
|
21783
|
+
writer.uint32(40).uint32(message.scanPoints);
|
|
21784
|
+
}
|
|
21785
|
+
if (message.matchInlierRatio !== 0) {
|
|
21786
|
+
writer.uint32(53).float(message.matchInlierRatio);
|
|
21787
|
+
}
|
|
21788
|
+
if (message.matchRms !== 0) {
|
|
21789
|
+
writer.uint32(61).float(message.matchRms);
|
|
21790
|
+
}
|
|
21791
|
+
if (message.keyframeCount !== 0) {
|
|
21792
|
+
writer.uint32(64).uint32(message.keyframeCount);
|
|
21793
|
+
}
|
|
21794
|
+
if (message.mapPointCount !== 0) {
|
|
21795
|
+
writer.uint32(72).uint32(message.mapPointCount);
|
|
21796
|
+
}
|
|
21797
|
+
if (message.depth !== undefined) {
|
|
21798
|
+
writer.uint32(85).float(message.depth);
|
|
21799
|
+
}
|
|
21800
|
+
if (message.sensorId !== "") {
|
|
21801
|
+
writer.uint32(106).string(message.sensorId);
|
|
21802
|
+
}
|
|
21803
|
+
if (message.mount !== undefined) {
|
|
21804
|
+
SlamPose.encode(message.mount, writer.uint32(114).fork()).join();
|
|
21805
|
+
}
|
|
21806
|
+
writer.uint32(122).fork();
|
|
21807
|
+
for (const v of message.covarianceElements) {
|
|
21808
|
+
writer.float(v);
|
|
21809
|
+
}
|
|
21810
|
+
writer.join();
|
|
21811
|
+
return writer;
|
|
21812
|
+
},
|
|
21813
|
+
decode(input, length) {
|
|
21814
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
21815
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
21816
|
+
const message = createBaseSlamPoseEstimate();
|
|
21817
|
+
while (reader.pos < end) {
|
|
21818
|
+
const tag = reader.uint32();
|
|
21819
|
+
switch (tag >>> 3) {
|
|
21820
|
+
case 1: {
|
|
21821
|
+
if (tag !== 8) {
|
|
21822
|
+
break;
|
|
21823
|
+
}
|
|
21824
|
+
message.mapId = reader.uint32();
|
|
21825
|
+
continue;
|
|
21826
|
+
}
|
|
21827
|
+
case 2: {
|
|
21828
|
+
if (tag !== 16) {
|
|
21829
|
+
break;
|
|
21830
|
+
}
|
|
21831
|
+
message.state = reader.int32();
|
|
21832
|
+
continue;
|
|
21833
|
+
}
|
|
21834
|
+
case 3: {
|
|
21835
|
+
if (tag !== 26) {
|
|
21836
|
+
break;
|
|
21837
|
+
}
|
|
21838
|
+
message.pose = SlamPose.decode(reader, reader.uint32());
|
|
21839
|
+
continue;
|
|
21840
|
+
}
|
|
21841
|
+
case 4: {
|
|
21842
|
+
if (tag !== 34) {
|
|
21843
|
+
break;
|
|
21844
|
+
}
|
|
21845
|
+
message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
21846
|
+
continue;
|
|
21847
|
+
}
|
|
21848
|
+
case 5: {
|
|
21849
|
+
if (tag !== 40) {
|
|
21850
|
+
break;
|
|
21851
|
+
}
|
|
21852
|
+
message.scanPoints = reader.uint32();
|
|
21853
|
+
continue;
|
|
21854
|
+
}
|
|
21855
|
+
case 6: {
|
|
21856
|
+
if (tag !== 53) {
|
|
21857
|
+
break;
|
|
21858
|
+
}
|
|
21859
|
+
message.matchInlierRatio = reader.float();
|
|
21860
|
+
continue;
|
|
21861
|
+
}
|
|
21862
|
+
case 7: {
|
|
21863
|
+
if (tag !== 61) {
|
|
21864
|
+
break;
|
|
21865
|
+
}
|
|
21866
|
+
message.matchRms = reader.float();
|
|
21867
|
+
continue;
|
|
21868
|
+
}
|
|
21869
|
+
case 8: {
|
|
21870
|
+
if (tag !== 64) {
|
|
21871
|
+
break;
|
|
21872
|
+
}
|
|
21873
|
+
message.keyframeCount = reader.uint32();
|
|
21874
|
+
continue;
|
|
21875
|
+
}
|
|
21876
|
+
case 9: {
|
|
21877
|
+
if (tag !== 72) {
|
|
21878
|
+
break;
|
|
21879
|
+
}
|
|
21880
|
+
message.mapPointCount = reader.uint32();
|
|
21881
|
+
continue;
|
|
21882
|
+
}
|
|
21883
|
+
case 10: {
|
|
21884
|
+
if (tag !== 85) {
|
|
21885
|
+
break;
|
|
21886
|
+
}
|
|
21887
|
+
message.depth = reader.float();
|
|
21888
|
+
continue;
|
|
21889
|
+
}
|
|
21890
|
+
case 13: {
|
|
21891
|
+
if (tag !== 106) {
|
|
21892
|
+
break;
|
|
21893
|
+
}
|
|
21894
|
+
message.sensorId = reader.string();
|
|
21895
|
+
continue;
|
|
21896
|
+
}
|
|
21897
|
+
case 14: {
|
|
21898
|
+
if (tag !== 114) {
|
|
21899
|
+
break;
|
|
21900
|
+
}
|
|
21901
|
+
message.mount = SlamPose.decode(reader, reader.uint32());
|
|
21902
|
+
continue;
|
|
21903
|
+
}
|
|
21904
|
+
case 15: {
|
|
21905
|
+
if (tag === 125) {
|
|
21906
|
+
message.covarianceElements.push(reader.float());
|
|
21907
|
+
continue;
|
|
21908
|
+
}
|
|
21909
|
+
if (tag === 122) {
|
|
21910
|
+
const end2 = reader.uint32() + reader.pos;
|
|
21911
|
+
while (reader.pos < end2) {
|
|
21912
|
+
message.covarianceElements.push(reader.float());
|
|
21913
|
+
}
|
|
21914
|
+
continue;
|
|
21915
|
+
}
|
|
21916
|
+
break;
|
|
21917
|
+
}
|
|
21918
|
+
}
|
|
21919
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
21920
|
+
break;
|
|
21921
|
+
}
|
|
21922
|
+
reader.skip(tag & 7);
|
|
21923
|
+
}
|
|
21924
|
+
return message;
|
|
21925
|
+
},
|
|
21926
|
+
fromJSON(object) {
|
|
21927
|
+
return {
|
|
21928
|
+
mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0,
|
|
21929
|
+
state: isSet(object.state) ? slamStateFromJSON(object.state) : 0,
|
|
21930
|
+
pose: isSet(object.pose) ? SlamPose.fromJSON(object.pose) : undefined,
|
|
21931
|
+
time: isSet(object.time) ? fromJsonTimestamp(object.time) : undefined,
|
|
21932
|
+
scanPoints: isSet(object.scanPoints) ? gt.Number(object.scanPoints) : 0,
|
|
21933
|
+
matchInlierRatio: isSet(object.matchInlierRatio) ? gt.Number(object.matchInlierRatio) : 0,
|
|
21934
|
+
matchRms: isSet(object.matchRms) ? gt.Number(object.matchRms) : 0,
|
|
21935
|
+
keyframeCount: isSet(object.keyframeCount) ? gt.Number(object.keyframeCount) : 0,
|
|
21936
|
+
mapPointCount: isSet(object.mapPointCount) ? gt.Number(object.mapPointCount) : 0,
|
|
21937
|
+
depth: isSet(object.depth) ? gt.Number(object.depth) : undefined,
|
|
21938
|
+
sensorId: isSet(object.sensorId) ? gt.String(object.sensorId) : "",
|
|
21939
|
+
mount: isSet(object.mount) ? SlamPose.fromJSON(object.mount) : undefined,
|
|
21940
|
+
covarianceElements: gt.Array.isArray(object?.covarianceElements)
|
|
21941
|
+
? object.covarianceElements.map((e) => gt.Number(e))
|
|
21942
|
+
: [],
|
|
21943
|
+
};
|
|
21944
|
+
},
|
|
21945
|
+
toJSON(message) {
|
|
21946
|
+
const obj = {};
|
|
21947
|
+
if (message.mapId !== 0) {
|
|
21948
|
+
obj.mapId = Math.round(message.mapId);
|
|
21949
|
+
}
|
|
21950
|
+
if (message.state !== 0) {
|
|
21951
|
+
obj.state = slamStateToJSON(message.state);
|
|
21952
|
+
}
|
|
21953
|
+
if (message.pose !== undefined) {
|
|
21954
|
+
obj.pose = SlamPose.toJSON(message.pose);
|
|
21955
|
+
}
|
|
21956
|
+
if (message.time !== undefined) {
|
|
21957
|
+
obj.time = message.time.toISOString();
|
|
21958
|
+
}
|
|
21959
|
+
if (message.scanPoints !== 0) {
|
|
21960
|
+
obj.scanPoints = Math.round(message.scanPoints);
|
|
21961
|
+
}
|
|
21962
|
+
if (message.matchInlierRatio !== 0) {
|
|
21963
|
+
obj.matchInlierRatio = message.matchInlierRatio;
|
|
21964
|
+
}
|
|
21965
|
+
if (message.matchRms !== 0) {
|
|
21966
|
+
obj.matchRms = message.matchRms;
|
|
21967
|
+
}
|
|
21968
|
+
if (message.keyframeCount !== 0) {
|
|
21969
|
+
obj.keyframeCount = Math.round(message.keyframeCount);
|
|
21970
|
+
}
|
|
21971
|
+
if (message.mapPointCount !== 0) {
|
|
21972
|
+
obj.mapPointCount = Math.round(message.mapPointCount);
|
|
21973
|
+
}
|
|
21974
|
+
if (message.depth !== undefined) {
|
|
21975
|
+
obj.depth = message.depth;
|
|
21976
|
+
}
|
|
21977
|
+
if (message.sensorId !== "") {
|
|
21978
|
+
obj.sensorId = message.sensorId;
|
|
21979
|
+
}
|
|
21980
|
+
if (message.mount !== undefined) {
|
|
21981
|
+
obj.mount = SlamPose.toJSON(message.mount);
|
|
21982
|
+
}
|
|
21983
|
+
if (message.covarianceElements?.length) {
|
|
21984
|
+
obj.covarianceElements = message.covarianceElements;
|
|
21985
|
+
}
|
|
21986
|
+
return obj;
|
|
21987
|
+
},
|
|
21988
|
+
create(base) {
|
|
21989
|
+
return SlamPoseEstimate.fromPartial(base ?? {});
|
|
21990
|
+
},
|
|
21991
|
+
fromPartial(object) {
|
|
21992
|
+
const message = createBaseSlamPoseEstimate();
|
|
21993
|
+
message.mapId = object.mapId ?? 0;
|
|
21994
|
+
message.state = object.state ?? 0;
|
|
21995
|
+
message.pose = (object.pose !== undefined && object.pose !== null) ? SlamPose.fromPartial(object.pose) : undefined;
|
|
21996
|
+
message.time = object.time ?? undefined;
|
|
21997
|
+
message.scanPoints = object.scanPoints ?? 0;
|
|
21998
|
+
message.matchInlierRatio = object.matchInlierRatio ?? 0;
|
|
21999
|
+
message.matchRms = object.matchRms ?? 0;
|
|
22000
|
+
message.keyframeCount = object.keyframeCount ?? 0;
|
|
22001
|
+
message.mapPointCount = object.mapPointCount ?? 0;
|
|
22002
|
+
message.depth = object.depth ?? undefined;
|
|
22003
|
+
message.sensorId = object.sensorId ?? "";
|
|
22004
|
+
message.mount = (object.mount !== undefined && object.mount !== null)
|
|
22005
|
+
? SlamPose.fromPartial(object.mount)
|
|
22006
|
+
: undefined;
|
|
22007
|
+
message.covarianceElements = object.covarianceElements?.map((e) => e) || [];
|
|
22008
|
+
return message;
|
|
22009
|
+
},
|
|
22010
|
+
};
|
|
22011
|
+
function createBaseSlamKeyframe() {
|
|
22012
|
+
return { id: 0, submapId: 0, pose: undefined, time: undefined, sensorId: "", mount: undefined };
|
|
22013
|
+
}
|
|
22014
|
+
export const SlamKeyframe = {
|
|
22015
|
+
encode(message, writer = new BinaryWriter()) {
|
|
22016
|
+
if (message.id !== 0) {
|
|
22017
|
+
writer.uint32(8).uint32(message.id);
|
|
22018
|
+
}
|
|
22019
|
+
if (message.submapId !== 0) {
|
|
22020
|
+
writer.uint32(16).uint32(message.submapId);
|
|
22021
|
+
}
|
|
22022
|
+
if (message.pose !== undefined) {
|
|
22023
|
+
SlamPose.encode(message.pose, writer.uint32(26).fork()).join();
|
|
22024
|
+
}
|
|
22025
|
+
if (message.time !== undefined) {
|
|
22026
|
+
Timestamp.encode(toTimestamp(message.time), writer.uint32(34).fork()).join();
|
|
22027
|
+
}
|
|
22028
|
+
if (message.sensorId !== "") {
|
|
22029
|
+
writer.uint32(50).string(message.sensorId);
|
|
22030
|
+
}
|
|
22031
|
+
if (message.mount !== undefined) {
|
|
22032
|
+
SlamPose.encode(message.mount, writer.uint32(58).fork()).join();
|
|
22033
|
+
}
|
|
22034
|
+
return writer;
|
|
22035
|
+
},
|
|
22036
|
+
decode(input, length) {
|
|
22037
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
22038
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
22039
|
+
const message = createBaseSlamKeyframe();
|
|
22040
|
+
while (reader.pos < end) {
|
|
22041
|
+
const tag = reader.uint32();
|
|
22042
|
+
switch (tag >>> 3) {
|
|
22043
|
+
case 1: {
|
|
22044
|
+
if (tag !== 8) {
|
|
22045
|
+
break;
|
|
22046
|
+
}
|
|
22047
|
+
message.id = reader.uint32();
|
|
22048
|
+
continue;
|
|
22049
|
+
}
|
|
22050
|
+
case 2: {
|
|
22051
|
+
if (tag !== 16) {
|
|
22052
|
+
break;
|
|
22053
|
+
}
|
|
22054
|
+
message.submapId = reader.uint32();
|
|
22055
|
+
continue;
|
|
22056
|
+
}
|
|
22057
|
+
case 3: {
|
|
22058
|
+
if (tag !== 26) {
|
|
22059
|
+
break;
|
|
22060
|
+
}
|
|
22061
|
+
message.pose = SlamPose.decode(reader, reader.uint32());
|
|
22062
|
+
continue;
|
|
22063
|
+
}
|
|
22064
|
+
case 4: {
|
|
22065
|
+
if (tag !== 34) {
|
|
22066
|
+
break;
|
|
22067
|
+
}
|
|
22068
|
+
message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
22069
|
+
continue;
|
|
22070
|
+
}
|
|
22071
|
+
case 6: {
|
|
22072
|
+
if (tag !== 50) {
|
|
22073
|
+
break;
|
|
22074
|
+
}
|
|
22075
|
+
message.sensorId = reader.string();
|
|
22076
|
+
continue;
|
|
22077
|
+
}
|
|
22078
|
+
case 7: {
|
|
22079
|
+
if (tag !== 58) {
|
|
22080
|
+
break;
|
|
22081
|
+
}
|
|
22082
|
+
message.mount = SlamPose.decode(reader, reader.uint32());
|
|
22083
|
+
continue;
|
|
22084
|
+
}
|
|
22085
|
+
}
|
|
22086
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
22087
|
+
break;
|
|
22088
|
+
}
|
|
22089
|
+
reader.skip(tag & 7);
|
|
22090
|
+
}
|
|
22091
|
+
return message;
|
|
22092
|
+
},
|
|
22093
|
+
fromJSON(object) {
|
|
22094
|
+
return {
|
|
22095
|
+
id: isSet(object.id) ? gt.Number(object.id) : 0,
|
|
22096
|
+
submapId: isSet(object.submapId) ? gt.Number(object.submapId) : 0,
|
|
22097
|
+
pose: isSet(object.pose) ? SlamPose.fromJSON(object.pose) : undefined,
|
|
22098
|
+
time: isSet(object.time) ? fromJsonTimestamp(object.time) : undefined,
|
|
22099
|
+
sensorId: isSet(object.sensorId) ? gt.String(object.sensorId) : "",
|
|
22100
|
+
mount: isSet(object.mount) ? SlamPose.fromJSON(object.mount) : undefined,
|
|
22101
|
+
};
|
|
22102
|
+
},
|
|
22103
|
+
toJSON(message) {
|
|
22104
|
+
const obj = {};
|
|
22105
|
+
if (message.id !== 0) {
|
|
22106
|
+
obj.id = Math.round(message.id);
|
|
22107
|
+
}
|
|
22108
|
+
if (message.submapId !== 0) {
|
|
22109
|
+
obj.submapId = Math.round(message.submapId);
|
|
22110
|
+
}
|
|
22111
|
+
if (message.pose !== undefined) {
|
|
22112
|
+
obj.pose = SlamPose.toJSON(message.pose);
|
|
22113
|
+
}
|
|
22114
|
+
if (message.time !== undefined) {
|
|
22115
|
+
obj.time = message.time.toISOString();
|
|
22116
|
+
}
|
|
22117
|
+
if (message.sensorId !== "") {
|
|
22118
|
+
obj.sensorId = message.sensorId;
|
|
22119
|
+
}
|
|
22120
|
+
if (message.mount !== undefined) {
|
|
22121
|
+
obj.mount = SlamPose.toJSON(message.mount);
|
|
22122
|
+
}
|
|
22123
|
+
return obj;
|
|
22124
|
+
},
|
|
22125
|
+
create(base) {
|
|
22126
|
+
return SlamKeyframe.fromPartial(base ?? {});
|
|
22127
|
+
},
|
|
22128
|
+
fromPartial(object) {
|
|
22129
|
+
const message = createBaseSlamKeyframe();
|
|
22130
|
+
message.id = object.id ?? 0;
|
|
22131
|
+
message.submapId = object.submapId ?? 0;
|
|
22132
|
+
message.pose = (object.pose !== undefined && object.pose !== null) ? SlamPose.fromPartial(object.pose) : undefined;
|
|
22133
|
+
message.time = object.time ?? undefined;
|
|
22134
|
+
message.sensorId = object.sensorId ?? "";
|
|
22135
|
+
message.mount = (object.mount !== undefined && object.mount !== null)
|
|
22136
|
+
? SlamPose.fromPartial(object.mount)
|
|
22137
|
+
: undefined;
|
|
22138
|
+
return message;
|
|
22139
|
+
},
|
|
22140
|
+
};
|
|
22141
|
+
function createBaseSlamSubmapPoints() {
|
|
22142
|
+
return { submapId: 0, anchorKeyframeId: 0, points: undefined, sensorId: "" };
|
|
22143
|
+
}
|
|
22144
|
+
export const SlamSubmapPoints = {
|
|
22145
|
+
encode(message, writer = new BinaryWriter()) {
|
|
22146
|
+
if (message.submapId !== 0) {
|
|
22147
|
+
writer.uint32(8).uint32(message.submapId);
|
|
22148
|
+
}
|
|
22149
|
+
if (message.anchorKeyframeId !== 0) {
|
|
22150
|
+
writer.uint32(16).uint32(message.anchorKeyframeId);
|
|
22151
|
+
}
|
|
22152
|
+
if (message.points !== undefined) {
|
|
22153
|
+
PointCloud.encode(message.points, writer.uint32(26).fork()).join();
|
|
22154
|
+
}
|
|
22155
|
+
if (message.sensorId !== "") {
|
|
22156
|
+
writer.uint32(34).string(message.sensorId);
|
|
22157
|
+
}
|
|
22158
|
+
return writer;
|
|
22159
|
+
},
|
|
22160
|
+
decode(input, length) {
|
|
22161
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
22162
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
22163
|
+
const message = createBaseSlamSubmapPoints();
|
|
22164
|
+
while (reader.pos < end) {
|
|
22165
|
+
const tag = reader.uint32();
|
|
22166
|
+
switch (tag >>> 3) {
|
|
22167
|
+
case 1: {
|
|
22168
|
+
if (tag !== 8) {
|
|
22169
|
+
break;
|
|
22170
|
+
}
|
|
22171
|
+
message.submapId = reader.uint32();
|
|
22172
|
+
continue;
|
|
22173
|
+
}
|
|
22174
|
+
case 2: {
|
|
22175
|
+
if (tag !== 16) {
|
|
22176
|
+
break;
|
|
22177
|
+
}
|
|
22178
|
+
message.anchorKeyframeId = reader.uint32();
|
|
22179
|
+
continue;
|
|
22180
|
+
}
|
|
22181
|
+
case 3: {
|
|
22182
|
+
if (tag !== 26) {
|
|
22183
|
+
break;
|
|
22184
|
+
}
|
|
22185
|
+
message.points = PointCloud.decode(reader, reader.uint32());
|
|
22186
|
+
continue;
|
|
22187
|
+
}
|
|
22188
|
+
case 4: {
|
|
22189
|
+
if (tag !== 34) {
|
|
22190
|
+
break;
|
|
22191
|
+
}
|
|
22192
|
+
message.sensorId = reader.string();
|
|
22193
|
+
continue;
|
|
22194
|
+
}
|
|
22195
|
+
}
|
|
22196
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
22197
|
+
break;
|
|
22198
|
+
}
|
|
22199
|
+
reader.skip(tag & 7);
|
|
22200
|
+
}
|
|
22201
|
+
return message;
|
|
22202
|
+
},
|
|
22203
|
+
fromJSON(object) {
|
|
22204
|
+
return {
|
|
22205
|
+
submapId: isSet(object.submapId) ? gt.Number(object.submapId) : 0,
|
|
22206
|
+
anchorKeyframeId: isSet(object.anchorKeyframeId) ? gt.Number(object.anchorKeyframeId) : 0,
|
|
22207
|
+
points: isSet(object.points) ? PointCloud.fromJSON(object.points) : undefined,
|
|
22208
|
+
sensorId: isSet(object.sensorId) ? gt.String(object.sensorId) : "",
|
|
22209
|
+
};
|
|
22210
|
+
},
|
|
22211
|
+
toJSON(message) {
|
|
22212
|
+
const obj = {};
|
|
22213
|
+
if (message.submapId !== 0) {
|
|
22214
|
+
obj.submapId = Math.round(message.submapId);
|
|
22215
|
+
}
|
|
22216
|
+
if (message.anchorKeyframeId !== 0) {
|
|
22217
|
+
obj.anchorKeyframeId = Math.round(message.anchorKeyframeId);
|
|
22218
|
+
}
|
|
22219
|
+
if (message.points !== undefined) {
|
|
22220
|
+
obj.points = PointCloud.toJSON(message.points);
|
|
22221
|
+
}
|
|
22222
|
+
if (message.sensorId !== "") {
|
|
22223
|
+
obj.sensorId = message.sensorId;
|
|
22224
|
+
}
|
|
22225
|
+
return obj;
|
|
22226
|
+
},
|
|
22227
|
+
create(base) {
|
|
22228
|
+
return SlamSubmapPoints.fromPartial(base ?? {});
|
|
22229
|
+
},
|
|
22230
|
+
fromPartial(object) {
|
|
22231
|
+
const message = createBaseSlamSubmapPoints();
|
|
22232
|
+
message.submapId = object.submapId ?? 0;
|
|
22233
|
+
message.anchorKeyframeId = object.anchorKeyframeId ?? 0;
|
|
22234
|
+
message.points = (object.points !== undefined && object.points !== null)
|
|
22235
|
+
? PointCloud.fromPartial(object.points)
|
|
22236
|
+
: undefined;
|
|
22237
|
+
message.sensorId = object.sensorId ?? "";
|
|
22238
|
+
return message;
|
|
22239
|
+
},
|
|
22240
|
+
};
|
|
22241
|
+
function createBaseSlamMapUpdate() {
|
|
22242
|
+
return { mapId: 0, sequence: 0, keyframes: [], points: [], frame: undefined };
|
|
22243
|
+
}
|
|
22244
|
+
export const SlamMapUpdate = {
|
|
22245
|
+
encode(message, writer = new BinaryWriter()) {
|
|
22246
|
+
if (message.mapId !== 0) {
|
|
22247
|
+
writer.uint32(8).uint32(message.mapId);
|
|
22248
|
+
}
|
|
22249
|
+
if (message.sequence !== 0) {
|
|
22250
|
+
writer.uint32(16).uint64(message.sequence);
|
|
22251
|
+
}
|
|
22252
|
+
for (const v of message.keyframes) {
|
|
22253
|
+
SlamKeyframe.encode(v, writer.uint32(26).fork()).join();
|
|
22254
|
+
}
|
|
22255
|
+
for (const v of message.points) {
|
|
22256
|
+
SlamSubmapPoints.encode(v, writer.uint32(34).fork()).join();
|
|
22257
|
+
}
|
|
22258
|
+
if (message.frame !== undefined) {
|
|
22259
|
+
SlamMapFrame.encode(message.frame, writer.uint32(42).fork()).join();
|
|
22260
|
+
}
|
|
22261
|
+
return writer;
|
|
22262
|
+
},
|
|
22263
|
+
decode(input, length) {
|
|
22264
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
22265
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
22266
|
+
const message = createBaseSlamMapUpdate();
|
|
22267
|
+
while (reader.pos < end) {
|
|
22268
|
+
const tag = reader.uint32();
|
|
22269
|
+
switch (tag >>> 3) {
|
|
22270
|
+
case 1: {
|
|
22271
|
+
if (tag !== 8) {
|
|
22272
|
+
break;
|
|
22273
|
+
}
|
|
22274
|
+
message.mapId = reader.uint32();
|
|
22275
|
+
continue;
|
|
22276
|
+
}
|
|
22277
|
+
case 2: {
|
|
22278
|
+
if (tag !== 16) {
|
|
22279
|
+
break;
|
|
22280
|
+
}
|
|
22281
|
+
message.sequence = longToNumber(reader.uint64());
|
|
22282
|
+
continue;
|
|
22283
|
+
}
|
|
22284
|
+
case 3: {
|
|
22285
|
+
if (tag !== 26) {
|
|
22286
|
+
break;
|
|
22287
|
+
}
|
|
22288
|
+
message.keyframes.push(SlamKeyframe.decode(reader, reader.uint32()));
|
|
22289
|
+
continue;
|
|
22290
|
+
}
|
|
22291
|
+
case 4: {
|
|
22292
|
+
if (tag !== 34) {
|
|
22293
|
+
break;
|
|
22294
|
+
}
|
|
22295
|
+
message.points.push(SlamSubmapPoints.decode(reader, reader.uint32()));
|
|
22296
|
+
continue;
|
|
22297
|
+
}
|
|
22298
|
+
case 5: {
|
|
22299
|
+
if (tag !== 42) {
|
|
22300
|
+
break;
|
|
22301
|
+
}
|
|
22302
|
+
message.frame = SlamMapFrame.decode(reader, reader.uint32());
|
|
22303
|
+
continue;
|
|
22304
|
+
}
|
|
22305
|
+
}
|
|
22306
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
22307
|
+
break;
|
|
22308
|
+
}
|
|
22309
|
+
reader.skip(tag & 7);
|
|
22310
|
+
}
|
|
22311
|
+
return message;
|
|
22312
|
+
},
|
|
22313
|
+
fromJSON(object) {
|
|
22314
|
+
return {
|
|
22315
|
+
mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0,
|
|
22316
|
+
sequence: isSet(object.sequence) ? gt.Number(object.sequence) : 0,
|
|
22317
|
+
keyframes: gt.Array.isArray(object?.keyframes) ? object.keyframes.map((e) => SlamKeyframe.fromJSON(e)) : [],
|
|
22318
|
+
points: gt.Array.isArray(object?.points) ? object.points.map((e) => SlamSubmapPoints.fromJSON(e)) : [],
|
|
22319
|
+
frame: isSet(object.frame) ? SlamMapFrame.fromJSON(object.frame) : undefined,
|
|
22320
|
+
};
|
|
22321
|
+
},
|
|
22322
|
+
toJSON(message) {
|
|
22323
|
+
const obj = {};
|
|
22324
|
+
if (message.mapId !== 0) {
|
|
22325
|
+
obj.mapId = Math.round(message.mapId);
|
|
22326
|
+
}
|
|
22327
|
+
if (message.sequence !== 0) {
|
|
22328
|
+
obj.sequence = Math.round(message.sequence);
|
|
22329
|
+
}
|
|
22330
|
+
if (message.keyframes?.length) {
|
|
22331
|
+
obj.keyframes = message.keyframes.map((e) => SlamKeyframe.toJSON(e));
|
|
22332
|
+
}
|
|
22333
|
+
if (message.points?.length) {
|
|
22334
|
+
obj.points = message.points.map((e) => SlamSubmapPoints.toJSON(e));
|
|
22335
|
+
}
|
|
22336
|
+
if (message.frame !== undefined) {
|
|
22337
|
+
obj.frame = SlamMapFrame.toJSON(message.frame);
|
|
22338
|
+
}
|
|
22339
|
+
return obj;
|
|
22340
|
+
},
|
|
22341
|
+
create(base) {
|
|
22342
|
+
return SlamMapUpdate.fromPartial(base ?? {});
|
|
22343
|
+
},
|
|
22344
|
+
fromPartial(object) {
|
|
22345
|
+
const message = createBaseSlamMapUpdate();
|
|
22346
|
+
message.mapId = object.mapId ?? 0;
|
|
22347
|
+
message.sequence = object.sequence ?? 0;
|
|
22348
|
+
message.keyframes = object.keyframes?.map((e) => SlamKeyframe.fromPartial(e)) || [];
|
|
22349
|
+
message.points = object.points?.map((e) => SlamSubmapPoints.fromPartial(e)) || [];
|
|
22350
|
+
message.frame = (object.frame !== undefined && object.frame !== null)
|
|
22351
|
+
? SlamMapFrame.fromPartial(object.frame)
|
|
22352
|
+
: undefined;
|
|
22353
|
+
return message;
|
|
22354
|
+
},
|
|
22355
|
+
};
|
|
22356
|
+
function createBaseSlamMapFrame() {
|
|
22357
|
+
return {
|
|
22358
|
+
gravityAligned: false,
|
|
22359
|
+
headingReference: 0,
|
|
22360
|
+
magneticDeclination: undefined,
|
|
22361
|
+
originDepth: undefined,
|
|
22362
|
+
startTime: undefined,
|
|
22363
|
+
platform: 0,
|
|
22364
|
+
};
|
|
22365
|
+
}
|
|
22366
|
+
export const SlamMapFrame = {
|
|
22367
|
+
encode(message, writer = new BinaryWriter()) {
|
|
22368
|
+
if (message.gravityAligned !== false) {
|
|
22369
|
+
writer.uint32(8).bool(message.gravityAligned);
|
|
22370
|
+
}
|
|
22371
|
+
if (message.headingReference !== 0) {
|
|
22372
|
+
writer.uint32(16).int32(message.headingReference);
|
|
22373
|
+
}
|
|
22374
|
+
if (message.magneticDeclination !== undefined) {
|
|
22375
|
+
writer.uint32(29).float(message.magneticDeclination);
|
|
22376
|
+
}
|
|
22377
|
+
if (message.originDepth !== undefined) {
|
|
22378
|
+
writer.uint32(37).float(message.originDepth);
|
|
22379
|
+
}
|
|
22380
|
+
if (message.startTime !== undefined) {
|
|
22381
|
+
Timestamp.encode(toTimestamp(message.startTime), writer.uint32(42).fork()).join();
|
|
22382
|
+
}
|
|
22383
|
+
if (message.platform !== 0) {
|
|
22384
|
+
writer.uint32(48).int32(message.platform);
|
|
22385
|
+
}
|
|
22386
|
+
return writer;
|
|
22387
|
+
},
|
|
22388
|
+
decode(input, length) {
|
|
22389
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
22390
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
22391
|
+
const message = createBaseSlamMapFrame();
|
|
22392
|
+
while (reader.pos < end) {
|
|
22393
|
+
const tag = reader.uint32();
|
|
22394
|
+
switch (tag >>> 3) {
|
|
22395
|
+
case 1: {
|
|
22396
|
+
if (tag !== 8) {
|
|
22397
|
+
break;
|
|
22398
|
+
}
|
|
22399
|
+
message.gravityAligned = reader.bool();
|
|
22400
|
+
continue;
|
|
22401
|
+
}
|
|
22402
|
+
case 2: {
|
|
22403
|
+
if (tag !== 16) {
|
|
22404
|
+
break;
|
|
22405
|
+
}
|
|
22406
|
+
message.headingReference = reader.int32();
|
|
22407
|
+
continue;
|
|
22408
|
+
}
|
|
22409
|
+
case 3: {
|
|
22410
|
+
if (tag !== 29) {
|
|
22411
|
+
break;
|
|
22412
|
+
}
|
|
22413
|
+
message.magneticDeclination = reader.float();
|
|
22414
|
+
continue;
|
|
22415
|
+
}
|
|
22416
|
+
case 4: {
|
|
22417
|
+
if (tag !== 37) {
|
|
22418
|
+
break;
|
|
22419
|
+
}
|
|
22420
|
+
message.originDepth = reader.float();
|
|
22421
|
+
continue;
|
|
22422
|
+
}
|
|
22423
|
+
case 5: {
|
|
22424
|
+
if (tag !== 42) {
|
|
22425
|
+
break;
|
|
22426
|
+
}
|
|
22427
|
+
message.startTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
22428
|
+
continue;
|
|
22429
|
+
}
|
|
22430
|
+
case 6: {
|
|
22431
|
+
if (tag !== 48) {
|
|
22432
|
+
break;
|
|
22433
|
+
}
|
|
22434
|
+
message.platform = reader.int32();
|
|
22435
|
+
continue;
|
|
22436
|
+
}
|
|
22437
|
+
}
|
|
22438
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
22439
|
+
break;
|
|
22440
|
+
}
|
|
22441
|
+
reader.skip(tag & 7);
|
|
22442
|
+
}
|
|
22443
|
+
return message;
|
|
22444
|
+
},
|
|
22445
|
+
fromJSON(object) {
|
|
22446
|
+
return {
|
|
22447
|
+
gravityAligned: isSet(object.gravityAligned) ? gt.Boolean(object.gravityAligned) : false,
|
|
22448
|
+
headingReference: isSet(object.headingReference) ? slamHeadingReferenceFromJSON(object.headingReference) : 0,
|
|
22449
|
+
magneticDeclination: isSet(object.magneticDeclination) ? gt.Number(object.magneticDeclination) : undefined,
|
|
22450
|
+
originDepth: isSet(object.originDepth) ? gt.Number(object.originDepth) : undefined,
|
|
22451
|
+
startTime: isSet(object.startTime) ? fromJsonTimestamp(object.startTime) : undefined,
|
|
22452
|
+
platform: isSet(object.platform) ? slamPlatformFromJSON(object.platform) : 0,
|
|
22453
|
+
};
|
|
22454
|
+
},
|
|
22455
|
+
toJSON(message) {
|
|
22456
|
+
const obj = {};
|
|
22457
|
+
if (message.gravityAligned !== false) {
|
|
22458
|
+
obj.gravityAligned = message.gravityAligned;
|
|
22459
|
+
}
|
|
22460
|
+
if (message.headingReference !== 0) {
|
|
22461
|
+
obj.headingReference = slamHeadingReferenceToJSON(message.headingReference);
|
|
22462
|
+
}
|
|
22463
|
+
if (message.magneticDeclination !== undefined) {
|
|
22464
|
+
obj.magneticDeclination = message.magneticDeclination;
|
|
22465
|
+
}
|
|
22466
|
+
if (message.originDepth !== undefined) {
|
|
22467
|
+
obj.originDepth = message.originDepth;
|
|
22468
|
+
}
|
|
22469
|
+
if (message.startTime !== undefined) {
|
|
22470
|
+
obj.startTime = message.startTime.toISOString();
|
|
22471
|
+
}
|
|
22472
|
+
if (message.platform !== 0) {
|
|
22473
|
+
obj.platform = slamPlatformToJSON(message.platform);
|
|
22474
|
+
}
|
|
22475
|
+
return obj;
|
|
22476
|
+
},
|
|
22477
|
+
create(base) {
|
|
22478
|
+
return SlamMapFrame.fromPartial(base ?? {});
|
|
22479
|
+
},
|
|
22480
|
+
fromPartial(object) {
|
|
22481
|
+
const message = createBaseSlamMapFrame();
|
|
22482
|
+
message.gravityAligned = object.gravityAligned ?? false;
|
|
22483
|
+
message.headingReference = object.headingReference ?? 0;
|
|
22484
|
+
message.magneticDeclination = object.magneticDeclination ?? undefined;
|
|
22485
|
+
message.originDepth = object.originDepth ?? undefined;
|
|
22486
|
+
message.startTime = object.startTime ?? undefined;
|
|
22487
|
+
message.platform = object.platform ?? 0;
|
|
22488
|
+
return message;
|
|
22489
|
+
},
|
|
22490
|
+
};
|
|
22491
|
+
function createBaseSlamMap() {
|
|
22492
|
+
return { mapId: 0, sequence: 0, keyframes: [], submaps: [], frame: undefined };
|
|
22493
|
+
}
|
|
22494
|
+
export const SlamMap = {
|
|
22495
|
+
encode(message, writer = new BinaryWriter()) {
|
|
22496
|
+
if (message.mapId !== 0) {
|
|
22497
|
+
writer.uint32(8).uint32(message.mapId);
|
|
22498
|
+
}
|
|
22499
|
+
if (message.sequence !== 0) {
|
|
22500
|
+
writer.uint32(16).uint64(message.sequence);
|
|
22501
|
+
}
|
|
22502
|
+
for (const v of message.keyframes) {
|
|
22503
|
+
SlamKeyframe.encode(v, writer.uint32(26).fork()).join();
|
|
22504
|
+
}
|
|
22505
|
+
for (const v of message.submaps) {
|
|
22506
|
+
SlamSubmapPoints.encode(v, writer.uint32(34).fork()).join();
|
|
22507
|
+
}
|
|
22508
|
+
if (message.frame !== undefined) {
|
|
22509
|
+
SlamMapFrame.encode(message.frame, writer.uint32(42).fork()).join();
|
|
22510
|
+
}
|
|
22511
|
+
return writer;
|
|
22512
|
+
},
|
|
22513
|
+
decode(input, length) {
|
|
22514
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
22515
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
22516
|
+
const message = createBaseSlamMap();
|
|
22517
|
+
while (reader.pos < end) {
|
|
22518
|
+
const tag = reader.uint32();
|
|
22519
|
+
switch (tag >>> 3) {
|
|
22520
|
+
case 1: {
|
|
22521
|
+
if (tag !== 8) {
|
|
22522
|
+
break;
|
|
22523
|
+
}
|
|
22524
|
+
message.mapId = reader.uint32();
|
|
22525
|
+
continue;
|
|
22526
|
+
}
|
|
22527
|
+
case 2: {
|
|
22528
|
+
if (tag !== 16) {
|
|
22529
|
+
break;
|
|
22530
|
+
}
|
|
22531
|
+
message.sequence = longToNumber(reader.uint64());
|
|
22532
|
+
continue;
|
|
22533
|
+
}
|
|
22534
|
+
case 3: {
|
|
22535
|
+
if (tag !== 26) {
|
|
22536
|
+
break;
|
|
22537
|
+
}
|
|
22538
|
+
message.keyframes.push(SlamKeyframe.decode(reader, reader.uint32()));
|
|
22539
|
+
continue;
|
|
22540
|
+
}
|
|
22541
|
+
case 4: {
|
|
22542
|
+
if (tag !== 34) {
|
|
22543
|
+
break;
|
|
22544
|
+
}
|
|
22545
|
+
message.submaps.push(SlamSubmapPoints.decode(reader, reader.uint32()));
|
|
22546
|
+
continue;
|
|
22547
|
+
}
|
|
22548
|
+
case 5: {
|
|
22549
|
+
if (tag !== 42) {
|
|
22550
|
+
break;
|
|
22551
|
+
}
|
|
22552
|
+
message.frame = SlamMapFrame.decode(reader, reader.uint32());
|
|
22553
|
+
continue;
|
|
22554
|
+
}
|
|
22555
|
+
}
|
|
22556
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
22557
|
+
break;
|
|
22558
|
+
}
|
|
22559
|
+
reader.skip(tag & 7);
|
|
22560
|
+
}
|
|
22561
|
+
return message;
|
|
22562
|
+
},
|
|
22563
|
+
fromJSON(object) {
|
|
22564
|
+
return {
|
|
22565
|
+
mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0,
|
|
22566
|
+
sequence: isSet(object.sequence) ? gt.Number(object.sequence) : 0,
|
|
22567
|
+
keyframes: gt.Array.isArray(object?.keyframes) ? object.keyframes.map((e) => SlamKeyframe.fromJSON(e)) : [],
|
|
22568
|
+
submaps: gt.Array.isArray(object?.submaps) ? object.submaps.map((e) => SlamSubmapPoints.fromJSON(e)) : [],
|
|
22569
|
+
frame: isSet(object.frame) ? SlamMapFrame.fromJSON(object.frame) : undefined,
|
|
22570
|
+
};
|
|
22571
|
+
},
|
|
22572
|
+
toJSON(message) {
|
|
22573
|
+
const obj = {};
|
|
22574
|
+
if (message.mapId !== 0) {
|
|
22575
|
+
obj.mapId = Math.round(message.mapId);
|
|
22576
|
+
}
|
|
22577
|
+
if (message.sequence !== 0) {
|
|
22578
|
+
obj.sequence = Math.round(message.sequence);
|
|
22579
|
+
}
|
|
22580
|
+
if (message.keyframes?.length) {
|
|
22581
|
+
obj.keyframes = message.keyframes.map((e) => SlamKeyframe.toJSON(e));
|
|
22582
|
+
}
|
|
22583
|
+
if (message.submaps?.length) {
|
|
22584
|
+
obj.submaps = message.submaps.map((e) => SlamSubmapPoints.toJSON(e));
|
|
22585
|
+
}
|
|
22586
|
+
if (message.frame !== undefined) {
|
|
22587
|
+
obj.frame = SlamMapFrame.toJSON(message.frame);
|
|
22588
|
+
}
|
|
22589
|
+
return obj;
|
|
22590
|
+
},
|
|
22591
|
+
create(base) {
|
|
22592
|
+
return SlamMap.fromPartial(base ?? {});
|
|
22593
|
+
},
|
|
22594
|
+
fromPartial(object) {
|
|
22595
|
+
const message = createBaseSlamMap();
|
|
22596
|
+
message.mapId = object.mapId ?? 0;
|
|
22597
|
+
message.sequence = object.sequence ?? 0;
|
|
22598
|
+
message.keyframes = object.keyframes?.map((e) => SlamKeyframe.fromPartial(e)) || [];
|
|
22599
|
+
message.submaps = object.submaps?.map((e) => SlamSubmapPoints.fromPartial(e)) || [];
|
|
22600
|
+
message.frame = (object.frame !== undefined && object.frame !== null)
|
|
22601
|
+
? SlamMapFrame.fromPartial(object.frame)
|
|
22602
|
+
: undefined;
|
|
22603
|
+
return message;
|
|
22604
|
+
},
|
|
22605
|
+
};
|
|
22606
|
+
function createBaseSlamScan() {
|
|
22607
|
+
return { mapId: 0, pose: undefined, points: undefined, sensor: undefined, mount: undefined };
|
|
22608
|
+
}
|
|
22609
|
+
export const SlamScan = {
|
|
22610
|
+
encode(message, writer = new BinaryWriter()) {
|
|
22611
|
+
if (message.mapId !== 0) {
|
|
22612
|
+
writer.uint32(8).uint32(message.mapId);
|
|
22613
|
+
}
|
|
22614
|
+
if (message.pose !== undefined) {
|
|
22615
|
+
SlamPose.encode(message.pose, writer.uint32(18).fork()).join();
|
|
22616
|
+
}
|
|
22617
|
+
if (message.points !== undefined) {
|
|
22618
|
+
PointCloud.encode(message.points, writer.uint32(26).fork()).join();
|
|
22619
|
+
}
|
|
22620
|
+
if (message.sensor !== undefined) {
|
|
22621
|
+
SlamSensor.encode(message.sensor, writer.uint32(34).fork()).join();
|
|
22622
|
+
}
|
|
22623
|
+
if (message.mount !== undefined) {
|
|
22624
|
+
SlamPose.encode(message.mount, writer.uint32(42).fork()).join();
|
|
22625
|
+
}
|
|
22626
|
+
return writer;
|
|
22627
|
+
},
|
|
22628
|
+
decode(input, length) {
|
|
22629
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
22630
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
22631
|
+
const message = createBaseSlamScan();
|
|
22632
|
+
while (reader.pos < end) {
|
|
22633
|
+
const tag = reader.uint32();
|
|
22634
|
+
switch (tag >>> 3) {
|
|
22635
|
+
case 1: {
|
|
22636
|
+
if (tag !== 8) {
|
|
22637
|
+
break;
|
|
22638
|
+
}
|
|
22639
|
+
message.mapId = reader.uint32();
|
|
22640
|
+
continue;
|
|
22641
|
+
}
|
|
22642
|
+
case 2: {
|
|
22643
|
+
if (tag !== 18) {
|
|
22644
|
+
break;
|
|
22645
|
+
}
|
|
22646
|
+
message.pose = SlamPose.decode(reader, reader.uint32());
|
|
22647
|
+
continue;
|
|
22648
|
+
}
|
|
22649
|
+
case 3: {
|
|
22650
|
+
if (tag !== 26) {
|
|
22651
|
+
break;
|
|
22652
|
+
}
|
|
22653
|
+
message.points = PointCloud.decode(reader, reader.uint32());
|
|
22654
|
+
continue;
|
|
22655
|
+
}
|
|
22656
|
+
case 4: {
|
|
22657
|
+
if (tag !== 34) {
|
|
22658
|
+
break;
|
|
22659
|
+
}
|
|
22660
|
+
message.sensor = SlamSensor.decode(reader, reader.uint32());
|
|
22661
|
+
continue;
|
|
22662
|
+
}
|
|
22663
|
+
case 5: {
|
|
22664
|
+
if (tag !== 42) {
|
|
22665
|
+
break;
|
|
22666
|
+
}
|
|
22667
|
+
message.mount = SlamPose.decode(reader, reader.uint32());
|
|
22668
|
+
continue;
|
|
22669
|
+
}
|
|
22670
|
+
}
|
|
22671
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
22672
|
+
break;
|
|
22673
|
+
}
|
|
22674
|
+
reader.skip(tag & 7);
|
|
22675
|
+
}
|
|
22676
|
+
return message;
|
|
22677
|
+
},
|
|
22678
|
+
fromJSON(object) {
|
|
22679
|
+
return {
|
|
22680
|
+
mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0,
|
|
22681
|
+
pose: isSet(object.pose) ? SlamPose.fromJSON(object.pose) : undefined,
|
|
22682
|
+
points: isSet(object.points) ? PointCloud.fromJSON(object.points) : undefined,
|
|
22683
|
+
sensor: isSet(object.sensor) ? SlamSensor.fromJSON(object.sensor) : undefined,
|
|
22684
|
+
mount: isSet(object.mount) ? SlamPose.fromJSON(object.mount) : undefined,
|
|
22685
|
+
};
|
|
22686
|
+
},
|
|
22687
|
+
toJSON(message) {
|
|
22688
|
+
const obj = {};
|
|
22689
|
+
if (message.mapId !== 0) {
|
|
22690
|
+
obj.mapId = Math.round(message.mapId);
|
|
22691
|
+
}
|
|
22692
|
+
if (message.pose !== undefined) {
|
|
22693
|
+
obj.pose = SlamPose.toJSON(message.pose);
|
|
22694
|
+
}
|
|
22695
|
+
if (message.points !== undefined) {
|
|
22696
|
+
obj.points = PointCloud.toJSON(message.points);
|
|
22697
|
+
}
|
|
22698
|
+
if (message.sensor !== undefined) {
|
|
22699
|
+
obj.sensor = SlamSensor.toJSON(message.sensor);
|
|
22700
|
+
}
|
|
22701
|
+
if (message.mount !== undefined) {
|
|
22702
|
+
obj.mount = SlamPose.toJSON(message.mount);
|
|
22703
|
+
}
|
|
22704
|
+
return obj;
|
|
22705
|
+
},
|
|
22706
|
+
create(base) {
|
|
22707
|
+
return SlamScan.fromPartial(base ?? {});
|
|
22708
|
+
},
|
|
22709
|
+
fromPartial(object) {
|
|
22710
|
+
const message = createBaseSlamScan();
|
|
22711
|
+
message.mapId = object.mapId ?? 0;
|
|
22712
|
+
message.pose = (object.pose !== undefined && object.pose !== null) ? SlamPose.fromPartial(object.pose) : undefined;
|
|
22713
|
+
message.points = (object.points !== undefined && object.points !== null)
|
|
22714
|
+
? PointCloud.fromPartial(object.points)
|
|
22715
|
+
: undefined;
|
|
22716
|
+
message.sensor = (object.sensor !== undefined && object.sensor !== null)
|
|
22717
|
+
? SlamSensor.fromPartial(object.sensor)
|
|
22718
|
+
: undefined;
|
|
22719
|
+
message.mount = (object.mount !== undefined && object.mount !== null)
|
|
22720
|
+
? SlamPose.fromPartial(object.mount)
|
|
22721
|
+
: undefined;
|
|
22722
|
+
return message;
|
|
22723
|
+
},
|
|
22724
|
+
};
|
|
20683
22725
|
const gt = (() => {
|
|
20684
22726
|
if (typeof globalThis !== "undefined") {
|
|
20685
22727
|
return globalThis;
|