Avoid tweaking tangent points of WrapCylinder when single object wrap…

Applications/Forward/test/testForward.cpp

@@ -160,7 +160,7 @@ void testArm26() {
     for (int j = 0; j < state->getSize(); ++j) {
         stringstream message;
         message << "t=" << time <<" state# "<< j << " " << standard->getColumnLabels()[j+1] << " std=" << data[j] <<"  computed=" << state->getData()[j] << endl;
-        ASSERT_EQUAL(data[j], state->getData()[j], 1.0e-3, 
+        ASSERT_EQUAL(data[j], state->getData()[j], 5.0e-3, 
             __FILE__, __LINE__, "ASSERT_EQUAL FAILED " + message.str());
         cout << "ASSERT_EQUAL PASSED " << message.str();
     }
@@ -173,7 +173,7 @@ void testArm26() {
     for (int j = 0; j < state->getSize(); ++j) {
         stringstream message;
         message << "t=" << time <<" state# "<< j << " " << standard->getColumnLabels()[j+1] << " std=" << data[j] <<"  computed=" << state->getData()[j] << endl;
-        ASSERT_EQUAL(data[j], state->getData()[j], 1.0e-3, 
+        ASSERT_EQUAL(data[j], state->getData()[j], 5.0e-3, 
             __FILE__, __LINE__, "ASSERT_EQUAL FAILED " + message.str());
         cout << "ASSERT_EQUAL PASSED " << message.str();
     }

OpenSim/Actuators/ModelProcessor.h

@@ -126,6 +126,7 @@ class OSIMACTUATORS_API ModelProcessor : public Object {
             }
             Model modelFromFile(path);
             model = std::move(modelFromFile);
+            model.updDisplayHints().disableVisualization();
             model.finalizeFromProperties();
             model.finalizeConnections();
         }

OpenSim/Common/ModelDisplayHints.h

@@ -105,8 +105,13 @@ class OSIMCOMMON_API ModelDisplayHints : public Object {
     /** Default construction creates a valid display hints object with all
     hints set to their default values. **/
     ModelDisplayHints() { constructProperties(); }
-
-
+    /** Turn off visualization completely, only use for API/modeling.
+    Meshes will not be loaded, path-wrapping intermediate points will
+    not be computed, MomentArm computations are not affected however.
+    Intentionally there's no reverse API to turn on visualization downstream.
+    **/
+    void disableVisualization() { _visualization = false; }
+    bool isVisualizationEnabled() const { return _visualization; }
 private:
     void constructProperties() {
         constructProperty_show_wrap_geometry(true);
@@ -120,6 +125,7 @@ class OSIMCOMMON_API ModelDisplayHints : public Object {
         constructProperty_show_forces(true);
         constructProperty_show_debug_geometry(false);
     }
+    bool _visualization{true};
 };
 
 

OpenSim/Common/Mtx.cpp

@@ -48,191 +48,6 @@ static const double eps = std::numeric_limits<double>::epsilon();
 //=============================================================================
 // CONSTRUCTOR(S) AND DESTRUCTOR
 //=============================================================================
-
-//-----------------------------------------------------------------------------
-// INTERPOLATION
-//-----------------------------------------------------------------------------
-//_____________________________________________________________________________
-/**
- * Linearly interpolate or extrapolate an array of data.
- */
-void Mtx::
-Interpolate(int aN,double aT1,double *aY1,double aT2,double *aY2,
-    double aT,double *aY)
-{
-    // DETERMINE PERCENT OF INTERVAL
-    int i;
-    double pct;
-    double num = aT-aT1;
-    double den = aT2-aT1;
-    if(den==0.0) {
-        pct = 0.0;
-    } else {
-        pct = num/den;
-    }
-
-    // LOOP OVER ARRAY
-    for(i=0;i<aN;i++) {
-        if(pct==0.0) {
-            aY[i] = aY1[i];
-        } else {
-            aY[i] = aY1[i] + pct*(aY2[i]-aY1[i]);
-        }
-    }
-}
-//_____________________________________________________________________________
-/**
- * Linearly interpolate or extrapolate two data points.
- */
-double Mtx::
-Interpolate(double aT1,double aY1,double aT2,double aY2,double aT)
-{
-    // DETERMINE PERCENT OF INTERVAL
-    double pct;
-    double num = aT-aT1;
-    double den = aT2-aT1;
-    if(den==0.0) {
-        pct = 0.0;
-    } else {
-        pct = num/den;
-    }
-
-    // INTERP
-    double y;
-    if(pct==0.0) {
-        y = aY1;
-    } else {
-        y = aY1 + pct*(aY2-aY1);
-    }
-    return(y);
-}
-
-
-//=============================================================================
-// TRANSLATION AND ROTATION
-//=============================================================================
-//-----------------------------------------------------------------------------
-// TRANSLATION
-//-----------------------------------------------------------------------------
-//_____________________________________________________________________________
-/**
- * Translate a point by a specified amount.
- *
- * @param aX Amount to translate in the X direction.
- * @param aY Amount to translate in the Y direction.
- * @param aZ Amount to translate in the Z direction.
- * @param aP Point to translate.
- * @param rP Translated point.  aP and rP may coincide in memory.
- */
-void Mtx::
-Translate(double aX,double aY,double aZ,const double aP[3],double rP[3])
-{
-    rP[0] = aP[0] + aX;
-    rP[1] = aP[1] + aY;
-    rP[2] = aP[2] + aZ;
-}
-
-//-----------------------------------------------------------------------------
-// ROTATE BY RADIANS
-//-----------------------------------------------------------------------------
-//_____________________________________________________________________________
-/**
- * Rotate a point about the X, Y, or Z axis by a specified amount.
- *
- * @param aXYZ Specify whether to rotate about the X (aXYZ=0), Y (aXYZ=1),
- * or Z (aXYZ=2) axes.  If aXYZ is not 0, 1, or 2, no rotation is performed.
- * @param aRadians Amount of rotation in radians.
- * @param aP Point to rotate.
- * @param rP Rotated point.  aP and rP may coincide in memory.
- */
-void Mtx::
-Rotate(int aXYZ,double aRadians,const double aP[3],double rP[3])
-{
-    if(aP==NULL) return;
-    if(rP==NULL) return;
-
-    // COPY
-    double p0 = aP[0];
-    double p1 = aP[1];
-    double p2 = aP[2];
-
-    // COMPUTE SIN AND COS
-    double c = cos(aRadians);
-    double s = sin(aRadians);
-
-    // X
-    if(aXYZ==0) {
-        rP[0] =  p0;
-        rP[1] =  c*p1 - s*p2;
-        rP[2] =  s*p1 + c*p2;
-
-    // Y
-    } else if(aXYZ==1) {
-        rP[0] =  c*p0 + s*p2;
-        rP[1] =  p1;
-        rP[2] = -s*p0 + c*p2;
-
-    // Z
-    } else if(aXYZ==2) {
-        rP[0] =  c*p0 - s*p1;
-        rP[1] =  s*p0 + c*p1;
-        rP[2] =  p2;
-    }
-}
-//_____________________________________________________________________________
-/**
- * Rotate a point about a specified axis by a specified amount.
- *
- * @param aAxis Axis about which to rotate.  The axis is not assumed to be
- * a unit vector; however, if the axis is the zero vector, no rotation
- * is performed.
- * @param aRadians Amount of rotation in radians.
- * @param aP Point to rotate.
- * @param rP Rotated point.  aP and rP may coincide in memory.
- */
-void Mtx::
-Rotate(const double aAxis[3],double aRadians,const double aP[3],double rP[3])
-{
-    if(aAxis==0) return;
-    if(aP==NULL) return;
-    if(rP==NULL) return;
-
-}
-
-//-----------------------------------------------------------------------------
-// ROTATE BY DEGREES
-//-----------------------------------------------------------------------------
-//_____________________________________________________________________________
-/**
- * Rotate a point about the X axis by a specified amount.
- *
- * @param aXYZ Specify whether to rotate about the X (aXYZ=0), Y (aXYZ=1),
- * or Z (aXYZ=2) axis.  If aXYZ is not 0, 1, or 2, no rotation is performed.
- * @param aDegrees Amount of rotation in degrees.
- * @param aP Point to rotate.
- * @param rP Rotated point.  aP and rP may coincide in memory.
- */
-void Mtx::
-RotateDeg(int aXYZ,double aDegrees,const double aP[3],double rP[3])
-{
-    Rotate(aXYZ,SimTK_DEGREE_TO_RADIAN*aDegrees,aP,rP);
-}
-//_____________________________________________________________________________
-/**
- * Rotate a point about a specified axis by a specified amount.
- *
- * @param aAxis Axis about which to rotate.
- * @param aDegrees Amount of rotation in degrees.
- * @param aP Point to rotate.
- * @param rP Rotated point.  aP and rP may coincide in memory.
- */
-void Mtx::
-RotateDeg(const double aAxis[3],double aDegrees,const double aP[3],double rP[3])
-{
-    Rotate(aAxis,SimTK_DEGREE_TO_RADIAN*aDegrees,aP,rP);
-}
-
-
 //=============================================================================
 // MATRIX ARITHMETIC
 //=============================================================================
@@ -267,30 +82,6 @@ Identity(int aN,double *rI)
     return(0);
 }
 //_____________________________________________________________________________
-/**
- * Add two matrices.
- *
- * If the arguments are not valid, then a -1 is returned.
- * Otherwise, 0 is returned.
- *
- * It is permissible for aM to coincide with either aM1 or aM2.
- */
-int Mtx::
-Add(int aNR,int aNC,const double *aM1,const double *aM2,double *aM)
-{
-    if(aM1==NULL) return(-1);
-    if(aM2==NULL) return(-1);
-    if(aM ==NULL) return(-1);
-    if(aNR<=0) return(-1);
-    if(aNC<=0) return(-1);
-
-    // MULTIPLY
-    int i,n=aNR*aNC;
-    for(i=0;i<n;i++,aM1++,aM2++,aM++)  *aM = *aM1 + *aM2;
-
-    return(0);
-}
-//_____________________________________________________________________________
 /**
  * Subtract two matrices.
  *

OpenSim/Common/Mtx.h

@@ -61,26 +61,11 @@ class OSIMCOMMON_API Mtx
 public:
     //--------------------------------------------------------------------------
     // CONSTRUCTION
-    //--------------------------------------------------------------------------
-    //Mtx();
-    //virtual ~Mtx();
 
     //--------------------------------------------------------------------------
     // VECTOR
     //--------------------------------------------------------------------------
     //_____________________________________________________________________________
-    /**
-    * Find the angle between two vectors:  theta = acos( aV1*aV2/(|aV1|*|aV2|)).
-    *
-    * @param aV1 Vector 1.
-    * @param aV2 Vector 2.
-    * @return Angle between two vectors in radians.
-    */
-    inline static double Angle(const SimTK::Vec3& aV1, const SimTK::Vec3& aV2){
-        SimTK::Vec3 v1(aV1);    v1.normalize();
-        SimTK::Vec3 v2(aV2);    v2.normalize();
-        return (acos( ~v1 * v2));
-    }
     //_____________________________________________________________________________
     /**
     * Normalize a vector.
@@ -101,16 +86,6 @@ class OSIMCOMMON_API Mtx
             rV.setToZero();
         return mag;
     }
-    /**
-    * Compute the magnitude of a vector.
-    *
-    * @param aN     Obsolete -- always pass as a "3".
-    * @param aV     Vector.
-    * @returns      Square root of the dot product aV*aV.
-    */
-    inline static double Magnitude(int aN,const SimTK::Vec3& aV){
-        return aV.norm();
-    }
     //_____________________________________________________________________________
     /**
     * Compute the dot product of two vectors.
@@ -121,59 +96,11 @@ class OSIMCOMMON_API Mtx
     inline static double DotProduct(int aN,const SimTK::Vec3& aV1,const SimTK::Vec3& aV2){
         return ~aV1 * aV2;
     }
-    //_____________________________________________________________________________
-    /**
-    * Compute the cross product of two vectors.
-    *
-    * If the arguments are not valid (aR=aS=NULL), -1 is returned.
-    */
-    inline static void CrossProduct(const SimTK::Vec3& aV1, const SimTK::Vec3& aV2, SimTK::Vec3& aV){
-         aV = aV1 % aV2;
-    };
-    /**
-    * Get a unit vector that is perpendicular to a specified vector.  The unit
-    * vector is arbitrary, in the sense that it is one of an infinite number of
-    * vectors that are perpendicular to the original specified vector.
-    *
-    * @param aV Input vector.
-    * @param rV Perpendicular unit vector.
-    */
-    static void PerpendicularUnitVector(const SimTK::Vec3& aV, SimTK::Vec3& rV)
-    {
-        SimTK::UnitVec3 unit(aV);
-        rV = unit.perp().asVec3();
-    }
-    static void
-     Interpolate(int aN,double aT1,double *aY1,double aT2,double *aY2,
-     double t,double *aY);
-    static double
-     Interpolate(double aT1,double aY1,double aT2,double aY2,
-     double t);
-
-    //--------------------------------------------------------------------------
-    // TRANSLATION AND ROTATION
-    //--------------------------------------------------------------------------
-    static void
-        Translate(double aX,double aY,double aZ,const double aP[3],double rP[3]);
-    static void
-        Rotate(int aXYZ,double aRadians,const double aP[3],double rP[3]);
-    static void
-        Rotate(const double aAxis[3],double aRadians,const double aP[3],
-        double rP[3]);
-    static void
-        RotateDeg(int aXYZ,double aDegrees,const double aP[3],double rP[3]);
-    static void
-        RotateDeg(const double aAxis[3],double aDegrees,const double aP[3],
-        double rP[3]);
 
     //--------------------------------------------------------------------------
     // MATRIX
     //--------------------------------------------------------------------------
     static int Identity(int aNR,double *rI);
-    //static int Assign(int aNR,int aNC,double aScalar,double *rM);
-    //static int Assign(int aNR,int aNC,const double *aM,double *rM);
-    //static int Add(int aNR,int aNC,const double *aM1,double aScalar,double *aM);
-    static int Add(int aNR,int aNC,const double *aM1,const double *aM2,double *aM);
     static int Subtract(int aNR,int aNC,const double *aM1,const double *aM2,
         double *aM);
     static int Multiply(int aNR,int aNC,const double *aM,double aScalar,double *rM);

OpenSim/Moco/MocoProblemRep.cpp

@@ -43,9 +43,11 @@ void MocoProblemRep::initialize() {
 
     // Clear member variables.
     m_model_base = Model();
+    m_model_base.updDisplayHints().disableVisualization();
     m_state_base.clear();
     m_position_motion_base.reset();
     m_model_disabled_constraints = Model();
+    m_model_disabled_constraints.updDisplayHints().disableVisualization();
     m_position_motion_disabled_constraints.reset();
     m_constraint_forces.reset();
     m_acceleration_motion.reset();