@@ -8,14 +8,22 @@ This package converts `autoware_sensing_msgs::msg::RadarObjects` into `autoware_
 
 A node that converts radar objects from the sensing definition into a perception friendly format with no filtering involved.
 
+### What the input is expected to be
+
+The node converts the message format; it does not transform coordinates, compensate the ego motion, or synchronize anything. It therefore expects the radar driver to publish `RadarObjects` in the form the perception pipeline uses:
+
+- Positions, orientations, sizes and their covariances are expressed in the frame named in `header.frame_id`, which is the frame the output objects are published in (typically `base_link`).
+- Velocities and accelerations are absolute (ground-relative) and expressed in that same frame, as the driver reports them; the node rotates them by the object's orientation so that the output twist and acceleration are expressed in the object's own frame, as Autoware's object messages require. The `absolute_dynamics` flag of `RadarInfo` is not checked.
+- The `RadarInfo` message declares the object fields the radar provides. The following fields are required, and objects are dropped until a `RadarInfo` that declares all of them has arrived: `existence_probability`, `position_x`, `position_y`, `velocity_x`, `velocity_y`, `acceleration_x`, `acceleration_y`, `orientation`.
+- Fields the `RadarInfo` does not declare are filled from the `default_*` parameters: `position_z`, `velocity_z`, `acceleration_z`, `size_x`, `size_y`, `size_z`. The yaw variances of the pose and the twist are set only when `orientation_std` and `orientation_rate_std` are declared.
+
 ### Parameter: classification_remap
 
 This parameter allows remapping of classification labels from `autoware_sensing_msgs::msg::RadarClassification` to `autoware_perception_msgs::msg::ObjectClassification`. It should be provided as a flat list of strings, where each pair of strings represents an input label and the corresponding output label.
 
 For example, the current default configuration remaps `MOTORCYCLE` and `BICYCLE` from radar classification to `CAR` in the perception classification, while keeping other labels unchanged.
 
-**Note**: If multiple radar labels are remapped to the same perception label, multiple probabilities may appear for that label.
-This does not violate any logic in Autoware but may be worth monitoring.
+The `probability` of each radar classification is treated as an independent confidence for that label, not as a share of a distribution, and is copied as it is. Consequently, if multiple radar labels are remapped to the same perception label, multiple entries with that label and their own probabilities appear in the output; the probabilities are not merged. This does not violate any logic in Autoware but may be worth monitoring.
 
 ### Inputs / Outputs
 
 
@@ -85,12 +85,13 @@ std::string join(const std::vector<std::string> & words)
 
 }  // namespace
 
-void ConversionConfiguration::add_field(std::string name, float default_value)
+void ConversionConfiguration::add_field(std::string name, double default_value)
 {
   default_fields_.push_back({std::move(name), default_value});
 }
 
-const std::vector<std::pair<std::string, float>> & ConversionConfiguration::defaulted_fields() const
+const std::vector<std::pair<std::string, double>> & ConversionConfiguration::defaulted_fields()
+  const
 {
   return default_fields_;
 }
 
@@ -79,13 +79,13 @@ class InvalidRadarInfo : public std::runtime_error
 class ConversionConfiguration
 {
 public:
-  void add_field(std::string name, float default_value);
+  void add_field(std::string name, double default_value);
 
   // The defaulted fields, in the order they were added.
-  const std::vector<std::pair<std::string, float>> & defaulted_fields() const;
+  const std::vector<std::pair<std::string, double>> & defaulted_fields() const;
 
 private:
-  std::vector<std::pair<std::string, float>> default_fields_;
+  std::vector<std::pair<std::string, double>> default_fields_;
 };
 
 // What a radar objects message converts into: the messages to publish.
@@ -106,12 +106,12 @@ class MissingRadarInfo : public std::runtime_error
 // The values used for the object fields a radar does not provide.
 struct RadarObjectsAdapterParams
 {
-  float default_position_z{0.0f};
-  float default_velocity_z{0.0f};
-  float default_acceleration_z{0.0f};
-  float default_size_x{0.0f};
-  float default_size_y{0.0f};
-  float default_size_z{0.0f};
+  double default_position_z{0.0};
+  double default_velocity_z{0.0};
+  double default_acceleration_z{0.0};
+  double default_size_x{0.0};
+  double default_size_y{0.0};
+  double default_size_z{0.0};
 };
 
 // Converts radar objects into detected objects and into tracked objects. Learns which fields the
 
@@ -41,13 +41,13 @@ RadarObjectsAdapterNode::RadarObjectsAdapterNode(const rclcpp::NodeOptions & opt
 
   RadarObjectsAdapterParams params;
 
-  params.default_position_z = this->declare_parameter<float>("default_position_z");
-  params.default_velocity_z = this->declare_parameter<float>("default_velocity_z");
-  params.default_acceleration_z = this->declare_parameter<float>("default_acceleration_z");
+  params.default_position_z = this->declare_parameter<double>("default_position_z");
+  params.default_velocity_z = this->declare_parameter<double>("default_velocity_z");
+  params.default_acceleration_z = this->declare_parameter<double>("default_acceleration_z");
 
-  params.default_size_x = this->declare_parameter<float>("default_size_x");
-  params.default_size_y = this->declare_parameter<float>("default_size_y");
-  params.default_size_z = this->declare_parameter<float>("default_size_z");
+  params.default_size_x = this->declare_parameter<double>("default_size_x");
+  params.default_size_y = this->declare_parameter<double>("default_size_y");
+  params.default_size_z = this->declare_parameter<double>("default_size_z");
 
   // The tracks of this radar are told from those of another by the hash of the input topic name.
   const std::string topic_name = radar_objects_sub_->get_topic_name();
 
@@ -89,23 +89,23 @@ struct DefaultParameters
   [[nodiscard]] RadarObjectsAdapterParams to_params() const
   {
     RadarObjectsAdapterParams params;
-    params.default_position_z = static_cast<float>(position_z);
-    params.default_velocity_z = static_cast<float>(velocity_z);
-    params.default_acceleration_z = static_cast<float>(acceleration_z);
-    params.default_size_x = static_cast<float>(size_x);
-    params.default_size_y = static_cast<float>(size_y);
-    params.default_size_z = static_cast<float>(size_z);
+    params.default_position_z = position_z;
+    params.default_velocity_z = velocity_z;
+    params.default_acceleration_z = acceleration_z;
+    params.default_size_x = size_x;
+    params.default_size_y = size_y;
+    params.default_size_z = size_z;
     return params;
   }
 };
 
 // The six optional fields that have a parameter, with the value DefaultParameters gives each, in
 // the order update_radar_info() reports them. orientation_std and orientation_rate_std have no
 // parameter and are never reported.
-using DefaultedField = std::pair<std::string, float>;
-const std::vector<DefaultedField> all_defaulted = {{"position_z", 0.25f},     {"velocity_z", 0.5f},
-                                                   {"acceleration_z", 0.75f}, {"size_x", 5.0f},
-                                                   {"size_y", 2.0f},          {"size_z", 1.5f}};
+using DefaultedField = std::pair<std::string, double>;
+const std::vector<DefaultedField> all_defaulted = {{"position_z", 0.25},     {"velocity_z", 0.5},
+                                                   {"acceleration_z", 0.75}, {"size_x", 5.0},
+                                                   {"size_y", 2.0},          {"size_z", 1.5}};
 
 std::vector<DefaultedField> all_defaulted_except(const std::string & declared)
 {
@@ -731,6 +731,37 @@ TEST(RadarObjectsAdapter, Detections_OptionalFields_ChoiceMadePerField)
   }
 }
 
+// The parameters above are values a float represents exactly, so they cannot tell a parameter
+// that was rounded to float on the way from one that was not. These cannot be represented as
+// float: each must reach the output as written, on whichever output carries it.
+TEST(RadarObjectsAdapter, Detections_UndeclaredFields_ParameterNotRoundedToFloat)
+{
+  // Arrange
+  DefaultParameters defaults;
+  defaults.position_z = 0.1;
+  defaults.velocity_z = 0.2;
+  defaults.acceleration_z = 0.3;
+  defaults.size_x = 4.1;
+  defaults.size_y = 1.9;
+  defaults.size_z = 1.7;
+  const RadarInfo info = make_radar_info(required_fields);
+  const RadarObject radar = make_radar_object();
+
+  // Act
+  const auto outputs = run_adapter_and_collect_outputs(info, {radar}, defaults.to_params());
+  ASSERT_TRUE(outputs.has_value());
+
+  // Assert: the parameter's value as written, not its nearest float
+  const DetectedObject & detected = outputs->detections.objects.at(0);
+  const TrackedObject & tracked = outputs->tracks.objects.at(0);
+  EXPECT_DOUBLE_EQ(detected.kinematics.pose_with_covariance.pose.position.z, 0.1);
+  EXPECT_DOUBLE_EQ(detected.kinematics.twist_with_covariance.twist.linear.z, 0.2);
+  EXPECT_DOUBLE_EQ(tracked.kinematics.acceleration_with_covariance.accel.linear.z, 0.3);
+  EXPECT_DOUBLE_EQ(detected.shape.dimensions.x, 4.1);
+  EXPECT_DOUBLE_EQ(detected.shape.dimensions.y, 1.9);
+  EXPECT_DOUBLE_EQ(detected.shape.dimensions.z, 1.7);
+}
+
 // The radar's yaw angle becomes the orientation quaternion: a rotation about z alone.
 TEST(RadarObjectsAdapter, Detections_Orientation_QuaternionFromYaw)
 {
 
@@ -384,6 +384,27 @@ TEST_F(RadarObjectsAdapterNodeTest, Construct_RemapParametersOmitted_Constructs)
   EXPECT_NO_THROW(std::make_shared<RadarObjectsAdapterNode>(options));
 }
 
+// A default_* value that a float cannot represent exactly reaches the output as written: the
+// parameter is read as the double it is declared as, not through a float.
+TEST_F(RadarObjectsAdapterNodeTest, Construct_DefaultParameterNotRepresentableAsFloat_ReachesOutput)
+{
+  // Arrange: no optional field declared, so every default_* parameter is used
+  DefaultParameters defaults;
+  defaults.position_z = 0.1;
+  defaults.size_x = 4.1;
+  const RadarInfo info = make_radar_info(required_fields);
+
+  // Act
+  const auto outputs =
+    run_node_and_collect_outputs(info, {make_radar_object()}, defaults.to_options());
+  ASSERT_TRUE(outputs.has_value());
+
+  // Assert
+  const auto & detected = outputs->detections.objects.at(0);
+  EXPECT_DOUBLE_EQ(detected.kinematics.pose_with_covariance.pose.position.z, 0.1);
+  EXPECT_DOUBLE_EQ(detected.shape.dimensions.x, 4.1);
+}
+
 // ---------------------------------------------------------------------------------------------
 // The radar info gate. Radar objects are converted only after a radar info message has declared
 // all of the fields the node requires; until then every radar objects message is dropped with a
Original file line number	Diff line number	Diff line change
`@@ -85,12 +85,13 @@ std::string join(const std::vector<std::string> & words)`
`85`	`85`
`86`	`86`	`} // namespace`
`87`	`87`
`88`		`-void ConversionConfiguration::add_field(std::string name, float default_value)`
	`88`	`+void ConversionConfiguration::add_field(std::string name, double default_value)`
`89`	`89`	`{`
`90`	`90`	`default_fields_.push_back({std::move(name), default_value});`
`91`	`91`	`}`
`92`	`92`
`93`		`-const std::vector<std::pair<std::string, float>> & ConversionConfiguration::defaulted_fields() const`
	`93`	`+const std::vector<std::pair<std::string, double>> & ConversionConfiguration::defaulted_fields()`
	`94`	`+ const`
`94`	`95`	`{`
`95`	`96`	`return default_fields_;`
`96`	`97`	`}`