Eliminate Body base class in favor of RigidBody (#20676)

Leaves Body as an alias for RigidBody but modifies all Drake code to use RigidBody only.
Removes unused ability to have body types other than RigidBody.
Moves now-non-templatized AddRigidBody function from inl.h to .cc.
Also renames BodyFrame to RigidBodyFrame and deprecates BodyFrame alias.

Author: sherm1

bindings/pydrake/multibody/plant_py.cc

@@ -393,7 +393,7 @@ void DoScalarDependentDefinitions(py::module m, T) {
         .def("GetFreeBodyPose", &Class::GetFreeBodyPose, py::arg("context"),
             py::arg("body"), cls_doc.GetFreeBodyPose.doc)
         .def("SetFreeBodyPose",
-            overload_cast_explicit<void, Context<T>*, const Body<T>&,
+            overload_cast_explicit<void, Context<T>*, const RigidBody<T>&,
                 const RigidTransform<T>&>(&Class::SetFreeBodyPose),
             py::arg("context"), py::arg("body"), py::arg("X_WB"),
             cls_doc.SetFreeBodyPose.doc_3args)
@@ -464,7 +464,7 @@ void DoScalarDependentDefinitions(py::module m, T) {
             cls_doc.GetVelocities.doc_2args)
         .def(
             "SetFreeBodySpatialVelocity",
-            [](const Class* self, const Body<T>& body,
+            [](const Class* self, const RigidBody<T>& body,
                 const SpatialVelocity<T>& V_WB, Context<T>* context) {
               self->SetFreeBodySpatialVelocity(context, body, V_WB);
             },
@@ -479,15 +479,15 @@ void DoScalarDependentDefinitions(py::module m, T) {
         .def(
             "EvalBodyPoseInWorld",
             [](const Class* self, const Context<T>& context,
-                const Body<T>& body_B) {
+                const RigidBody<T>& body_B) {
               return self->EvalBodyPoseInWorld(context, body_B);
             },
             py::arg("context"), py::arg("body"),
             cls_doc.EvalBodyPoseInWorld.doc)
         .def(
             "EvalBodySpatialVelocityInWorld",
             [](const Class* self, const Context<T>& context,
-                const Body<T>& body_B) {
+                const RigidBody<T>& body_B) {
               return self->EvalBodySpatialVelocityInWorld(context, body_B);
             },
             py::arg("context"), py::arg("body"),
@@ -783,12 +783,12 @@ void DoScalarDependentDefinitions(py::module m, T) {
         .def("GetFrameIndices", &Class::GetFrameIndices,
             py::arg("model_instance"), cls_doc.GetFrameIndices.doc)
         .def("GetBodyByName",
-            overload_cast_explicit<const Body<T>&, string_view>(
+            overload_cast_explicit<const RigidBody<T>&, string_view>(
                 &Class::GetBodyByName),
             py::arg("name"), py_rvp::reference_internal,
             cls_doc.GetBodyByName.doc_1args)
         .def("GetBodyByName",
-            overload_cast_explicit<const Body<T>&, string_view,
+            overload_cast_explicit<const RigidBody<T>&, string_view,
                 ModelInstanceIndex>(&Class::GetBodyByName),
             py::arg("name"), py::arg("model_instance"),
             py_rvp::reference_internal, cls_doc.GetBodyByName.doc_2args)
@@ -854,26 +854,27 @@ void DoScalarDependentDefinitions(py::module m, T) {
             &Class::RegisterAsSourceForSceneGraph, py::arg("scene_graph"),
             cls_doc.RegisterAsSourceForSceneGraph.doc)
         .def("RegisterVisualGeometry",
-            py::overload_cast<const Body<T>&, const RigidTransform<double>&,
-                const geometry::Shape&, const std::string&,
-                const Vector4<double>&>(&Class::RegisterVisualGeometry),
+            py::overload_cast<const RigidBody<T>&,
+                const RigidTransform<double>&, const geometry::Shape&,
+                const std::string&, const Vector4<double>&>(
+                &Class::RegisterVisualGeometry),
             py::arg("body"), py::arg("X_BG"), py::arg("shape"), py::arg("name"),
             py::arg("diffuse_color"),
             cls_doc.RegisterVisualGeometry
                 .doc_5args_body_X_BG_shape_name_diffuse_color)
         .def("RegisterCollisionGeometry",
-            py::overload_cast<const Body<T>&, const RigidTransform<double>&,
-                const geometry::Shape&, const std::string&,
-                geometry::ProximityProperties>(
+            py::overload_cast<const RigidBody<T>&,
+                const RigidTransform<double>&, const geometry::Shape&,
+                const std::string&, geometry::ProximityProperties>(
                 &Class::RegisterCollisionGeometry),
             py::arg("body"), py::arg("X_BG"), py::arg("shape"), py::arg("name"),
             py::arg("properties"),
             cls_doc.RegisterCollisionGeometry
                 .doc_5args_body_X_BG_shape_name_properties)
         .def("RegisterCollisionGeometry",
-            py::overload_cast<const Body<T>&, const RigidTransform<double>&,
-                const geometry::Shape&, const std::string&,
-                const CoulombFriction<double>&>(
+            py::overload_cast<const RigidBody<T>&,
+                const RigidTransform<double>&, const geometry::Shape&,
+                const std::string&, const CoulombFriction<double>&>(
                 &Class::RegisterCollisionGeometry),
             py::arg("body"), py::arg("X_BG"), py::arg("shape"), py::arg("name"),
             py::arg("coulomb_friction"),

bindings/pydrake/multibody/test/plant_test.py

@@ -19,7 +19,7 @@
 )
 from pydrake.multibody.tree import (
     BallRpyJoint_,
-    Body_,
+    Body_,  # dispreferred alias for RigidBody_
     BodyIndex,
     CalcSpatialInertia,
     MultibodyConstraintId,
@@ -46,6 +46,7 @@
     QuaternionFloatingJoint_,
     RevoluteJoint_,
     RevoluteSpring_,
+    RigidBody,
     RigidBody_,
     RotationalInertia_,
     ScopedName,
@@ -61,6 +62,11 @@
     world_index,
     world_model_instance,
 )
+# Deprecated, remove 2024-04-01. Just making sure these exist.
+from pydrake.multibody.tree import (
+    BodyFrame,
+    BodyFrame_,
+)
 from pydrake.multibody.math import (
     SpatialForce_,
     SpatialMomentum_,
@@ -140,7 +146,7 @@
 def get_index_class(cls, T):
     # Maps a class to its corresponding index class, accommdating inheritance.
     class_to_index_class_map = {
-        Body_[T]: BodyIndex,
+        RigidBody_[T]: BodyIndex,
         ForceElement_[T]: ForceElementIndex,
         Frame_[T]: FrameIndex,
         Joint_[T]: JointIndex,
@@ -320,7 +326,7 @@ def test_casting_and_get_weakref_and_last_body():
     def test_multibody_plant_api_via_parsing(self, T):
         MultibodyPlant = MultibodyPlant_[T]
         Joint = Joint_[T]
-        Body = Body_[T]
+        Body = Body_[T]  # check that dispreferred alias works
         Frame = Frame_[T]
         JointActuator = JointActuator_[T]
         InputPort = InputPort_[T]
@@ -415,7 +421,7 @@ def check_repr(element, expected):
         link1_frame = plant.GetFrameByName(name="Link1")
         check_repr(
             link1_frame,
-            "<BodyFrame name='Link1' index=1 model_instance=2>")
+            "<RigidBodyFrame name='Link1' index=1 model_instance=2>")
         self.assertIs(
             link1_frame,
             plant.GetFrameByName(name="Link1", model_instance=model_instance))
@@ -500,7 +506,7 @@ def _test_frame_api(self, T, frame):
         self.assertIsInstance(frame, Frame)
         self._test_multibody_tree_element_mixin(T, frame)
 
-        self.assertIsInstance(frame.body(), Body_[T])
+        self.assertIsInstance(frame.body(), RigidBody_[T])
         self.assertIsInstance(frame.is_world_frame(), bool)
         self.assertIsInstance(frame.is_body_frame(), bool)
         self.assertIsInstance(frame.name(), str)
@@ -514,7 +520,7 @@ def _test_frame_api(self, T, frame):
             RotationMatrix_[T])
 
     def _test_body_api(self, T, body):
-        Body = Body_[T]
+        Body = RigidBody_[T]
 
         self.assertIsInstance(body, Body)
         self._test_multibody_tree_element_mixin(T, body)
@@ -564,7 +570,7 @@ def test_body_context_methods(self, T):
 
     def _test_joint_api(self, T, joint):
         Joint = Joint_[T]
-        Body = Body_[T]
+        Body = RigidBody_[T]
         Frame = Frame_[T]
 
         self.assertIsInstance(joint, Joint)
@@ -882,11 +888,13 @@ def test_legacy_unpickle_plant_module(self):
 
     @numpy_compare.check_all_types
     def test_rigid_body_api(self, T):
-        RigidBody = RigidBody_[T]
+        TemplatedRigidBody = RigidBody_[T]
         M = SpatialInertia_[float]()
         i = ModelInstanceIndex(0)
+        TemplatedRigidBody(body_name="body_name", M_BBo_B=M)
+        TemplatedRigidBody(body_name="body_name", model_instance=i, M_BBo_B=M)
+        # Make sure the default (float) version also works.
         RigidBody(body_name="body_name", M_BBo_B=M)
-        RigidBody(body_name="body_name", model_instance=i, M_BBo_B=M)
 
     @numpy_compare.check_all_types
     def test_multibody_force_element(self, T):

bindings/pydrake/multibody/tree_py.cc

@@ -12,7 +12,6 @@
 #include "drake/bindings/pydrake/pydrake_pybind.h"
 #include "drake/multibody/plant/multibody_plant.h"
 #include "drake/multibody/tree/ball_rpy_joint.h"
-#include "drake/multibody/tree/body.h"
 #include "drake/multibody/tree/door_hinge.h"
 #include "drake/multibody/tree/force_element.h"
 #include "drake/multibody/tree/frame.h"
@@ -288,11 +287,15 @@ void DoScalarDependentDefinitions(py::module m, T) {
   }
 
   {
-    using Class = BodyFrame<T>;
-    constexpr auto& cls_doc = doc.BodyFrame;
+    using Class = RigidBodyFrame<T>;
+    constexpr auto& cls_doc = doc.RigidBodyFrame;
     auto cls = DefineTemplateClassWithDefault<Class, Frame<T>>(
-        m, "BodyFrame", param, cls_doc.doc);
+        m, "RigidBodyFrame", param, cls_doc.doc);
     // No need to re-bind element mixins from `Frame`.
+
+    // TODO(sherm1) This is deprecated; remove 2024-04-01.
+    m.attr("BodyFrame") = m.attr("RigidBodyFrame");
+    m.attr("BodyFrame_") = m.attr("RigidBodyFrame_");
   }
 
   {
@@ -306,7 +309,7 @@ void DoScalarDependentDefinitions(py::module m, T) {
                  std::optional<ModelInstanceIndex>>(),
             py::arg("name"), py::arg("P"), py::arg("X_PF"),
             py::arg("model_instance") = std::nullopt, cls_doc.ctor.doc_4args)
-        .def(py::init<const std::string&, const Body<T>&,
+        .def(py::init<const std::string&, const RigidBody<T>&,
                  const math::RigidTransform<double>&>(),
             py::arg("name"), py::arg("bodyB"), py::arg("X_BF"),
             cls_doc.ctor.doc_3args)
@@ -317,14 +320,20 @@ void DoScalarDependentDefinitions(py::module m, T) {
             py::arg("context"), cls_doc.GetPoseInParentFrame.doc);
   }
 
-  // Bodies.
+  // Rigid bodies.
   {
-    using Class = Body<T>;
-    constexpr auto& cls_doc = doc.Body;
-    auto cls =
-        DefineTemplateClassWithDefault<Class>(m, "Body", param, cls_doc.doc);
+    using Class = RigidBody<T>;
+    constexpr auto& cls_doc = doc.RigidBody;
+    auto cls = DefineTemplateClassWithDefault<Class>(
+        m, "RigidBody", param, cls_doc.doc);
     BindMultibodyElementMixin<T>(&cls);
     cls  // BR
+        .def(py::init<const std::string&, const SpatialInertia<double>&>(),
+            py::arg("body_name"), py::arg("M_BBo_B"), cls_doc.ctor.doc_2args)
+        .def(py::init<const std::string&, ModelInstanceIndex,
+                 const SpatialInertia<double>&>(),
+            py::arg("body_name"), py::arg("model_instance"), py::arg("M_BBo_B"),
+            cls_doc.ctor.doc_3args)
         .def("name", &Class::name, cls_doc.name.doc)
         .def("scoped_name", &Class::scoped_name, cls_doc.scoped_name.doc)
         .def("body_frame", &Class::body_frame, py_rvp::reference_internal,
@@ -366,31 +375,7 @@ void DoScalarDependentDefinitions(py::module m, T) {
         .def("Lock", &Class::Lock, py::arg("context"), cls_doc.Lock.doc)
         .def("Unlock", &Class::Unlock, py::arg("context"), cls_doc.Unlock.doc)
         .def("is_locked", &Class::is_locked, py::arg("context"),
-            cls_doc.is_locked.doc);
-
-// TODO(sherm1) Remove as of 2024-02-01.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    cls  // BR
-        .def("floating_velocities_start",
-            WrapDeprecated(cls_doc.floating_velocities_start.doc_deprecated,
-                &Class::floating_velocities_start),
-            cls_doc.floating_velocities_start.doc_deprecated);
-#pragma GCC diagnostic pop
-  }
-
-  {
-    using Class = RigidBody<T>;
-    constexpr auto& cls_doc = doc.RigidBody;
-    auto cls = DefineTemplateClassWithDefault<Class, Body<T>>(
-        m, "RigidBody", param, cls_doc.doc);
-    cls  // BR
-        .def(py::init<const std::string&, const SpatialInertia<double>&>(),
-            py::arg("body_name"), py::arg("M_BBo_B"), cls_doc.ctor.doc_2args)
-        .def(py::init<const std::string&, ModelInstanceIndex,
-                 const SpatialInertia<double>&>(),
-            py::arg("body_name"), py::arg("model_instance"), py::arg("M_BBo_B"),
-            cls_doc.ctor.doc_3args)
+            cls_doc.is_locked.doc)
         .def("default_mass", &Class::default_mass, cls_doc.default_mass.doc)
         .def("default_com", &Class::default_com, py_rvp::reference_internal,
             cls_doc.default_com.doc)
@@ -408,6 +393,20 @@ void DoScalarDependentDefinitions(py::module m, T) {
         .def("SetSpatialInertiaInBodyFrame",
             &Class::SetSpatialInertiaInBodyFrame, py::arg("context"),
             py::arg("M_Bo_B"), cls_doc.SetSpatialInertiaInBodyFrame.doc);
+
+// TODO(sherm1) Remove as of 2024-02-01.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+    cls  // BR
+        .def("floating_velocities_start",
+            WrapDeprecated(cls_doc.floating_velocities_start.doc_deprecated,
+                &Class::floating_velocities_start),
+            cls_doc.floating_velocities_start.doc_deprecated);
+#pragma GCC diagnostic pop
+
+    // Aliases for backwards compatibility (dispreferred).
+    m.attr("Body") = m.attr("RigidBody");
+    m.attr("Body_") = m.attr("RigidBody_");
   }
 
   // Joints.
@@ -888,8 +887,9 @@ void DoScalarDependentDefinitions(py::module m, T) {
     auto cls = DefineTemplateClassWithDefault<Class, ForceElement<T>>(
         m, "LinearSpringDamper", param, cls_doc.doc);
     cls  // BR
-        .def(py::init<const Body<T>&, const Vector3<double>&, const Body<T>&,
-                 const Vector3<double>&, double, double, double>(),
+        .def(py::init<const RigidBody<T>&, const Vector3<double>&,
+                 const RigidBody<T>&, const Vector3<double>&, double, double,
+                 double>(),
             py::arg("bodyA"), py::arg("p_AP"), py::arg("bodyB"),
             py::arg("p_BQ"), py::arg("free_length"), py::arg("stiffness"),
             py::arg("damping"), cls_doc.ctor.doc)

bindings/pydrake/planning/planning_py_collision_checker.cc

@@ -11,9 +11,9 @@ namespace drake {
 namespace pydrake {
 namespace internal {
 
-using multibody::Body;
 using multibody::BodyIndex;
 using multibody::Frame;
+using multibody::RigidBody;
 
 void DefinePlanningCollisionChecker(py::module m) {
   // NOLINTNEXTLINE(build/namespaces): Emulate placement in namespace.
@@ -34,7 +34,7 @@ void DefinePlanningCollisionChecker(py::module m) {
         .def("robot_model_instances", &Class::robot_model_instances,
             cls_doc.robot_model_instances.doc)
         .def("IsPartOfRobot",
-            overload_cast_explicit<bool, const Body<double>&>(
+            overload_cast_explicit<bool, const RigidBody<double>&>(
                 &Class::IsPartOfRobot),
             py::arg("body"), cls_doc.IsPartOfRobot.doc)
         .def("IsPartOfRobot",
@@ -107,8 +107,8 @@ void DefinePlanningCollisionChecker(py::module m) {
             py::arg("bodyA_index"), py::arg("bodyB_index"),
             cls_doc.GetPaddingBetween.doc_2args_bodyA_index_bodyB_index)
         .def("GetPaddingBetween",
-            overload_cast_explicit<double, const Body<double>&,
-                const Body<double>&>(&Class::GetPaddingBetween),
+            overload_cast_explicit<double, const RigidBody<double>&,
+                const RigidBody<double>&>(&Class::GetPaddingBetween),
             py::arg("bodyA"), py::arg("bodyB"),
             cls_doc.GetPaddingBetween.doc_2args_bodyA_bodyB)
         .def("SetPaddingBetween",
@@ -117,8 +117,8 @@ void DefinePlanningCollisionChecker(py::module m) {
             py::arg("bodyA_index"), py::arg("bodyB_index"), py::arg("padding"),
             cls_doc.SetPaddingBetween.doc_3args_bodyA_index_bodyB_index_padding)
         .def("SetPaddingBetween",
-            py::overload_cast<const Body<double>&, const Body<double>&, double>(
-                &Class::SetPaddingBetween),
+            py::overload_cast<const RigidBody<double>&,
+                const RigidBody<double>&, double>(&Class::SetPaddingBetween),
             py::arg("bodyA"), py::arg("bodyB"), py::arg("padding"),
             cls_doc.SetPaddingBetween.doc_3args_bodyA_bodyB_padding)
         .def("GetPaddingMatrix", &Class::GetPaddingMatrix,
@@ -152,8 +152,8 @@ void DefinePlanningCollisionChecker(py::module m) {
             cls_doc.IsCollisionFilteredBetween
                 .doc_2args_bodyA_index_bodyB_index)
         .def("IsCollisionFilteredBetween",
-            overload_cast_explicit<bool, const Body<double>&,
-                const Body<double>&>(&Class::IsCollisionFilteredBetween),
+            overload_cast_explicit<bool, const RigidBody<double>&,
+                const RigidBody<double>&>(&Class::IsCollisionFilteredBetween),
             py::arg("bodyA"), py::arg("bodyB"),
             cls_doc.IsCollisionFilteredBetween.doc_2args_bodyA_bodyB)
         .def("SetCollisionFilteredBetween",
@@ -164,7 +164,8 @@ void DefinePlanningCollisionChecker(py::module m) {
             cls_doc.SetCollisionFilteredBetween
                 .doc_3args_bodyA_index_bodyB_index_filter_collision)
         .def("SetCollisionFilteredBetween",
-            py::overload_cast<const Body<double>&, const Body<double>&, bool>(
+            py::overload_cast<const RigidBody<double>&,
+                const RigidBody<double>&, bool>(
                 &Class::SetCollisionFilteredBetween),
             py::arg("bodyA"), py::arg("bodyB"), py::arg("filter_collision"),
             cls_doc.SetCollisionFilteredBetween
@@ -175,7 +176,7 @@ void DefinePlanningCollisionChecker(py::module m) {
             py::arg("body_index"),
             cls_doc.SetCollisionFilteredWithAllBodies.doc_1args_body_index)
         .def("SetCollisionFilteredWithAllBodies",
-            py::overload_cast<const Body<double>&>(
+            py::overload_cast<const RigidBody<double>&>(
                 &Class::SetCollisionFilteredWithAllBodies),
             py::arg("body"),
             cls_doc.SetCollisionFilteredWithAllBodies.doc_1args_body)