@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.
@@ -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 { state: 0, boundingBox: undefined, imageWidth: 0, imageHeight: 0, confidence: 0, vx: 0, vy: 0, vs: 0, vr: 0 };
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;