ci(pre-commit): autofix

Author: pre-commit-ci[bot]

src/nebula_ouster/nebula_ouster/src/ouster_ros_wrapper.cpp

@@ -46,7 +46,8 @@ namespace
 {
 constexpr double k_ns_to_ms = 1e-6;
 
-/// Fetch Ouster `SensorInfo` JSON from a sensor or replay HTTP API. Respects `http_proxy` / `https_proxy`.
+/// Fetch Ouster `SensorInfo` JSON from a sensor or replay HTTP API. Respects `http_proxy` /
+/// `https_proxy`.
 std::string fetch_ouster_metadata_via_http(const std::string & sensor_url)
 {
   auto sensor_http = ouster::sdk::sensor::SensorHttp::create(sensor_url);
@@ -425,8 +426,8 @@ void OusterRosWrapper::process_packet(
 
   if (!decode_result.metadata_or_error.has_value()) {
     RCLCPP_DEBUG_THROTTLE(
-        get_logger(), *get_clock(), 1000, "Packet decode failed: %s.",
-        drivers::to_cstr(decode_result.metadata_or_error.error()));
+      get_logger(), *get_clock(), 1000, "Packet decode failed: %s.",
+      drivers::to_cstr(decode_result.metadata_or_error.error()));
     return;
   }
 

src/nebula_ouster/nebula_ouster_decoders/include/nebula_ouster_decoders/ouster_decoder.hpp

@@ -19,13 +19,13 @@
 #include <nebula_core_common/util/expected.hpp>
 #include <nebula_core_decoders/angles.hpp>
 
+#include <ouster/types.h>
+
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <vector>
 
-#include <ouster/types.h>
-
 namespace nebula::drivers
 {
 
@@ -62,10 +62,7 @@ struct PacketDecodeResult
   /// Successful metadata or a decode error.
   util::expected<PacketMetadata, DecodeError> metadata_or_error;
 
-  PacketDecodeResult()
-  : performance_counters{}, metadata_or_error(DecodeError::CALLBACK_NOT_SET)
-  {
-  }
+  PacketDecodeResult() : performance_counters{}, metadata_or_error(DecodeError::CALLBACK_NOT_SET) {}
 };
 
 /// @brief Decoder that batches Ouster UDP packets via ouster-sdk (@c ScanBatcher) and publishes

src/nebula_ouster/nebula_ouster_decoders/src/ouster_decoder.cpp

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "nebula_ouster_decoders/ouster_decoder.hpp"
+
 #include "nebula_ouster_decoders/ouster_lidar_scan_conversions.hpp"
 
 #include <ouster/lidar_scan.h>
@@ -71,9 +72,7 @@ const char * to_cstr(const DecodeError error)
 OusterDecoder::OusterDecoder(
   FieldOfView<float, Degrees> fov, std::shared_ptr<ouster::sdk::core::SensorInfo> & sensor_info,
   bool apply_sensor_extrinsics, pointcloud_callback_t pointcloud_cb)
-: impl_(std::make_unique<Impl>(
-    fov, sensor_info, apply_sensor_extrinsics,
-    std::move(pointcloud_cb)))
+: impl_(std::make_unique<Impl>(fov, sensor_info, apply_sensor_extrinsics, std::move(pointcloud_cb)))
 {
 }
 
@@ -91,17 +90,17 @@ PacketDecodeResult OusterDecoder::unpack(const std::vector<uint8_t> & packet)
     result.metadata_or_error = DecodeError::CALLBACK_NOT_SET;
     result.performance_counters.decode_time_ns =
       static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
-                               std::chrono::steady_clock::now() - decode_begin)
-                               .count());
+                              std::chrono::steady_clock::now() - decode_begin)
+                              .count());
     return result;
   }
 
   if (packet.empty()) {
     result.metadata_or_error = DecodeError::EMPTY_PACKET;
     result.performance_counters.decode_time_ns =
       static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
-                               std::chrono::steady_clock::now() - decode_begin)
-                               .count());
+                              std::chrono::steady_clock::now() - decode_begin)
+                              .count());
     return result;
   }
 
@@ -112,8 +111,8 @@ PacketDecodeResult OusterDecoder::unpack(const std::vector<uint8_t> & packet)
     result.metadata_or_error = DecodeError::PACKET_FORMAT_INVALID;
     result.performance_counters.decode_time_ns =
       static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
-                               std::chrono::steady_clock::now() - decode_begin)
-                               .count());
+                              std::chrono::steady_clock::now() - decode_begin)
+                              .count());
     return result;
   }
 
