Implement AbstractPath and related API changes to support multiple path types

Applications/Scale/test/testScale.cpp

@@ -35,6 +35,7 @@
 #include <OpenSim/Simulation/Model/ForceSet.h>
 #include <OpenSim/Simulation/Model/Ligament.h>
 #include <OpenSim/Simulation/Model/PhysicalOffsetFrame.h>
+#include <OpenSim/Simulation/Model/GeometryPath.h>
 #include <OpenSim/Simulation/SimbodyEngine/PinJoint.h>
 #include <OpenSim/Simulation/SimbodyEngine/FreeJoint.h>
 #include <OpenSim/Simulation/SimbodyEngine/EllipsoidJoint.h>
@@ -561,8 +562,9 @@ void scalePhysicalOffsetFrames()
         const Vec3 offset1 = Vec3(0.2, 0.4, 0.6);
         PathActuator* act1 = new PathActuator();
         act1->setName("pathActuator1");
-        act1->addNewPathPoint("point1a", model->updGround(), Vec3(0));
-        act1->addNewPathPoint("point1b", *body, offset1);
+        auto& path = act1->updPath<GeometryPath>();
+        path.appendNewPathPoint("point1a", model->updGround(), Vec3(0));
+        path.appendNewPathPoint("point1b", *body, offset1);
         body->addComponent(act1);
 
         // Second PathActuator is attached to the Body via a POF. Both new
@@ -575,8 +577,9 @@ void scalePhysicalOffsetFrames()
 
         PathActuator* act2 = new PathActuator();
         act2->setName("pathActuator2");
-        act2->addNewPathPoint("point2a", model->updGround(), Vec3(0));
-        act2->addNewPathPoint("point2b", *pof2, offset2);
+        auto& path2 = act2->updPath<GeometryPath>();
+        path2.appendNewPathPoint("point2a", model->updGround(), Vec3(0));
+        path2.appendNewPathPoint("point2b", *pof2, offset2);
         act1->addComponent(act2);
 
         State& s = model->initSystem();
@@ -592,9 +595,11 @@ void scalePhysicalOffsetFrames()
                 model->getComponent<PathActuator>(pathToAct1);
             const PathActuator& pa2 =
                 model->getComponent<PathActuator>(pathToAct2);
+            const auto& path1 = dynamic_cast<const GeometryPath&>(pa1.getPath());
+            const auto& path2 = dynamic_cast<const GeometryPath&>(pa2.getPath());
 
