  OpenSim::AbstractProperty | An abstract property is a serializable (name,value) pair, for which we
do not know the type of the value |
  OpenSim::Property< T > | A %Property\<T> is a serializable (name, list-of-values) pair, where each
value is of type T |
 OpenSim::Property_Deprecated | |
 OpenSim::PropertyBool | |
| OpenSim::PropertyBoolArray | Class PropertyBoolArray extends class Property |
| OpenSim::PropertyDbl | |
| OpenSim::PropertyDblArray | |
 OpenSim::PropertyTransform | |
| OpenSim::PropertyDblVec_< M > | |
| OpenSim::PropertyInt | |
| OpenSim::PropertyIntArray | |
| OpenSim::PropertyObj | |
| OpenSim::PropertyObjArray< T > | |
| OpenSim::PropertyObjPtr< T > | |
| OpenSim::PropertyStr | |
| OpenSim::PropertyStrArray | |
| OpenSim::PropertyObjArray< Analysis > | |
| OpenSim::PropertyObjArray< Body > | |
| OpenSim::PropertyObjArray< BodyScale > | |
| OpenSim::PropertyObjArray< Constraint > | |
| OpenSim::PropertyObjArray< ContactGeometry > | |
| OpenSim::PropertyObjArray< Control > | |
| OpenSim::PropertyObjArray< Controller > | |
| OpenSim::PropertyObjArray< Coordinate > | |
| OpenSim::PropertyObjArray< DisplayGeometry > | |
| OpenSim::PropertyObjArray< ExternalForce > | |
| OpenSim::PropertyObjArray< Force > | |
| OpenSim::PropertyObjArray< Function > | |
| OpenSim::PropertyObjArray< IKTask > | |
| OpenSim::PropertyObjArray< Joint > | |
| OpenSim::PropertyObjArray< Marker > | |
| OpenSim::PropertyObjArray< MarkerPair > | |
| OpenSim::PropertyObjArray< Measurement > | |
| OpenSim::PropertyObjArray< ModelComponent > | |
| OpenSim::PropertyObjArray< ObjectGroup > | |
| OpenSim::PropertyObjArray< PathPoint > | |
| OpenSim::PropertyObjArray< Probe > | |
| OpenSim::PropertyObjArray< Scale > | |
| OpenSim::PropertyObjArray< TrackingTask > | |
| OpenSim::Array< T > | |
| dllObjectInstantiator | |
| OpenSim::Exception | |
| OpenSim::InterruptedException | |
| OpenSim::Muscle::FiberVelocityInfo | FiberVelocityInfo contains velocity quantities related to the velocity of the muscle (fiber + tendon) complex |
| OpenSim::ForceAdapter | This acts as an adapter to allow a Force or Actuator to be used as a SimTK::Force |
| OpenSim::FunctionScaler | This is a SimTK::Function that multiplies the value of another function by a constant |
| OpenSim::Geometry | Class Geometry is intended to be used as the base class for all geometry that needs to be represented in the system, both as vtk files, or analytic |
| OpenSim::AnalyticGeometry | Utility class used to abstract anayltic geometry |
| OpenSim::AnalyticCylinder | |
| OpenSim::AnalyticEllipsoid | |
| OpenSim::AnalyticSphere | |
| OpenSim::AnalyticTorus | |
| OpenSim::LineGeometry | |
| OpenSim::ArrowGeometry | |
| OpenSim::PolyhedralGeometry | |
| OpenSim::IO | A class for performing input and output with OpenSim API |
| OpenSim::Manager | A class that manages the execution of a simulation |
| OpenSim::ModelDisplayHints | This class captures information indicating user or programmer preferences
to guide automatic display geometry generation by a Model |
| OpenSim::ModelVisualizer | This class manages runtime visualization of a Model that is being
manipulated through the OpenSim API |
| OpenSim::Muscle::MuscleDynamicsInfo | MuscleDynamicsInfo contains quantities that are related to the forces that the muscle generates |
| OpenSim::Muscle::MuscleLengthInfo | The MuscleLengthInfo struct contains information about the muscle that is strictly a function of the length of the fiber and the tendon, and the orientation of the muscle fiber |
| OpenSim::Object | This is the base class for all %OpenSim objects that are serializable
(meaning they can be written to and read back from files) |
| OpenSim::AbstractTool | An abstract class for specifying the interface for an investigation |
| OpenSim::AnalyzeTool | An abstract class for specifying the interface for an investigation |
| OpenSim::CMCTool | An abstract class for specifying the interface for an investigation |
| OpenSim::ForwardTool | A concrete tool for perfroming forward dynamics simulations |
| OpenSim::RRATool | An abstract class for specifying the interface for an investigation |
| OpenSim::Analysis | An abstract class for specifying the interface for an analysis plugin |
| OpenSim::Actuation | A class for recording the basic actuator information for a model during a simulation |
| OpenSim::AnalysisPlugin_Template | |
| OpenSim::AnalysisWrapper | Class used as base class for Java classes deriving from Analysis (used to be callback) It lives on the C++ side so that it gets access to SimTK::State, but it returns quantities in Java data types |
| OpenSim::InterruptCallback | Class used to handle interrupts (synchronously) |
| OpenSim::BodyKinematics | A class for recording the kinematics of the bodies of a model during a simulation |
| OpenSim::ForceReporter | A class for recording the Forces applied to a model during a simulation |
| OpenSim::InducedAccelerations | A class to perform an Induced Accelerations analysis using a constraint- method of replacing external (contact) forces in order to determine the contributions of actuators to external reaction forces and thus model accelerations including that of the center-of-mass |
| OpenSim::JointReaction | An analysis for reporting the joint reaction loads from a model |
| OpenSim::Kinematics | A class for recording the kinematics of the generalized coordinates of a model during a simulation |
| OpenSim::MuscleAnalysis | A class for recording and computting basic quantities (length, shortening velocity, tendon length, ...) for muscles during a simulation |
| OpenSim::PointKinematics | A class for recording the kinematics of a point on a body of a model during a simulation |
| OpenSim::ProbeReporter | A class for reporting the outputs of all model-connected Probes to file during a simulation |
| OpenSim::StatesReporter | A class for recording the states of a model during a simulation |
| OpenSim::StaticOptimization | This class implements static optimization to compute Muscle Forces and activations |
| OpenSim::BodyScale | A class implementing a set of parameters describing how to scale a body segment |
| OpenSim::Condition | A parent class for implementing an OpenSim Condition |
| OpenSim::FunctionThresholdCondition | FunctionThresholdCondition is a concrete implementation of a Condition |
| OpenSim::Control | |
| OpenSim::ControlConstant | |
| OpenSim::ControlLinear | |
| OpenSim::ControlLinearNode | |
| OpenSim::DisplayGeometry | A class for representing the DisplayGeometry properties of an object |
| OpenSim::Function | |
| OpenSim::Constant | A class for representing a constant value |
| OpenSim::GCVSpline | |
| OpenSim::LinearFunction | A class for representing a LinearFunction |
| OpenSim::MultiplierFunction | |
| OpenSim::PiecewiseConstantFunction | |
| OpenSim::PiecewiseLinearFunction | |
| OpenSim::SimmSpline | |
| OpenSim::Sine | A class for representing a Sine function |
| OpenSim::StepFunction | A class for representing a StepFunction |
| OpenSim::GenericModelMaker | A class implementing a set of parameters describing a generic musculoskeletal model |
| OpenSim::IKTask | |
| OpenSim::IKCoordinateTask | |
| OpenSim::IKMarkerTask | |
| OpenSim::Marker | A class implementing a SIMM [mocap] marker |
| OpenSim::MarkerData | A class implementing a sequence of marker frames from a TRC/TRB file |
| OpenSim::MarkerFrame | A class implementing a frame of marker data from a TRC/TRB file |
| OpenSim::MarkerPair | |
| OpenSim::MarkerPlacer | A class implementing a set of parameters describing how to place markers on a model (presumably after it has been scaled to fit a subject) |
| OpenSim::MarkerWeight | |
| OpenSim::Measurement | A class implementing a measurement (the distance between one or more pairs of markers, used to scale a model) |
| OpenSim::ModelComponent | This defines the abstract ModelComponent class, which is used to add computational components to the underlying SimTK::System (MultibodySystem) |
| OpenSim::ActiveForceLengthCurve | This class serves as a serializable ActiveForceLengthCurve, for use in muscle models |
| OpenSim::Body | A class implementing a Simbody rigid body |
| OpenSim::Constraint | A parent class for implementing a Simbody Constraint |
| OpenSim::ConstantDistanceConstraint | A class implementing a constraint that maintains a constant distance between between two points |
| OpenSim::CoordinateCouplerConstraint | |
| OpenSim::PointConstraint | A class implementing a Point Constraint |
| OpenSim::PointOnLineConstraint | A class implementing a Point On Line Constraint |
| OpenSim::UnilateralConstraint | An abstract class defining an OpenSim UnilateralConstraint |
| OpenSim::RollingOnSurfaceConstraint | A class implementing a collection of rolling-without-slipping and non-penetration constraints on a surface |
| OpenSim::WeldConstraint | A class implementing a Weld Constraint |
| OpenSim::ContactGeometry | This class represents the physical shape of an object for use in contact modeling |
| OpenSim::ContactHalfSpace | This class represents a half space (that is, everything to one side of an infinite plane) for use in contact modeling |
| OpenSim::ContactMesh | This class represents a polygonal mesh for use in contact modeling |
| OpenSim::ContactSphere | This class represents a spherical object for use in contact modeling |
| OpenSim::Controller | Controller is an abstract ModelComponent that defines the interface for an OpenSim Controller |
| OpenSim::ControlSetController | |
| OpenSim::PrescribedController | |
| OpenSim::TrackingController | |
| OpenSim::CMC | Computed Muscle Control (CMC) is an optimization-based control technique designed specifically for controlling dynamic models that are actuated by redundant sets of actuators whose force-generating properties may be nonlinear and goverend by differential equaitions (as so have delays in force production) |
| OpenSim::CorrectionController | This is a simple feedback controller to be used in generating a forward dynamic simulation |
| OpenSim::Coordinate | A Coordinate is a ModelComponent for managing the access and behavior of a model's generalized coordinate including its value, speed and acceleration (once system accelerations have been realized) |
| OpenSim::FiberCompressiveForceCosPennationCurve | This class serves as a serializable FiberCompressiveForceCosPennationCurve, which is used to ensure that the pennation angle approaches but never reaches an angle of 90 degrees |
| OpenSim::FiberCompressiveForceLengthCurve | This class serves as a serializable FiberCompressiveForceLengthCurve, which is used to ensure that the fiber cannot generate force at, nor shorten beyond a minimum normalized length |
| OpenSim::FiberForceLengthCurve | This class serves as a serializable FiberForceLengthCurve, commonly used to model the parallel elastic element, for use in muscle models |
| OpenSim::Force | This abstract class represents a force applied to bodies or generalized coordinates during a simulation |
| OpenSim::Actuator_ | Base class for an actuator (e.g., a torque motor, muscle, ...) that requires external input (controls) to generate force |
| OpenSim::Actuator | Derived class for an actuator (e.g., a torque motor, muscle, ...) that requires exactly one external input (control) to generate a scalar value force, such as a torque/force magnitude or a tension |
| OpenSim::CoordinateActuator | An actuator that applies a generalized force to along a generalized a generalized coordinate, which is proportional to its input control |
| OpenSim::PathActuator | This is the base class for actuators that apply controllable tension along a geometry path |
| OpenSim::Muscle | A base class for modeling a muscle-tendon actuator |
| OpenSim::ActivationFiberLengthMuscle | A base class representing a two-state muscle-tendon actuator |
| OpenSim::Thelen2003Muscle | Implementation of a two state (activation and fiber-length) Muscle model by Thelen 2003. This a complete rewrite of a previous implementation (present in OpenSim 2.4 and earlier) contained numerous errors |
| OpenSim::ActivationFiberLengthMuscle_Deprecated | A base class representing a muscle-tendon actuator |
| OpenSim::ContDerivMuscle_Deprecated | A class implementing a SIMM muscle |
| OpenSim::Delp1990Muscle_Deprecated | A class implementing a SIMM muscle |
| OpenSim::Schutte1993Muscle_Deprecated | A class implementing a SIMM muscle |
| OpenSim::Thelen2003Muscle_Deprecated | A class implementing a SIMM muscle |
| OpenSim::Millard2012AccelerationMuscle | This class implements a 3 state (activation,fiber length and fiber velocity) acceleration musculo-tendon model that has several advantages over equilibrium musculo-tendon models: it is possible to simulate 0 activation, it requires fewer integrator steps to simulate, and physiological active force-length (with a minimum value of 0) and force velocity (with true asymptotes at the maximum shortening and lengthening velocites) curves can be employed |
| OpenSim::Millard2012EquilibriumMuscle | This class implements a 2 state (activation and fiber length) equilibrium muscle model that uses a unilateral constraint to ensure that the singularity conditions typical of equilibrium models (when  ,  , and  ) are prevented |
| OpenSim::RigidTendonMuscle | A class implementing a RigidTendonMuscle actuator with no states |
| OpenSim::PointActuator | A class that implements a point actuator acting on the model |
| OpenSim::PointToPointActuator | A class that implements a force actuator acting between two points on two bodies |
| OpenSim::TorqueActuator | A class that implements a torque actuator acting on a body |
| OpenSim::BodyDrag | |
| OpenSim::BushingForce | A class implementing a Bushing Force |
| OpenSim::CoordinateLimitForce | |
| OpenSim::ElasticFoundationForce | This Force subclass implements an elastic foundation contact model |
| OpenSim::ExternalForce | This applies a force and/or torque to a body according describe by arrays contained in a Storage The source of the Storage may be experimental sensor recording or user generated data |
| OpenSim::HuntCrossleyForce | This force subclass implements a Hunt-Crossley contact model |
| OpenSim::Ligament | A class implementing a ligament |
| OpenSim::PointToPointSpring | |
| OpenSim::PrescribedForce | This applies to a body a force and/or torque that is fully specified as a
function of time |
| OpenSim::SpringGeneralizedForce | |
| OpenSim::ForceVelocityCurve | This class serves as a serializable ForceVelocityCurve, for use in muscle models |
| OpenSim::ForceVelocityInverseCurve | This class serves as a serializable ForceVelocityInverseCurve, for use in equilibrium muscle models |
| OpenSim::GeometryPath | A base class representing a path (muscle, ligament, etc.) |
| OpenSim::Joint | A class implementing an OpenSim Joint |
| OpenSim::BallJoint | A class implementing an Ball joint |
| OpenSim::CustomJoint | A class implementing a custom joint |
| OpenSim::EllipsoidJoint | A class implementing an Ellipsoid joint |
| OpenSim::FreeJoint | A class implementing a Free joint |
| OpenSim::PinJoint | A class implementing an Pin joint |
| OpenSim::SliderJoint | A class implementing an Slider joint |
| OpenSim::UniversalJoint | A class implementing a Universal joint |
| OpenSim::WeldJoint | A class implementing an Weld joint |
| OpenSim::Model | A concrete class that specifies the interface to a musculoskeletal model |
| OpenSim::Probe | This class represents a Probe which is designed to query a Vector of model values given system state |
| OpenSim::ActuatorForceProbe | ActuatorForceProbe is a ModelComponent Probe for computing an operation on a force or sum of forces in the model during a simulation |
| OpenSim::ActuatorPowerProbe | ActuatorPowerProbe is a ModelComponent Probe for computing an operation on a actuator power or sum of actuator powers in the model during a simulation |
| OpenSim::JointInternalPowerProbe | JointInternalPowerProbe is a ModelComponent Probe for computing an operation on internal joint power or sum of joint powers in the model during a simulation |
| OpenSim::SystemEnergyProbe | SystemEnergyProbe is a ModelComponent Probe for computing an operation on a total system energy during a simulation |
| OpenSim::TendonForceLengthCurve | This class serves as a serializable TendonForceLengthCurve, for use in muscle models |
| OpenSim::ModelScaler | A class for scaling a model |
| OpenSim::MuscleFirstOrderActivationDynamicModel | This function is a muscle modeling utility class that computes the derivative of activation with respect to time time using a modification of the activation model presented in Thelen 2003 |
| OpenSim::MuscleFixedWidthPennationModel | This is a class that acts as a utility class that contains all of the necessary kinematic equations required to use a fixed width parallelogram pennation model to compute the way the muscle fibers deform as the muscle contracts |
| OpenSim::ObjectGroup | A class implementing an object group |
| OpenSim::OpenSimContext | Class intended to keep the SimTK::State under an OpenSim model to make it possible
to get/set values in the SimTK::State without exposing the SimTK::State class itself |
| OpenSim::OpenSimJavaObject | In some cases, the GUI ad/or scripting language needs to create objects that derive from OpenSim::Object The class OpenSim::Object however is not a concrete class, so we introduce OpenSimJavaObject for this purpose |
| OpenSim::PathPoint | A class implementing a path point |
| OpenSim::ConditionalPathPoint | A class implementing a conditional path point, which is a point that is active only for a specified range of a coordinate |
| OpenSim::MovingPathPoint | A class implementing a moving muscle point, which is a muscle point that moves in a body's reference frame as a function of a coordinate |
| OpenSim::Reference_< T > | This base (abstract) class defines the interface for objects repsonsible in identifying a model output and its Reference value to be achieved via optimization and/or tracking |
| OpenSim::Scale | |
| OpenSim::ScaleTool | A class implementing a set of parameters describing how to scale a model to fit a subject, place markers on it, and do IK on one or more motion trials |
| OpenSim::Set< T > | A class for holding a set of pointers to objects |
| OpenSim::ModelComponentSet< T > | This is the base class for sets of ModelComponent subclasses |
| OpenSim::SimbodyEngine | A wrapper class to use the SimTK Simbody dynamics engine as the underlying engine for OpenSim |
| OpenSim::Solver | The base (abstract) class for a family of objects repsonsible for solving system equations (statics, dynamic, kinematics, muscle, etc...) given by a model for values of interest |
| OpenSim::AssemblySolver | Solve for the coordinates (degrees-of-freedom) of the model that satisfy the set of constraints imposed on the model as well as set of desired coordinate values |
| OpenSim::InverseKinematicsSolver | Solve for the coordinates (degrees-of-freedom) of the model that satisfy the set of constraints imposed on the model as well as set of desired coordinate values |
| OpenSim::InverseDynamicsSolver | Solve for the generalized coordinate coordinate forces (1 per degree-of-freedom) that satisfy the unconstrained equations of motion given kinemtics: q, u, u_dot |
| OpenSim::MomentArmSolver | Solve for the effective moment arms at all degrees-of-freedom due to one or more point forces |
| OpenSim::SpatialTransform | A class encapsulating the spatial transformation bewteen two bodies that defines the behaviour of a custom joint |
| OpenSim::StorageInterface | |
| OpenSim::Storage | |
| OpenSim::Tool | A Tool is an OpenSim abstraction that encapsulates an analysis or series of modeling and analysis steps |
| OpenSim::DynamicsTool | An abstract Tool for defining tools for perfroming a dynamics analysis with a given model |
| OpenSim::InverseDynamicsTool | A Tool that performs an Inverse Dynamics analysis with a given model |
| OpenSim::InverseKinematicsTool | A Tool that performs an Inverse Kinematics analysis with a given model |
| OpenSim::TrackingTask | An abstract base class for specifying a target for a tracking problem |
| OpenSim::CMC_Task | An abstract base class for specifying a task objective for a dynamic simulation |
| OpenSim::CMC_Joint | A class for specifying the tracking task for a joint |
| OpenSim::SMC_Joint | A class for specifying the tracking task for a joint |
| OpenSim::CMC_Orientation | A class for tracking the orientation of a body |
| OpenSim::CMC_Point | A class for specifying and computing parameters for tracking a point |
| OpenSim::StateTrackingTask | A target for a tracking problem that corresponds to a state variable |
| OpenSim::MuscleStateTrackingTask | A TrackingTask for that corresponds to a muscle state variable |
| OpenSim::TransformAxis | A class expressing a transformation of a child body in relation to a parent body along either a translation or rotation axis |
| OpenSim::VectorFunction | |
| OpenSim::VectorFunctionUncoupledNxN | |
| OpenSim::VectorFunctionForActuators | |
| OpenSim::VisibleObject | Class VisibleObject is intended to be used as the base class for all Visible objects that subclass Object |
| OpenSim::Reference_< double > | |
| OpenSim::CoordinateReference | Reference value to be achieved for a specified coordinate that will be used via optimization and/or tracking |
| OpenSim::Reference_< SimTK::Vec3 > | |
| OpenSim::MarkersReference | |
| OpenSim::Set< Analysis > | |
| OpenSim::AnalysisSet | |
| OpenSim::Set< Body > | |
| OpenSim::ModelComponentSet< Body > | |
| OpenSim::BodySet | A class for holding a set of bodies |
| OpenSim::Set< BodyScale > | |
| OpenSim::BodyScaleSet | A class for holding a set of body scales |
| OpenSim::Set< Constraint > | |
| OpenSim::ModelComponentSet< Constraint > | |
| OpenSim::ConstraintSet | A class for holding a set of constraints |
| OpenSim::Set< ContactGeometry > | |
| OpenSim::ModelComponentSet< ContactGeometry > | |
| OpenSim::ContactGeometrySet | A class for holding a set of ContactGeometry objects |
| OpenSim::Set< Control > | |
| OpenSim::ControlSet | |
| OpenSim::Set< Controller > | |
| OpenSim::ModelComponentSet< Controller > | |
| OpenSim::ControllerSet | A class for holding and managing a set of controllers for a model |
| OpenSim::Set< Coordinate > | |
| OpenSim::ModelComponentSet< Coordinate > | |
| OpenSim::CoordinateSet | A class for holding a set of coordinates |
| OpenSim::Set< DisplayGeometry > | |
| OpenSim::GeometrySet | |
| OpenSim::Set< ExternalForce > | |
| OpenSim::ModelComponentSet< ExternalForce > | |
| OpenSim::ExternalLoads | A convenience class for managing ExternaForce(s) to be applied to a model |
| OpenSim::Set< Force > | |
| OpenSim::ModelComponentSet< Force > | |
| OpenSim::ForceSet | A class for holding and managing a set of forces for a model |
| OpenSim::Set< Function > | |
| OpenSim::FunctionSet | |
| OpenSim::GCVSplineSet | |
| OpenSim::Set< IKTask > | |
| OpenSim::IKTaskSet | |
| OpenSim::Set< Joint > | |
| OpenSim::ModelComponentSet< Joint > | |
| OpenSim::JointSet | A class for holding a set of joints |
| OpenSim::Set< Marker > | |
| OpenSim::MarkerSet | A class for holding a set of markers for inverse kinematics |
| OpenSim::Set< MarkerPair > | |
| OpenSim::MarkerPairSet | A class for holding a set of SimmMarkerPairs |
| OpenSim::Set< Measurement > | |
| OpenSim::MeasurementSet | A class for holding a set of measurements |
| OpenSim::Set< ModelComponent > | |
| OpenSim::ModelComponentSet< ModelComponent > | |
| OpenSim::ComponentSet | A class for holding a set of miscellaneous model components |
| OpenSim::Set< PathPoint > | |
| OpenSim::PathPointSet | A class for holding a set of muscle points |
| OpenSim::Set< Probe > | |
| OpenSim::ModelComponentSet< Probe > | |
| OpenSim::ProbeSet | A class for holding a set of probes |
| OpenSim::Set< Scale > | |
| OpenSim::ScaleSet | |
| OpenSim::Set< TrackingTask > | |
| OpenSim::CMC_TaskSet | An class for holding and managing a set of tasks |
| OpenSim::OptimizationTarget | This class provides an interface specification for optimizing redundant systems |
| OpenSim::ActuatorForceTarget | A Computed Muscle Control (CMC) optimization target for controlling dynamic systems whose actuators may be themselves governed by differential equations, meaning there may be non-linear behavior and delays in force production |
| OpenSim::ActuatorForceTargetFast | A Computed Muscle Control (CMC) optimization target for controlling dynamic systems whose actuators may be themselves governed by differential equations, meaning there may be non-linear behavior and delays in force production |
| osimInstantiator | |
| OpenSim::PointForceDirection | Convenience class for a generic representation of geomtery of a complex Force (or any other object) with multiple points of contact through which forces are applied to bodies |
| OpenSim::MuscleAnalysis::private | |
| OpenSim::PropertyGroup | A class implementing a property group |
| OpenSim::PropertyHelper | This class allows access to property values using template-free methods |
| OpenSim::PropertySet | A property set is simply a set of properties |
| OpenSim::PropertyTable | A property table is the container that an OpenSim Object uses to hold its properties (each derived from base class AbstractProperty) |
| OpenSim::RootSolver | A class for finding the N roots of N one-dimensional non-linear equations |
| OpenSim::SegmentedQuinticBezierToolkit | This is a low level Quintic Bezier curve class that contains functions to design continuous sets of 'C' shaped Bezier curves, and to evaluate their values and derivatives |
| OpenSim::Signal | A class for signal processing |
| OpenSim::SmoothSegmentedFunction | This class contains the quintic Bezier curves, x(u) and y(u), that have been created by SmoothSegmentedFunctionFactory to follow a physiologically meaningful muscle characteristic |
| OpenSim::SmoothSegmentedFunctionFactory | This is a class that acts as a user friendly wrapper to QuinticBezerCurveSet to build specific kinds of physiologically plausible muscle curves using C2 continuous sets of quintic Bezier curves |
| OpenSim::StateVector | A class which stores a vector of states or data at a specified time |
| OpenSim::StaticOptimizationTarget | This class provides an interface specification for static optimization Objective Function |
| OpenSim::StorageCreator | |
| OpenSim::StorageFactory | |
| OpenSim::Property< T >::TypeHelper | This is the generic definition of Property::TypeHelper to be used
whenever T does not have a specialization, meaning that T must be a type derived from class Object |
| OpenSim::Units | A class implementing various units for measuring quantities |
| OpenSim::XMLDocument | |
1.8.1.2 
