Eliminate Body base class in favor of RigidBody

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)