@@ -139,29 +138,28 @@ PacketDecodeResult OusterDecoder::unpack(const std::vector<uint8_t> & packet)
   PacketMetadata metadata{};
   metadata.packet_timestamp_ns =
     static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
-                          std::chrono::system_clock::now().time_since_epoch())
-                          .count());
+                            std::chrono::system_clock::now().time_since_epoch())
+                            .count());
   metadata.did_scan_complete = complete;
 
   if (complete) {
     const auto callback_begin = std::chrono::steady_clock::now();
     NebulaPointCloudPtr cloud =
       nebula_point_cloud_from_lidar_scan(impl_->lidar_scan, impl_->xyz_lut, impl_->fov);
     const uint64_t scan_ts = impl_->lidar_scan.get_first_valid_column_timestamp();
-    const double timestamp_s =
-      scan_ts != 0U ? static_cast<double>(scan_ts) * 1e-9 : 0.0;
+    const double timestamp_s = scan_ts != 0U ? static_cast<double>(scan_ts) * 1e-9 : 0.0;
     impl_->pointcloud_callback(cloud, timestamp_s);
     result.performance_counters.callback_time_ns =
       static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
-                               std::chrono::steady_clock::now() - callback_begin)
-                               .count());
+                              std::chrono::steady_clock::now() - callback_begin)
+                              .count());
   }
 
   result.metadata_or_error = metadata;
   result.performance_counters.decode_time_ns =
     static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
-                             std::chrono::steady_clock::now() - decode_begin)
-                             .count());
+                            std::chrono::steady_clock::now() - decode_begin)
+                            .count());
   return result;
 }
 

src/nebula_ouster/nebula_ouster_decoders/src/ouster_lidar_scan_conversions.cpp

@@ -41,24 +41,20 @@ float normalize_azimuth_deg(float az_deg)
 }  // namespace
 
 using ouster::sdk::core::LidarScan;
-using ouster::sdk::core::XYZLut;
-using ouster::sdk::core::SensorInfo;
 using ouster::sdk::core::RANGE_UNIT;
+using ouster::sdk::core::SensorInfo;
+using ouster::sdk::core::XYZLut;
 namespace ChanField = ouster::sdk::core::ChanField;
 
 NebulaPointCloudPtr nebula_point_cloud_from_lidar_scan(
-  const LidarScan & scan, const XYZLut & lut,
-  const FieldOfView<float, Degrees> & fov)
+  const LidarScan & scan, const XYZLut & lut, const FieldOfView<float, Degrees> & fov)
 {
   if (!scan.has_field(ChanField::RANGE) || scan.w == 0 || scan.h == 0) {
     return std::make_shared<NebulaPointCloud>();
   }
 
-
   const auto range_img = scan.field<uint32_t>(ChanField::RANGE);
-  const ouster::sdk::core::PointCloudXYZd xyz =
-    ouster::sdk::core::cartesian(range_img, lut);
-
+  const ouster::sdk::core::PointCloudXYZd xyz = ouster::sdk::core::cartesian(range_img, lut);
 
   const bool dual = scan.sensor_info->num_returns() > 1;
   const Eigen::Index h = static_cast<Eigen::Index>(scan.h);
@@ -87,8 +83,8 @@ NebulaPointCloudPtr nebula_point_cloud_from_lidar_scan(
         continue;
       }
 
-      const size_t i = static_cast<size_t>(row) * static_cast<size_t>(scan.w) +
-        static_cast<size_t>(col);
+      const size_t i =
+        static_cast<size_t>(row) * static_cast<size_t>(scan.w) + static_cast<size_t>(col);
 
       Eigen::Vector3d pt = xyz.row(i);
 
@@ -115,8 +111,8 @@ NebulaPointCloudPtr nebula_point_cloud_from_lidar_scan(
         tgt_pt.intensity = static_cast<std::uint8_t>(std::min<uint16_t>(255U, v >> 4));
       }
       // TODO[unaal]: retrieve return type from the sensor_info config
-      tgt_pt.return_type = static_cast<std::uint8_t>(
-        dual ? ReturnType::LAST : ReturnType::STRONGEST);
+      tgt_pt.return_type =
+        static_cast<std::uint8_t>(dual ? ReturnType::LAST : ReturnType::STRONGEST);
       tgt_pt.channel = static_cast<std::uint16_t>(row);
       tgt_pt.azimuth = deg2rad(azimuth_deg);
       tgt_pt.elevation = deg2rad(altitude_deg);