-            const PathPointSet& pps1 = pa1.getGeometryPath().getPathPointSet();
-            const PathPointSet& pps2 = pa2.getGeometryPath().getPathPointSet();
+            const PathPointSet& pps1 = path1.getPathPointSet();
+            const PathPointSet& pps2 = path2.getPathPointSet();
 
             for (int i = 0; i < 2; ++i)
             {

Bindings/Java/OpenSimJNI/OpenSimContext.cpp

@@ -30,6 +30,7 @@
 #include <OpenSim/Simulation/Model/MovingPathPoint.h>
 #include <OpenSim/Simulation/Model/Muscle.h>
 #include <OpenSim/Simulation/Model/PathPoint.h>
+#include <OpenSim/Simulation/Model/GeometryPath.h>
 #include <OpenSim/Simulation/Wrap/PathWrap.h>
 #include <OpenSim/Simulation/Model/ConditionalPathPoint.h>
 #include <OpenSim/Simulation/SimbodyEngine/SimbodyEngine.h>
@@ -124,13 +125,21 @@ double OpenSimContext::getMuscleLength(Muscle& m) {
 }
 
 const Array<AbstractPathPoint*>& OpenSimContext::getCurrentPath(Muscle& m) {
-  return m.getGeometryPath().getCurrentPath(*_configState);
+  if (auto* p = dynamic_cast<const GeometryPath*>(&m.getPath())) {
+      return p->getCurrentPath(*_configState);
+  } else {
+      OPENSIM_THROW(Exception, "Muscle path is not a GeometryPath.")
+  }
 }
 
 void OpenSimContext::copyMuscle(Muscle& from, Muscle& to) {
-  to = from;
-  recreateSystemKeepStage();
-  to.updGeometryPath().updateGeometry(*_configState);
+  if (auto* p = dynamic_cast<const GeometryPath*>(&from.getPath())) {
+      to = from;
+      recreateSystemKeepStage();
+      to.updPath<GeometryPath>().updateGeometry(*_configState);
+  } else {
+      OPENSIM_THROW(Exception, "Muscle path is not a GeometryPath.")
+  }
 }
 
 // Muscle Points

Bindings/Java/OpenSimJNI/OpenSimContext.h

@@ -48,6 +48,7 @@ class GeometryPath;
 class AbstractPathPoint;
 class PathWrap;
 class ConditionalPathPoint;
+class PathPoint;
 class WrapObject;
 class Analysis;
 class AnalyzeTool;

Bindings/Java/OpenSimJNI/Test/testContext.cpp

@@ -33,6 +33,7 @@
 #include <OpenSim/Simulation/Model/PathPoint.h>
 #include <OpenSim/Simulation/Wrap/PathWrap.h>
 #include <OpenSim/Simulation/Model/ConditionalPathPoint.h>
+#include <OpenSim/Simulation/Model/GeometryPath.h>
 #include <OpenSim/Simulation/SimbodyEngine/SimbodyEngine.h>
 #include <OpenSim/Simulation/Wrap/WrapObject.h>
 #include <OpenSim/Simulation/Model/Analysis.h>
@@ -121,7 +122,7 @@ int main()
     cout << "Prop after create system is " << dProp2.toString() << endl;
     bool after = PropertyHelper::getValueBool(dProp);
     SimTK_ASSERT_ALWAYS(!after, "Property has wrong value!!");
-    dTRIlong->updGeometryPath().updateGeometry(context->getCurrentStateRef());
+    dTRIlong->updPath<GeometryPath>().updateGeometry(context->getCurrentStateRef());
     const OpenSim::Array<AbstractPathPoint*>& path = context->getCurrentPath(*dTRIlong);
     cout << "Muscle Path" << endl;
     cout << path.getSize() << endl;
@@ -156,7 +157,7 @@ int main()
     cout << "After setting coordinate to 100 deg." << endl;
     cout << xform << endl;
     // Compare to known xform
-    dTRIlong->updGeometryPath().updateGeometry(context->getCurrentStateRef());
+    dTRIlong->updPath<GeometryPath>().updateGeometry(context->getCurrentStateRef());
     const OpenSim::Array<AbstractPathPoint*>& newPath = context->getCurrentPath(*dTRIlong);
     context->realizePosition();
     // Compare to known path 
@@ -190,37 +191,37 @@ int main()
     context->restoreStateFromCachedModel();
 
     // Exercise PathPoint operations used to edit Path in GUI
-    PathPointSet& pathPoints = dTRIlong->updGeometryPath().updPathPointSet();
-    std::string pathBeforeInXML = dTRIlong->updGeometryPath().dump();
+    PathPointSet& pathPoints = dTRIlong->updPath<GeometryPath>().updPathPointSet();
+    std::string pathBeforeInXML = dTRIlong->updPath<GeometryPath>().dump();
     std::cout << pathBeforeInXML << endl;
     int origSize = pathPoints.getSize();
     AbstractPathPoint& savePoint = pathPoints.get("TRIlong-P2");
     const std::string& saveFrameName = savePoint.getParentFrame().getName();
     AbstractPathPoint* clonedPoint = savePoint.clone();
 
     // Test delete second PathPoint from TRIlong muscle
-    context->deletePathPoint(dTRIlong->updGeometryPath(), 2); 
+    context->deletePathPoint(dTRIlong->updPath<GeometryPath>(), 2);
     assert(pathPoints.getSize() == origSize - 1);
-    std::string pathAfterDeletionInXML = dTRIlong->updGeometryPath().dump();
+    std::string pathAfterDeletionInXML = dTRIlong->updPath<GeometryPath>().dump();
     std::cout << pathAfterDeletionInXML << endl;
 
     // Test adding PathPoint to TRIlong muscle (Stationary)
     Component& frame = model->updBodySet().updComponent(saveFrameName);
     PhysicalFrame* physFrame = PhysicalFrame::safeDownCast(&frame);
-    context->addPathPoint(dTRIlong->updGeometryPath(), 3, *physFrame);
+    context->addPathPoint(dTRIlong->updPath<GeometryPath>(), 3, *physFrame);
     assert(pathPoints.getSize() == origSize);
-    std::string pathAfterReinsertionInXML = dTRIlong->updGeometryPath().dump();
+    std::string pathAfterReinsertionInXML = dTRIlong->updPath<GeometryPath>().dump();
     std::cout << pathAfterReinsertionInXML << endl;
 
     // Test changing type to ConditionalPathPoint
     ConditionalPathPoint* newPoint = new ConditionalPathPoint();
     AbstractPathPoint& oldPoint = pathPoints.get(2);
     newPoint->setCoordinate(model->getCoordinateSet().get(0));
     newPoint->setParentFrame(oldPoint.getParentFrame());
-    context->replacePathPoint(dTRIlong->updGeometryPath(), oldPoint, *newPoint);
+    context->replacePathPoint(dTRIlong->updPath<GeometryPath>(), oldPoint, *newPoint);
     assert(pathPoints.getSize() == origSize);
 
-    std::string pathAfterTypeChangeToViaInXML = dTRIlong->updGeometryPath().dump();
+    std::string pathAfterTypeChangeToViaInXML = dTRIlong->updPath<GeometryPath>().dump();
     std::cout << pathAfterTypeChangeToViaInXML << endl;
 
     // Make a change to a socket that is invalid and verify that we can recover

Bindings/Java/tests/TestBasics.java

@@ -35,12 +35,14 @@ public static void testMuscleList() {
         Ground ground = model.getGround();
         Thelen2003Muscle thelenMuscle =
             new Thelen2003Muscle("Darryl", 1, 0.5, 0.5, 0);
-        thelenMuscle.addNewPathPoint("muscle1-point1", ground, new Vec3(0.0,0.0,0.0));
-        thelenMuscle.addNewPathPoint("muscle1-point2", ground, new Vec3(1.0,0.0,0.0));
+        GeometryPath pathThelen = thelenMuscle.initGeometryPath();
+        pathThelen.appendNewPathPoint("muscle1-point1", ground, new Vec3(0.0,0.0,0.0));
+        pathThelen.appendNewPathPoint("muscle1-point2", ground, new Vec3(1.0,0.0,0.0));
         Millard2012EquilibriumMuscle millardMuscle =
             new Millard2012EquilibriumMuscle("Matt", 1, 0.5, 0.5, 0);
-        millardMuscle.addNewPathPoint("muscle1-point1", ground, new Vec3(0.0,0.0,0.0));
-        millardMuscle.addNewPathPoint("muscle1-point2", ground, new Vec3(1.0,0.0,0.0));
+        GeometryPath pathMillard = millardMuscle.initGeometryPath();
+        pathMillard.appendNewPathPoint("muscle1-point1", ground, new Vec3(0.0,0.0,0.0));
+        pathMillard.appendNewPathPoint("muscle1-point2", ground, new Vec3(1.0,0.0,0.0));
         model.addComponent(thelenMuscle);
         model.addComponent(millardMuscle);
 

Bindings/Java/tests/TestModelBuilding.java

@@ -26,8 +26,9 @@ public static void main(String[] args) {
             0.6,        // Optimal fibre length
             0.55,       // Tendon slack length
             0.0);       // Pennation angle
-        biceps.addNewPathPoint("origin", hum, ArrayDouble.createVec3(new double[]{0, 0.8, 0}));
-        biceps.addNewPathPoint("insert", rad, ArrayDouble.createVec3(new double[]{0, 0.7, 0}));
+        GeometryPath pathBiceps = biceps.initGeometryPath();
+        pathBiceps.appendNewPathPoint("origin", hum, ArrayDouble.createVec3(new double[]{0, 0.8, 0}));
+        pathBiceps.appendNewPathPoint("insert", rad, ArrayDouble.createVec3(new double[]{0, 0.7, 0}));
 
         PrescribedController cns = new PrescribedController();
         cns.addActuator(biceps);

CHANGELOG.md

@@ -6,6 +6,10 @@ request related to the change, then we may provide the commit.
 
 This is not a comprehensive list of changes but rather a hand-curated collection of the more notable ones. For a comprehensive history, see the [OpenSim Core GitHub repo](https://github.com/opensim-org/opensim-core).
 
+v4.5
+====
+- Added `AbstractPath` which is a base class for `GeometryPath` and other path types (#3388). TODO: add API changes.
+
 v4.4.1
 ======
 - IMU::calcGyroscopeSignal() now reports angular velocities in the IMU frame.

OpenSim/Actuators/DeGrooteFregly2016Muscle.cpp

@@ -27,6 +27,7 @@
 #include <OpenSim/Actuators/Thelen2003Muscle.h>
 #include <OpenSim/Common/CommonUtilities.h>
 #include <OpenSim/Simulation/Model/Model.h>
+#include "OpenSim/Simulation/Model/GeometryPath.h"
 #include "OpenSim/Common/STOFileAdapter.h"
 
 using namespace OpenSim;
@@ -1021,31 +1022,36 @@ void DeGrooteFregly2016Muscle::replaceMuscles(
         actu->set_ignore_activation_dynamics(
                 muscBase.get_ignore_activation_dynamics());
 
-        const auto& pathPointSet = muscBase.getGeometryPath().getPathPointSet();
-        auto& geomPath = actu->updGeometryPath();
-        for (int ipp = 0; ipp < pathPointSet.getSize(); ++ipp) {
-            auto* pathPoint = pathPointSet.get(ipp).clone();
-            const auto& socketNames = pathPoint->getSocketNames();
-            for (const auto& socketName : socketNames) {
-                pathPoint->updSocket(socketName)
-                        .connect(pathPointSet.get(ipp)
-                                         .getSocket(socketName)
-                                         .getConnecteeAsObject());
+        // Copy the muscle's path.
+        AbstractPath& path = muscBase.updPath();
+        if (auto* pGeometryPath = dynamic_cast<GeometryPath*>(&path)) {
+            auto& thisGeometryPath = actu->initGeometryPath();
+
+            const auto& pathPointSet = pGeometryPath->getPathPointSet();
+            for (int ipp = 0; ipp < pathPointSet.getSize(); ++ipp) {
+                auto* pathPoint = pathPointSet.get(ipp).clone();
+                const auto& socketNames = pathPoint->getSocketNames();
+                for (const auto& socketName : socketNames) {
+                    pathPoint->updSocket(socketName)
+                            .connect(pathPointSet.get(ipp)
+                                             .getSocket(socketName)
+                                             .getConnecteeAsObject());
+                }
+                thisGeometryPath.updPathPointSet().adoptAndAppend(pathPoint);
             }
-            geomPath.updPathPointSet().adoptAndAppend(pathPoint);
-        }
 
-        const auto& pathWrapSet = muscBase.getGeometryPath().getWrapSet();
-        for (int ipw = 0; ipw < pathWrapSet.getSize(); ++ipw) {
-            auto* pathWrap = pathWrapSet.get(ipw).clone();
-            const auto& socketNames = pathWrap->getSocketNames();
-            for (const auto& socketName : socketNames) {
-                pathWrap->updSocket(socketName)
-                        .connect(pathWrapSet.get(ipw)
-                                .getSocket(socketName)
-                                .getConnecteeAsObject());
+            const auto& pathWrapSet = pGeometryPath->getWrapSet();
+            for (int ipw = 0; ipw < pathWrapSet.getSize(); ++ipw) {
+                auto* pathWrap = pathWrapSet.get(ipw).clone();
+                const auto& socketNames = pathWrap->getSocketNames();
+                for (const auto& socketName : socketNames) {
+                    pathWrap->updSocket(socketName)
+                            .connect(pathWrapSet.get(ipw)
+                                             .getSocket(socketName)
+                                             .getConnecteeAsObject());
+                }
+                thisGeometryPath.updWrapSet().adoptAndAppend(pathWrap);
             }
-            geomPath.updWrapSet().adoptAndAppend(pathWrap);
         }
 
         std::string actname = actu->getName();
@@ -1074,14 +1080,14 @@ void DeGrooteFregly2016Muscle::extendPostScale(
         const SimTK::State& s, const ScaleSet& scaleSet) {
     Super::extendPostScale(s, scaleSet);
 
-    GeometryPath& path = upd_GeometryPath();
+    AbstractPath& path = updPath();
     if (path.getPreScaleLength(s) > 0.0)
     {
         double scaleFactor = path.getLength(s) / path.getPreScaleLength(s);
         upd_optimal_fiber_length() *= scaleFactor;
         upd_tendon_slack_length() *= scaleFactor;
 
-        // Clear the pre-scale length that was stored in the GeometryPath.
+        // Clear the pre-scale length that was stored in the path.
         path.setPreScaleLength(s, 0.0);
     }
 }

OpenSim/Actuators/McKibbenActuator.cpp

@@ -107,7 +107,7 @@ void McKibbenActuator::computeForce(const SimTK::State& s,
 
     double actuation = computeActuation(s);
 
-    getGeometryPath().addInEquivalentForces(s, actuation, bodyForces, generalizedForces);
+    getPath().addInEquivalentForces(s, actuation, bodyForces, generalizedForces);
 }
 //_____________________________________________________________________________
 /**

OpenSim/Actuators/Millard2012AccelerationMuscle.cpp

@@ -557,14 +557,14 @@ extendPostScale(const SimTK::State& s, const ScaleSet& scaleSet)
 
     Super::extendPostScale(s, scaleSet);
 
-    GeometryPath& path = upd_GeometryPath();
+    AbstractPath& path = updPath();
     if (path.getPreScaleLength(s) > 0.0)
     {
         double scaleFactor = path.getLength(s) / path.getPreScaleLength(s);
         upd_optimal_fiber_length() *= scaleFactor;
         upd_tendon_slack_length() *= scaleFactor;
 
-        // Clear the pre-scale length that was stored in the GeometryPath.
+        // Clear the pre-scale length that was stored in the path.
         path.setPreScaleLength(s, 0.0);
     }
 }

OpenSim/Actuators/Millard2012EquilibriumMuscle.cpp

@@ -598,14 +598,14 @@ extendPostScale(const SimTK::State& s, const ScaleSet& scaleSet)
 {
     Super::extendPostScale(s, scaleSet);
 
-    GeometryPath& path = upd_GeometryPath();
+    AbstractPath& path = updPath();
     if (path.getPreScaleLength(s) > 0.0)
     {
         double scaleFactor = path.getLength(s) / path.getPreScaleLength(s);
         upd_optimal_fiber_length() *= scaleFactor;
         upd_tendon_slack_length() *= scaleFactor;
 
-        // Clear the pre-scale length that was stored in the GeometryPath.
+        // Clear the pre-scale length that was stored in the path.
         path.setPreScaleLength(s, 0.0);
     }
 }