Actin®  Version 5.1.0
Software for Robotics Simulation and Control
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 1234]
 NEcEnergid common namespace
 Necboost
 Nosg
 CanalogDigitalIoPluginPlugin to interface with analog and digital IO modules
 CdigitalIOXmlConfig
 CEc2DShapeContainerHolds a container for a 2dShapes
 CEc3DTransformationToolsProvides a tool for 3D transformation calculation
 CEc600CellProvides a tool for operating with a 600-cell, a four-dimensional regular polytope for 3-D orientation analysis
 CEc7zipUtil
 CEcAccelerationLimiterHolds a class that limits joint accelerations
 CEcAccelerationStateHolds a description of the acceleration state of a manipulator. This includes the joint accelerations and the acceleration of the base. The base acceleration is the motion of the base with respect to the manipulator system frame, expressed in manipulator system frame coordinates, with point of application at the origin of the base frame
 CEcAccelerometerEndEffectorA vector alignment end effector
 CEcActinLicenseHandleInstantiate this class to receive a valid Actin license and use Actin SDK
 CEcActionDirectionConcrete implementation of EcManipulationDirection for running EcManipulationAction directions from the director
 CEcActionDirectionSimpleStateConcrete implementation of EcManipulationSceneDirectionSimpleState for action direction
 CEcActionIssuesBasic issues for manipulation actions
 CEcActualPlacementGraspOffsetThis class provides a grasp offset that uses the initial actual EE placement and remains constant throughout the update
 CEcActualPlacementGraspOffsetStateThis class provides a grasp offset that uses the initial actual EE placement and remains constant throughout the update
 CEcActualPlacementManipulationOffsetStateThis class provides a manipulation offset that uses the initial actual EE placement and remains constant throughout the update
 CEcActualPlacementOffsetThis class provides a manipulation offset that uses the initial actual EE placement and remains constant throughout the update
 CEcActuationMechanismContainerHolds a container for power converter description
 CEcActuatorDynamicSimulatorHolds a dynamic simulator for an individual manipulator
 CEcActuatorStateHolds a description of an actuator state
 CEcAdamsBashforthMoultonHolds a class implementing Adams-Bashforth predictor, Adams-Moulton corrector method for numerical integration
 CEcAdmittanceControlToolHolds an admittance control tool class. Currently only works for 6 joints
 CecAdmittanceControlToolHolds an admittance control tool class. Currently only works for 6 joints
 CEcAlignmentDirectionThis represents a path
 CEcAlignmentDirectionStateA state for the alignment action
 CEcAnalogChannelBaseA base class interface for an analog input or output channel
 CEcAnalogDigitalIoModuleBaseProvides a general interface for analog and digital IO boards
 CEcAnalogDigitalIoModuleDataData for analog and digital IO modules
 CEcAnalogDigitalIoPluginConfiguration
 CEcAnalogDigitalIoSensorValueConditionConcrete implementation of EcDirectionCondition for determining if a specified sensor holds a specified value
 CEcAnalogDigitalIoSensorValueSetDirectionConcrete implementation of EcStageDirection for setting a custom sensor value
 CEcAnalogInputChannelBaseA base class interface for an analog input channel
 CEcAnalogOutputChannelBaseA base class interface for an analog output channel
 CEcAndDirectionConditionConcrete implementation of EcBinaryDirectionCondition for returning the logical AND of two conditions
 CEcAngleA class to define an angle, with values in the range [-Pi, Pi]
 CEcAntiCollisionPositionControllerHolds a description of a position controller for one manipulator
 CEcAntiCollisionPriorityListHolds definition of a priority list used in anti-collision
 CEcAppendSceneVisitorVisitor implementation for appending a scene
 CEcApplicationSetup
 CEcApproachAttachSolutionFindingDirection
 CEcArbiAccelerationToolProvides a tool for calculating joint accelerations using articulated rigid-body inertia
 CEcArticulatedBodyDynamicsHolds articulated rigid body mass properties and bias forces
 CEcArticulatedBodyInertiaHolds articulated rigid body mass properties. These include a 3x3 symmetric linear term, a 3x3 symmetric angular term, and a cross term. If these were formed into a 6x6 spatial inertia matrix, it would be as follows: | Jl Jc | J = | | | Jc^T Ja | Note that for rigid bodies, Jc = H^T, where H is the cross-product matrix for the first moment of inertia
 CEcAssignObjectRoleDirectionConcrete implementation of EcStageDirection for selecting the role to use as the object in object-relative actions
 CEcAttachmentMapStateHolds the active state for a manipulator attachment map
 CEcAttachmentNodeStateHolds the state for a manipulator attachment node
 CEcAttachToDirectionConcrete implementation of EcStageDirection for attaching the role to a specified link of another role in the scene
 CEcAttachToNamedFrameDirectionConcrete implementation of EcStageDirection for attaching the role to a specified link of another role in the scene using named frames
 CEcAxisAlignedBoundingBoxHolds a class to describe an axis aligned bounding box (AABB)
 CEcAxisAlignedBoundingBoxToolHelper class to create axis-aligned bounding box
 CEcAxisRotateEndEffectorAn end effector with 1-dof rotation
 CEcBalovnevBucketExcavationInteractionDefines a class for computing bucket excavation force using Balovnev model
 CEcBalovnevExcavationInteractionDefines a class for computing blade excavation force using Balovnev model
 CEcBaseAccelerationDataCaptureTypeA class for capturing base accelerations
 CEcBaseActuationMechanismA base class describing the mechanism converting prime mover motion into joint motion
 CEcBaseCollisionForceProcessorThe abstract base class for processing collision force between two shapes
 CEcBaseContinuousDynamicSystem
 CEcBaseControlInputConverterHolds a base class for a system that converts control torques to control inputs
 CEcBaseControlSystemModifierBase control system modifier
 CEcBaseDiscreteDynamicSystem
 CEcBaseDissipativeForceProcessorDefines a base class for all dissipative force processors
 CEcBaseEndEffectorMotionBase end effector motion class for one end effector
 CEcBaseEndEffectorPathGeneratorAn abstract base class for generating end-effector paths. These paths can be used in any study but perhaps are most appropriate for reachability study
 CEcBaseEndEffectorPlacementConverterBase class for end-effector placement converter
 CEcBaseEndEffectorSetMotionBase end-effector set motion class for one set of motion constraint
 CEcBaseExcavationInteractionAn abstract base class for computing excavation forces
 CEcBaseExpressionTreeContainerHolds an abstract base class for a logical expression tree
 CEcBaseExpressionTreeElementAbstract base class for the element types of EcBaseExpressionTreeContainer
 CEcBaseExpressionTreeSharedContainerHolds an abstract base class for a logical expression tree
 CEcBaseForceControllerThe base class for force controller
 CEcBaseGeneralBoundObjectDefines a base class for geometric objects that do not belong to any link
 CEcBaseHandGraspingModuleThis class is a base class for hand grasping modules
 CEcBaseIndividualJointControllerHolds a description of a feedback controller for a single joint
 CEcBaseIntegratorHolds a base class for numerical integrator, used primarily in dynamic simulation
 CEcBaseInterpolatedEndEffectorMotionBase interpolated end effector motion class for one end effector
 CEcBaseJointActuatorA base class describing a joint actuator. In includes inertia, friction, and gear ratio
 CEcBaseJointControllerSystemHolds a base class for joint controllers, which provides an interface for all joint controllers. It is initialized with a manipulator system, and then given an actual state and a desired state to use to calculate the joint torques
 CEcBaseLinkInteractionsA base class describing interactions between links and other links or the environment. The result of interaction is a force induced on the link
 CEcBaseLinkInterfaceA base class describing a link interface used to attach objects to links
 CEcBaseManipulationSceneVirtual base class for manipulation scenes
 CEcBaseManipulationSceneSimpleStateAbstract class defining the interface for manipulation scene states
 CEcBaseManipulationSceneStateAbstract class defining the interface for manipulation scene direction states
 CEcBaseManipulatorJointControllerHolds a base class for feedback controllers for an entire manipulator
 CEcBaseManipulatorMotionBase manipulator motion class for a manipulator
 CEcBaseManipulatorMotionExcludeCollisionBase class for excluding/including collision check
 CEcBaseMechanicalActuatorComponent
 CEcBaseMotionFilterFilter for motion of the base of the robot TODO
 CEcBaseMotionScriptContainerBase motion script container class
 CEcBaseMotionScriptDefineVariableBase class for defining variable
 CEcBaseMotionScriptSetDataMapHolds a base class of motion script for setting data map
 CEcBaseMotionScriptVariableBase class of motion script variable type
 CEcBaseMotionScriptVariableTypeBase class of motion script variables
 CEcBaseMultivariableConstraintAbstract base class for multivariable constraint
 CEcBaseNalpeironLicenseFunctionsBase class for Nalpeiron license functions
 CEcBaseOrientationSamplerBase class for sampling the orientation space
 CEcBaseOutputWriterHolds a base class for writing output to files
 CEcBasePathPlanningSequenceDirection
 CEcBasePhysicalExtentHolds a description of a physical extent (surface) of a rigid body
 CEcBasePhysicalExtentConverterHolds a description of a base class for converting other object formats to XML physical extents
 CEcBasePositionDataCaptureTypeA class for capturing base positions
 CEcBasePowerConverterA base class describing the power converter part of a joint actuator
 CEcBasePreferencePageBase class for preference pages
 CEcBaseRiccatiEquationSolver
 CEcBaseRigidWheelSoilInteractionAn base class for computing interaction force between rigid wheel and soil
 CEcBaseScalarFunctionHolds a description of a base class defining a function that one-to-one maps the range 0-1 to the domain 0-1. It represents a scalar function that must be monotonically increasing
 CEcBaseShapeDataCache
 CEcBaseSimulationLoaderHolds a base class for loading systems from various file types
 CEcBaseSoftConstraintHandlerHolds a description of a base soft end-effector constraint handler TODO
 CEcBaseSplineBase spline class
 CEcBaseStageIGraspingModuleThis class is a base class for stage I grasping
 CEcBaseStageIIGraspingModuleThis class is a base class for stage I grasping
 CEcBaseStageIIIGraspingModuleThis class is a base class for stage I grasping
 CEcBaseStateConstraintAbstract base class for position state constraint
 CEcBaseStateEqualityConstraintAbstract base class for position state restriction
 CEcBaseStochasticContinuousDynamicSystem
 CEcBaseStochasticDiscreteDynamicSystem
 CEcBaseStoppingCriterionA base class describing a criterion for stopping the arm
 CEcBaseStudyAn abstract base class for a study
 CEcBaseSystemDataComponentHolds a base class for elements of system data description
 CEcBaseSystemLoaderHolds a base class for loading systems from various file types
 CEcBaseThreadWorkerBase class of thread worker
 CEcBaseTrajectoryGeneratorBase class for trajectory generator
 CEcBaseUnitaryMapHolds a description of a base class defining a function that one-to-one maps the range 0-1 to the domain 0-1. It represents a scalar function that must be monotonically increasing
 CEcBaseVelocityDataCaptureTypeA class for capturing base velocities
 CEcBaseViewerMainWidgetA widget class used to render our stated system and is the main rendering widget for the Viewer application
 CEcBaseViewerMainWindowThe main window for Viewer
 CEcBaseXmlBasicTypeHolds the parent class for all XML basic types
 CEcBaseXmlFactoryAn abstract base class for XML object factories
 CEcBasicDirectionIssuesConcrete implementation of EcManipulationSceneDirectionIssues for holding basic issues
 CEcBasicDirectionSimpleStateConcrete implementation of EcManipulationSceneDirectionSimpleState for holding basic state information
 CEcBasicStudyHolds a description of basic study that corresponds to a single simulation run
 CEcBasicStudyVectorA vector of classes derived from EcBasicStudy
 CEcBBTreeHeuristicHolds a class used to describe the heuristic used by the BB tree for determining when decompose the tree further
 CEcBezierInterpolatorWaypoint interpolator using cubic Bezier curve
 CEcBinaryDirectionConditionAbstract EcDirectionCondition for binary operations on two conditions
 CEcBisectionGraspContactLocatorCompute contact points and normals using bisection method
 CEcBoostAssignUsage
 CEcBoostConversionUsage
 CEcBoostFilesystemUsage
 CEcBoostForeachUsage
 CEcBoostFormatUsage
 CEcBoostIostreamsUsage
 CEcBoostNumericUsage
 CEcBoostProgramOptionsUsage
 CEcBoostRegexUsage
 CEcBoostSignalsUsage
 CEcBoostSmartPtrUsage
 CEcBoostThreadPluginWorkerBoost thread worker
 CEcBoostThreadUsage
 CEcBoothFunctionProvides an example function for testing
 CEcBoundingVolumeHierarchyNodeHolds a class to describe a node of the bounding volume hierarchy
 CEcBoundingVolumeHierarchyProcessorThe broad-phase is used for computing pairs and performing volume queries and ray casts. This broad-phase does not persist pairs. Instead, this reports potentially new pairs. It is up to the client to consume the new pairs and to track subsequent overlap
 CEcBoxHolds a class to describe a 3D oriented bounding box
 CEcBoxDistanceAlgorithmClass for distance algorithm involving box
 CEcBoxEndEffectorPathGeneratorA class for generating end-effector path in a box-shaped work envelope
 CEcBoxLozengeHolds a class to describe a 3D box lozenge (fixed distance from a box)
 CEcBoxLozengeDistanceAlgorithmClass for distance algorithm involving box lozenge
 CEcBoxTreeNodeA bounding box tree. This is a tree of axis aligned bounding boxes for fast detection of static bodies in the environment. The tree is built once on load
 CEcBrickThe class holds a list of indices and a data value for a block
 CEcBroadphaseCollisionProcessorTests for overlap between links using AABBs. This is a slow test: O(n^2) where n is the number of bounding volumes
 CEcCameraA base camera window is used as an additional view into an existing scene. It will share the rendering resources with the main window, but provide its own display and viewer attributes in addition to a separate EcPovParameter
 CEcCameraViewExampleHolds the code for creating camera view example
 CEcCapsuleHolds a class to describe a 3D capsule (a distance from a line segment)
 CEcCapsuleDistanceAlgorithmClass for distance algorithm involving capsule
 CEcCapsuleFittingMethods for fitting to a capsule
 CEcCenterOfMassDataCaptureTypeA class for capturing center of mass
 CEcCenterOfMassEndEffectorA center-of-mass constraint
 CEcChangeControlDescriptionDirectionConcrete implementation of EcManipulationDirection that changes the active control description
 CEcChangeControlDescriptionDirectionStateA manipulation sequence
 CEcCharacterTemplateMatchEcCharacterMatch helper class for performing template match methods
 CEcCheckBoxEditor
 CEcChunkInfoChunk info
 CEcCircleHolds a description of a circle (disk) in 3D
 CEcCircleFittingMethods for fitting to a circle
 CEcCirclePathExampleDirectionConcrete implementation of EcManipulationDirection for moving along a circle path
 CEcCirclePathExampleDirectionEditorConcrete implementation of EcManipulationSceneDirectionEditor for creating EcCirclePathExampleDirectionWidget
 CEcCirclePathExampleDirectionStateConcrete implementation of EcManipulationSceneDirectionState for holding EcCirclePathExampleDirection state information
 CEcCirclePathExampleDirectionWidget
 CEcCircularBufferHolds a circular buffer
 CEcCircularLozengeHolds a class to describe a 3D circular lozenge (fixed distance from a filled 3D circle)
 CEcCircularLozengeDistanceAlgorithmClass for distance algorithm involving circular lozenge
 CEcCircularLozengeFittingMethods for fitting to a circular lozenge
 CEcCleverPositionControlMethodHolds a description of a position control method, which automatically adjusts the soft constraint weight as the robot move closer to the goals
 CEcClientApiThis DLL sends joint commands from a client application to a responder application
 CEcClusterContainer class for cluster algorithms
 CEcClusterableBase class for clusterable objects
 CEcClusterablePointClass cluster point
 CEcClusterableWeightedPointClass for weighted cluster point
 CEcClusterAlgorithmBase class for cluster algorithms
 CEcClusterHierarchicalClass holding hierarchical clustering algorithm
 CEcClusterKExclusiveClass holding K-mean, K-median, and K-center algorithm
 CEcCollaborativeManipulatorToolProvides a tool implementing assistive mode and collision stopping
 CEcCollisionAvoidanceConstraintThis filter avoids collisions
 CEcCollisionAvoidanceExampleHolds the collision-avoidance code described in the Users Guide
 CEcCollisionDescriptorContains a class describing a link-link collision
 CEcCollisionDistanceFunctionProvides a measure of proximity to obstacles
 CEcCollisionExclusionDataHolds description of collision exclusion data
 CEcCollisionExclusionDirectionConcrete implementation of EcStageDirection for modifying the collision exclusion map
 CEcCollisionForceContainerHolds an collision force container
 CEcCollisionForceProcessorVectorXML vector container for EcCollisionForceProcessor
 CEcCollisionProximityFunctionProvides a measure of proximity to obstacles
 CEcColorHolds a real-valued description of a color, with a transparency value
 CEcColorImageSensorA concrete class describing a color image sensor
 CEcColorImageSensorDescriptorA class describing the color part of an image sensor
 CEcComPolygonalStoppingCriterionCompute the collision force at the link level
 CEcCompositeFunctionBranchBranch provider for table functions
 CEcCompositeFunctionContainerContainer for table function tree expression
 CEcCompositeFunctionElementTable Function Base Class
 CEcComprehensiveStudyHolds a set of simple studies, each of which runs in its threads
 CEcConcurrentQueueProvides a thread safe FIFO queue data container. This container will manage threads by allowing them to wait until elements are available to pop. This is used manage work flow in a mulitple producer/consumer threading model
 CEcConditionalDirectionConcrete implementation of EcManipulationDirection for running conditional directions from the director
 CEcConditionalDirectionSimpleStateConcrete implementation of EcManipulationSceneDirectionSimpleState for conditional direction
 CEcConditionalDirectionStateConcrete implementation of EcManipulationSceneDirectionState for holding EcConditionalDirection state information
 CEcConditionalJointStateConstraintA state constraint the uses a conditional constraint for joint state
 CEcConeHolds a class to describe a 3D Cone
 CEcConeDistanceAlgorithmClass for distance algorithm involving cone
 CEcConeFittingMethods for fitting to a cone
 CEcConicalLozengeHolds a class to describe a 3D conical lozenge (fixed distance from a cone)
 CEcConicalLozengeDistanceAlgorithmClass for distance algorithm involving conical lozenge
 CEcConsolePerformGraspCallbacksSimple implementation of EcPerformGraspCallbacks
 CEcConstantGraspOffsetThis class provides a grasp offset that remains constant
 CEcConstantGraspOffsetStateThis class provides a grasp offset that remains constant
 CEcConstantIndividualJointControllerHolds a description of a feedback controller for a single joint
 CEcConstantManipulationOffsetStateThis class provides a manipulation offset that remains constant
 CEcConstantOffsetThis class provides a manipulation offset that remains constant
 CEcContactNormalToolTool to find contact normals on a shape
 CEcContactRegionHolds a description of a region of contact for a body
 CEcContinueDirectionConcrete implementation of EcStageDirection that simply returns true. This is useful to use in exceptions for conditional directions
 CEcContinuousTimeKalmanFilter
 CEcControlExpressionABCoreThe core velocity control algorithm is represented through this class. A matrix A, vector B, and scalar S are used to define the control system
 CEcControlExpressionAccelerationMinimizerThis expression returns a vector that will minimize joint/base acceleration
 CEcControlExpressionCollisionAvoidanceABThis expression returns a vector that can be used in the velocity control system to drive the manipulator away from obstacles
 CEcControlExpressionCollisionAvoidanceFilterThis filter avoids collisions
 CEcControlExpressionColumnTableFunctionThis evaluates a table function on the child. The input and the output are columns
 CEcControlExpressionContainerHolds a control-system-based mathematical expression. This class inherits from EcExpressionContainer, and adds a pointer to an individual manipulator, an end effector, a desired end-effector velocity, and a time step
 CEcControlExpressionConvergenceToolHolds a base class for a joint solution finder
 CEcControlExpressionCoreThe core velocity control algorithm is represented through this class.A matrix W, vector F, and scalar S are used to define the control system
 CEcControlExpressionDescriptionA class containing EcControlExpressionContainer and a label
 CEcControlExpressionEndEffectorErrorFilterHolds the description of the end-effector error filter
 CEcControlExpressionEndEffectorErrorFilterWithCollFilteredStopThis behaves exactly like End Effector Error Filter, but doesn't stop on collision between manipulators excluded by the exclusion map defined here
 CEcControlExpressionEndEffectorErrorWeightsThis returns a matrix of weights as provided by the end effectors
 CEcControlExpressionEndEffectorMotionFilterThis limits the ratio of a measure of the joint rates to the hand motion
 CEcControlExpressionErrorReductionThis expression returns a vector that will drive joints toward a singularity. The negative will drive away from a singularity
 CEcControlExpressionErrorSensitivityThis expression returns the gradient of an error sensitivity function
 CEcControlExpressionGenConstraintAvoidanceThis solves multiple types of constraints
 CEcControlExpressionGravitationalTorqueGradientThis expression returns the gradient of the gravitational torque/force squared on a single joint
 CEcControlExpressionJointConstraintAvoidanceThis expression returns a vector that will drive joints away from constraints
 CEcControlExpressionJointLimitAvoidanceThis expression returns a vector that will drive joints away from limits
 CEcControlExpressionJointLimitFilterThis caps the weighted infinity norm of the joint rates
 CEcControlExpressionJointRateFilterThis caps the weighted infinity norm of the joint rates
 CEcControlExpressionJointValueAn element of an expression tree. Holds a joint value
 CEcControlExpressionLinkControlledNominalJointDeviationThis expression returns a value that will try to keep a single joint close to a nominal position, i.e. minimize deviation from the nominal joint position
 CEcControlExpressionMassMatrixThis expression returns the mass matrix of the manipulator
 CEcControlExpressionMassMatrixABThis expression returns the mass matrix of the manipulator
 CEcControlExpressionMatrixToABThis expression element converts a full matrix (as would be appropriate for control core) to an AB matrix value (as would be appropriate for control AB core)
 CEcControlExpressionNominalConfigDeviationThis expression returns a value that will try to keep joint configuration close to a defined nominal joint configuration (may come from nominal manipulator's current joint configuration) , i.e. minimize deviation from the nominal joints. The scalar for this vector should be negative
 CEcControlExpressionNominalJointDeviationThis expression returns a value that will try to keep a single joint close to a nominal position, i.e. minimize deviation from the nominal joint position
 CEcControlExpressionObstacleAvoidanceThis expression returns a vector that can be used in the velocity control system to drive the manipulator away from obstacles
 CEcControlExpressionObstacleAvoidanceABThis expression returns a vector that can be used in the velocity control system to drive the manipulator away from obstacles
 CEcControlExpressionPathAdherenceThis expression returns a vector that can be used in the velocity control system to drive the manipulator away from obstacles
 CEcControlExpressionPlanarTracksFilterThis yields the tracks behavior
 CEcControlExpressionPointMotionFilterThis expression element caps the velocity of point
 CEcControlExpressionPotentialEnergyGradientThis expression returns the potential-energy gradient of the manipulator
 CEcControlExpressionSimulationFilterThis simulates forward in time to verify the effectiveness of the current joint rate commands
 CEcControlExpressionSingularityAvoidanceThis expression returns a vector that will drive joints toward a singularity. The negative will drive away from a singularity
 CEcControlExpressionStrengthOptimizationThis expression returns a vector that will drive joints toward a singularity. The negative will drive away from a singularity
 CEcControlExpressionVectorToABThis expression element converts a full vector (as would be appropriate for control core) to an AB vector value (as would be appropriate for control AB core)
 CEcControlInputConverterContainerHolds a container for a system that converts the control torques to control inputs
 CEcControlInputDataCaptureTypeA class for capturing control inputs
 CEcControlInterfaceHolds a class for efficiently interfacing the Cyton arm with Actin
 CEcControlOutputActualJointVelocityDataCaptureTypeA class for capturing actual joint velocites
 CEcControlOutputJointPositionDataCaptureTypeA class for capturing joint positions that are the output of the position control system
 CEcControlOutputJointVelocityDataCaptureTypeA class for capturing joint velocities that are the output of the position control system
 CEcControlParametersA class containing control parameters
 CEcControlSystemExecutiveModifierBase control system modifier
 CEcControlSystemPluginModifierBase control system modifier
 CEcControlTorqueDataCaptureTypeA class for capturing control torques
 CEcConvergenceToolA tool class used to find a joint solution given a goal end effector placement
 CEcConvergenceToolContainerHolds a container for EcConvergenceTool
 CEcConversionToolProvides a tool for coverting other formats to XML
 CEcConvexDistanceAlgorithmClass for distance algorithm involving convex shapes
 CEcConvexHullHolds a wrapper class for implementing qHull–the convex hull generating algorithm
 CEcCoordinatedJointEndEffectorA class for end effector that is used for coordinated joint control
 CEcCoordinatedJointEndEffectorToolProvides a tool for setting EE placement for EcCoordinatedJointEndEffector
 CEcCoordinateSystemTransformationA rotation and a translation to describe a new frame
 CEcCoordJointPositionControlMethodHolds a description of a position control method, which uses coordinated joint control to move to desired placements
 CEcCoreResultHolds a description of the result of the execution of the core velocity control algorithm (either regular or AB)
 CEcCoreVelocityControlToolProvides a tool for velocity control
 CEcCosimulationForceCompute the external cosimulation force(s)
 CEcCosimulationModuleBaseCompute the external cosimulation force(s)
 CEcCrashHandler
 CEcCrbiAccelerationToolProvides a tool for gravitational torque/force and gradients
 CEcCubicBezierSplineCubic Bezier spline
 CEcCubicSplineCubic spline
 CEcCustomFileDialog
 CEcCustomTypeLinkA type of joint to rotate and translate at the same time
 CEcCycloidTrajectoryGeneratorBase class for end-effector placement converter
 CEcCylinderHolds a class to describe a 3D Cylinder
 CEcCylinderDistanceAlgorithmClass for distance algorithm involving cylinder
 CEcCylinderFittingMethods for fitting to a cylinder
 CEcCylindricalLozengeHolds a class to describe a 3D cylindrical lozenge (fixed distance from a cylinder)
 CEcCylindricalLozengeDistanceAlgorithmClass for distance algorithm involving cylindrical lozenge
 CEcCytonControlInterfaceHolds a class for efficiently interfacing the Cyton arm with Actin
 CEcDamperPropertiesDefines the damper force on a joint as a function of its rate and the rates of other joints
 CEcDataCaptureTypeAn abstract base class for capturing and storing the data
 CEcDataCaptureTypeVectorHolds a description of a vector of general data capture configurations
 CEcDataElementAccessor
 CEcDataMapHolds data organized by string maps
 CEcDataMapValueConditionConcrete implementation of EcDirectionCondition for determining if a specified EcDataMap Variabl holds a specified value
 CEcDataMapValueReadDirectionConcrete implementation of EcStageDirection for setting a custom variable value
 CEcDataMapValueReadDirectionStateConcrete implementation of EcManipulationSceneDirectionState for holding EcDataMapValueReadDirection state information
 CEcDataMapValueSetDirectionConcrete implementation of EcStageDirection for setting a custom variable value
 CEcDataPlotParametersHolds a description of parameters to control the data plots in the GUI viewer
 CEcDcElectricMotorA class describing power conversion by a DC electric motor
 CEcDcMotorSystemIdentifierDC motor robot system identification class used to estimate the actuator efficiency, friction model and actuator inertia
 CEcDeadlineTimer
 CEcDebugParseInfoHandlerA handler for debug parse info
 CEcDecisionTreeArticulatedModelBranchThis class tests an object for an articulated model
 CEcDecisionTreeBoxBranchThis class tests an object for a box
 CEcDecisionTreeCapsuleBranchThis class tests an object for a capsule
 CEcDecisionTreeConvexBranchThis class tests an object for edges
 CEcDecisionTreeFamilyBranchThis class tests an object for edges
 CEcDecisionTreePassThroughBranchThis class tests an object for edges
 CEcDecisionTreeShapeMatchingBranchThis class tests an object for shape matching
 CEcDecisionTreeSphereBranchThis class tests an object for edges
 CEcDefaultInputHandler
 CEcDefectivePixelsNoiseA class describing the effect of defective pixels on an image sensor
 CEcDenavitHartenbergA class to describe the Denavit-Hartenberg link parameters
 CEcDereferenceFunctor
 CEcDesiredPlacementModificationHolds a description of a modification to a desired end-effector position
 CEcDesiredPlacementPathModificationHolds a description of a modification to a desired end-effector path
 CEcDetectedComponent
 CEcDetectedComponentVertex
 CEcDigitalChannelBaseA base class interface for a digital input or output channel
 CEcDigitalInputChannelBaseA base class interface for a digital input channel
 CEcDigitalIOBaseBase class for digital IO
 CEcDigitalIOImplBase
 CEcDigitalIOXmlConfigDescribes a set of digital IO
 CEcDigitalIOXmlItemHW implimentation base class
 CEcDigitalOutputChannelBaseA base class interface for a digital output channel
 CEcDirectActuationMechanismA direct actuation mechanism converting prime mover motion directly into joint motion (no linkages)
 CEcDirectionalFrameEndEffectorA frame end effector with directional velocity and acceleration thresholds
 CEcDirectionConditionVirtual base class for direction conditions
 CEcDirectionConditionContainerContainer for direction conditions
 CEcDirectionCuesChangedVisitorVisitor implementation for changing a direction's cues
 CEcDirectOptimizerDIRECT algorithm for global optimization. Based on the paper by D. R. Jones published in the Encyclopedia of Optimization, 2001, "Direct Global Optimization Algorithm"
 CEcDirectorObjectVirtual base class for manipulation director objects
 CEcDirectorObjectContainerContainer for manipulation director objects
 CEcDirectorObjectDirectoryOrganizes multiple manipulation director objects into a directory hierarchy
 CEcDiscreteLinearTimeInvariantSystem
 CEcDiscreteTimeKalmanFilter
 CEcDisplayOptionsDisplay options for selected end effectors, collision and joint limit events
 CEcDisplayOptionsParametersParameters for displaying events such as selected end effectors, collision and joint limit
 CEcDisplaySystemDataCaptureSystem data capture for displaying (plotting) purposes
 CEcDissipativeForceInputHolds a class to convey information to the dissipative force processor
 CEcDissipativeForceOutputHolds the output data returned from the dissipative force processor
 CEcDissipativeForceProcessorHolds a class for processing dissipative forces that arise from object interaction
 CEcDissipativeForceProcessorContainerDefines a class for computing dissipative (non-conservative) forces
 CEcDistanceAlgorithmVirtual base class for distance algorithm
 CEcDistanceCalculationToolTool to compute distance between shapes
 CEcDistanceFromConditionConcrete implementation of EcDirectionCondition for determining if a role/link is within a specified distance
 CEcDisturbanceObserverNonlinear disturbance observer for estimating external forces on a manipulator joint without using acceleration state
 CEcDllLoaderWrapper for DLL and Shared Object code
 CEcDodLibraryEventParamsBase class to provide input to dod events
 CEcDodLibraryRenameEventParamsData class to provide input to dod rename events
 CEcDodObjectVisitorVirtual base class for defining visitor algorithms for manipulationAction objects
 CEcDODRemoveRoleVisitorVisitor implementation for moving a direction
 CEcDODRenameActionVisitorVisitor implementation for moving a direction
 CEcDODRenamePoseVisitorVisitor implementation for moving a direction
 CEcDODRenameRoleVisitorVisitor implementation for moving a direction
 CEcDODReplaceActionToDirectionVisitorVisitor implementation for moving a direction
 CEcDryFrictionForceProcessorHolds a class for processing dissipative forces that arise from object interaction
 CEcDummySensorStateHolds a description of a base sensor state
 CEcDynamicSimulatorSystemHolds a dynamic simulator for a manipulator system
 CEcEditorGraspFrameDataComplimentary data for a grasp frame for use in grasp editor
 CEcEditorGraspSequenceA grasp sequence for grasp editor
 CEcEEToPoseDistanceConditionConcrete implementation of EcDirectionCondition for determining if a role/link is within a specified distance
 CEcEigToolProvides a tool for calculating the eigenvalues and eigenvectors for a system of equations
 CEcElapsedTimeGeneral class for capturing elapsed time
 CEcEllipsoidHolds a class to describe an ellipsoid. The ellipsoid is described using semiaxes and an coordinate system transformation
 CEcEndEffectorHolds a base class for single end-effector components
 CEcEndEffectorAccelerationDataCaptureTypeA class for capturing end effector velocity
 CEcEndEffectorDataCaptureA base class used for configuring capture of end-effector data
 CEcEndEffectorMapHolds a description of a map of general end effectors
 CEcEndEffectorMotionInterpolatedPoseSequenceInterpolated pose sequence
 CEcEndEffectorMotionMoveCircularCircular motion
 CEcEndEffectorMotionMoveJointJoint motion
 CEcEndEffectorMotionMoveJointMixedMixed joint motion
 CEcEndEffectorMotionMoveJointRelativeRelative joint motion
 CEcEndEffectorMotionMoveLinearEnd effector linear motion
 CEcEndEffectorMotionMovePosePose motion
 CEcEndEffectorMotionMovePoseSequenceJoint motion sequence
 CEcEndEffectorMotionMovePoseWithBlendingEnd effector pose motion with blending
 CEcEndEffectorMotionProfileJointJoint motion
 CEcEndEffectorMotionProfilePoseProfiled pose motion
 CEcEndEffectorMotionSetRemoteTcpSet remote TCP for an end effector
 CEcEndEffectorMotionSetTcpSet TCP for an end effector
 CEcEndEffectorMotionSpeedJoint motion
 CEcEndEffectorMotionStopJoint motion
 CEcEndEffectorPathPlanningDirection
 CEcEndEffectorPlacementA description of an end-effector placement
 CEcEndEffectorPlacementConverterVectorVector of end-effector placement converters
 CEcEndEffectorPlacementDataCaptureTypeA class for capturing end effector placement
 CEcEndEffectorRelativeLinkDataHolds a description of the relative nature of an end effector
 CEcEndEffectorSetHolds a description of all end effectors on a manipulator
 CEcEndEffectorSetModificationHolds a description of a modification to an end-effector set
 CEcEndEffectorToolProvides a tool for calculating end effector placement and motion
 CEcEndEffectorVectorHolds a description of a vector of general end effectors
 CEcEndEffectorVelocityDataCaptureTypeA class for capturing end effector velocity
 CEcErrorReductionFunctionComputes f(q) = J'AJCe used to drive joints in a direction that minimizes velocity errors cause by high frequency noise on the joints
 CEcErrorSensitivityFunctionProvides a measure of joint error sensitivity. This measure is given by the weighted sum of the squares of errors in end-effector velocities cause by an error in a joint angle
 CEcExampleAnalogInputChannelA class for an example analog input channel The value read from this channel will trace out a sin wave from [-1,1] with a period of 1 second
 CEcExampleAnalogOutputChannelA class for an example analog output channel
 CEcExampleDecisionTreeCapsuleExample grasping model for a capsule
 CEcExampleDecisionTreeSphereExample grasping model for a sphere
 CEcExampleDigitalInputChannelA class for an example digital input channel The value read from this channel will alternate between on and off each second
 CEcExampleDigitalOutputChannelA class for an example digital output channel
 CEcExampleDockWidgetWidget containing controls and logic to view and edit named frames
 CEcExampleGraspingModuleFactoryFactory class for generating a grasping module for the grasping training
 CEcExampleIoModuleProvides an example implementation of the analog digital IO module interface
 CEcExampleReferenceCapsuleGraspInfoExample reference grasp info for a Capsule
 CEcExampleReferenceGraspInfoExample reference grasp info
 CEcExampleReferenceSphereGraspInfoExample reference grasp info for a sphere
 CEcExampleRobotFactoryFactory class for generating a robot simulation for the grasping training
 CEcExampleRobotHardwareExample implementation of a class to communicate with a robot
 CEcExampleSensorExample sensor
 CEcExampleStageIBaseGraspingThis class provides foundation stage I grasping for the example
 CEcExampleStageICapsuleGraspingThis class provides stage I capsule grasping for the example
 CEcExampleStageISphereGraspingThis class provides stage I sphere grasping for the example
 CEcExcavationForceProcessorDefines a class for computing excavation forces
 CEcExcavationInteractionContainerAn container class for computing bucket excavation forces
 CEcExcavationParametersA class containing excavation parameters
 CEcExcelExampleWorksheet parser for an example
 CEcExcelParserGeneric parser for Excel XML files
 CEcExcelWorksheetGeneric worksheet parser for Excel XML file
 CEcExceptionDirectionConcrete implementation of EcManipulationDirection for running exception directions from the director
 CEcExceptionDirectionSimpleStateConcrete implementation of EcManipulationSceneDirectionSimpleState for exception direction
 CEcExceptionDirectionStateConcrete implementation of EcManipulationSceneDirectionState for holding EcExceptionDirection state information
 CEcExchangeManipDlgDialog for exchanging manipulator
 CEcExecptionDirectionConcrete implementation of EcManipulationDirection for running exception directions from the director
 CEcExponentialFrictionModelComponentHolds a description of a friction model for a joint actuator. The model can be used to calculate the resulting output torque of the actuator based on the input (controlled) torque minus actuator resistive torques including Stribeck, Coulumb, Viscous and friction
 CEcExpressionAndAn element of an expression tree. Holds a and operator
 CEcExpressionBaseBinaryA parent of binary expressions. It loads two children. The subclass defines the operation, while this class defines reading, writing, and access
 CEcExpressionBaseUnaryA parent of unary expressions. It loads one child
 CEcExpressionContainerHolds a manipulator-based mathematical expression
 CEcExpressionCosineAn element of an expression tree. Cosine operator
 CEcExpressionDiagonalMatrixAn element of an expression tree. Holds a general (mxn) diagonal matrix
 CEcExpressionElementHolds a description of a base class for expression elements
 CEcExpressionElementInverseAn element of an expression tree. Returns an array of the same size as the child with all elements inverted
 CEcExpressionElementLogAn element of an expression tree. Returns an array of the same size as the child with all elements negated
 CEcExpressionElementLogNAn element of an expression tree. Holds a logN operator
 CEcExpressionElementPowAn element of an expression tree. Holds a pow operator
 CEcExpressionElementRootAn element of an expression tree. Returns the Nth root of the LHS child
 CEcExpressionGeneralColumnAn element of an expression tree. A general (nx1) column matrix
 CEcExpressionGreaterThanAn element of an expression tree. Holds a greater-than operator
 CEcExpressionGreaterThanOrEqualToAn element of an expression tree. Holds a >= operator
 CEcExpressionIdentityMatrixAn element of an expression tree. Holds an nxn identity matrix
 CEcExpressionLessThanAn element of an expression tree. Holds a less-than operator
 CEcExpressionLessThanOrEqualToAn element of an expression tree. Holds a less-than-equal-to operator
 CEcExpressionMinusAn element of an expression tree. Holds a difference operator
 CEcExpressionNegativeAn element of an expression tree. Returns an array of the same size as the child with all elements negated
 CEcExpressionOrAn element of an expression tree. Holds an OR operator
 CEcExpressionPlusAn element of an expression tree. Holds a plus operator
 CEcExpressionScalarConstantAn element of an expression tree. Holds a description of a scalar constant
 CEcExpressionSineAn element of an expression tree. Holds a sine operator
 CEcExpressionSingleElementColumnAn element of an expression tree. Holds a column vector with a single nonzero element
 CEcExpressionSingleElementMatrixAn element of an expression tree. Holds a general (mxn) matrix operator
 CEcExpressionTimesAn element of an expression tree. Holds a product operator
 CEcExpressionTransposeAn element of an expression tree. Returns the matrix transpose of the child
 CEcExtentExpressionBaseBinaryA parent of binary extent operators. It loads two children. The subclass defines the operation, while this class defines reading, writing, and access
 CEcExtentExpressionBaseUnaryA parent of unary expressions. It loads one child. The subclass defines the operation, while this class defines reading, writing, and access
 CEcExtentUnion
 CEcExternalForceDataCaptureTypeA class for capturing external forces
 CEcExternalForceDescriptionClass describing a general force (force and moment) and its point of application
 CEcFeedforwardKinLoopsManipulatorJointController
 CEcFeedforwardManipulatorJointController
 CEcFeedforwardManipulatorJointControllerSampleSample code for EcFeedforwardManipulatorJointController
 CEcFiniteDifferenceToolProvides a tool for calculating differential values using the method of finite differences
 CEcFixedOrientationPointEndEffectorA general end effector
 CEcFixedPatternNoiseA class representing fixed pattern noise in an image sensor
 CEcFlexGeneralSpatialEndEffectorA general end effector
 CEcFlexibleJointFramesDirectionA joint sequence
 CEcForceAchievedTransitionEventThis class provides a grasp frame transition event based on force
 CEcForceAchievedTransitionEventStateThis class provides a grasp frame transition event based on force
 CEcForceControlDescriptionHolds a description of a force control description
 CEcForceControlExampleHolds the quick-start code described in the Users Guide
 CEcForceControlFunctionThe base class for force control function
 CEcForceControlFunctionContainerThe container class for force control function
 CEcForceControllerVectorHolds a description of a vector of force controllers
 CEcForceControlSystemHolds a description of a force control system, which use a position control system
 CEcForceDetectedTransitionEventThis class provides a grasp frame transition event based on force
 CEcForceDetectedTransitionEventStateThis class provides a grasp frame transition event based on force
 CEcForceSensorImplementation of base class of force sensor
 CEcForceSensorSetHolds a description of all force sensors on a manipulator
 CEcForceSensorVectorHolds a description of a vector of force sensors
 CEcForDirectionConcrete implementation of EcManipulationDirection for running For directions from the director
 CEcForDirectionSimpleStateConcrete implementation of EcManipulationSceneDirectionSimpleState for if direction
 CEcForDirectionStateConcrete implementation of EcManipulationSceneDirectionState for holding EcForDirection state information
 CEcFourBarSliderToRotaryMechanismA four bar linkage mechanism converting prime mover's linear motion (for ex. hydraulic piston) into rotational joint motion about joint axis
 CEcFrameA single frame of a manipulation sequence
 CEcFrameBasedEndEffectorAn abstract class for end effector that uses general motion filter
 CEcFrameContainerContainer for manipulation frames
 CEcFrameEndEffectorA frame end effector
 CEcFrameRelativeGraspOffsetThis class provides a grasp offset that is relative to a grasp offset in another frame
 CEcFrameRelativeGraspOffsetStateThis class provides a grasp offset that is relative to a grasp offset in another frame
 CEcFrameRelativeManipulationOffsetStateThis class provides a manipulation offset that is relative to a manipulation offset in another frame
 CEcFrameRelativeOffsetThis class provides a manipulation offset that is relative to a manipulation offset in another frame
 CEcFrameTransitionEventAbstract class defining the interface for transition events
 CEcFrameTransitionEventContainerContainer for manipulation frame transition events
 CEcFreeSpinInZEndEffector
 CEcFrictionCoefficientLookupToolDescription of a class for looking up friction values based on link surface properties
 CEcGateTrajectoryGate trajectory planning
 CEcGaussianBlurA class representing Gaussian blur
 CEcGaussQuadratureImplements Gauss Quadrature integration
 CEcGeneralBoundObjectVectorImplementation of the EcGeneralBoundObjectVector class
 CEcGeneralForceA class describing generalized force. It is composed of 3D force and moment vectors
 CEcGeneralMotion
 CEcGeneralMotionAccFilterHolds a description of a general-motion filter system
 CEcGeneralMotionFilterHolds a description of a general-motion filter system
 CEcGeneralPreferencePagePage for general preferences
 CEcGeneralSpatialEndEffectorA general end effector
 CEcGenericFunctionTypeLinkA type joint whose transformation depends on a function of its joint value
 CEcGeometryOverwriteDescriptorHolds a class for implementing a geometry overwrite descriptor
 CEcGeomObjGeometric object data
 CEcGeomTriangleHolds a class to describe a 3D triangle
 CEcGJKHolds a class that implements the GJK algorithm for distance (including penetration distance) calculations
 CEcGJKTriangleA class that defines a triangle used by the GJK algorithm
 CEcGoldsteinPriceFunctionProvides an example function for testing
 CEcGraspableBarbellCreator
 CEcGraspableBoxCreator
 CEcGraspableCapsuleCreator
 CEcGraspableModelCreator
 CEcGraspableObjectCreator
 CEcGraspableObjectFactory
 CEcGraspableSphereCreator
 CEcGraspContactLocatorAbstract class to compute contact points and normals
 CEcGraspContactPointDataData for a grasp contact point
 CEcGraspCustomizationCallbackCallback class for customizing EcPerformGraspFunctor
 CEcGraspDescriptorGrasp descriptor
 CEcGraspFrameA single frame of a grasp sequence
 CEcGraspFrameContainerContainer for grasp frames
 CEcGraspFrameStateA single frame of a grasp sequence
 CEcGraspFrameStateContainerContainer for grasp frames
 CEcGraspFrameTransitionEventAbstract class defining the interface for transition events
 CEcGraspFrameTransitionEventContainerContainer for grasp frame transition events
 CEcGraspFrameTransitionEventStateAbstract class defining the interface for transition events
 CEcGraspFrameTransitionEventStateContainerContainer for grasp frame transition events
 CEcGraspingControlInterfaceControl interface used inside EcPerformGraspFunctor
 CEcGraspingDecisionTreeBranchBranch provider for grasping tree
 CEcGraspingDecisionTreeContainerContainer for grasping decision tree
 CEcGraspingDecisionTreeElementDecision Tree Base Class
 CEcGraspingDecisionTreeFactoryFactory for creating grasping decision trees
 CEcGraspingDecisionTreeLeafLeaf node in the grasping tree
 CEcGraspingObjectFactoryFactory class for generating a grasping object simulation for the grasping training
 CEcGraspingSimulationFactory
 CEcGraspInitParamsThis class is a container for paremeters used for grasp initialization
 CEcGraspOffsetAbstract class defining the interface for grasp offsets
 CEcGraspOffsetContainerContainer for grasp offsets
 CEcGraspOffsetStateAbstract class defining the interface for grasp offsets
 CEcGraspOffsetStateContainerContainer for grasp offsets
 CEcGraspQualityMeasureMeasure of grasp quality
 CEcGraspRunInfo
 CEcGraspRunManager
 CEcGraspSequenceA grasp sequence
 CEcGraspSequenceManagerA grasp sequence
 CEcGraspSequenceManagerStateA grasp sequence
 CEcGraspSequenceStateA grasp sequence
 CEcGraspUpdateParamsThis class is a container for paremeters used for grasp updates
 CEcGravitationalTorqueToolProvides a tool for gravitational torque/force and gradients
 CEcGridPhysicalExtentA class describing the physical extent of a grid. It includes a description of the mesh and the surface properties
 CEcGripperDirectionA manipulation action for one or more simple 1-DOF grippers
 CEcGripperDirectionStateState for EcGripperAction
 CEcGroupUserDataProvides groups and users for user account management
 CEcGuideFramePathA series of time-parameterized sets of guide frames
 CEcGuideFrameWidgetWidget to numerically edit and display guide frame values
 CEcGUIObjectParametersHolds parameters for GUI objects such as guide frame and center of interest
 CEcGzStreamBufferAdd compression capability to stream buffer
 CEcGzStringStreamAn input file compressed stream class
 CEcHalfSpaceDefines a half-space. A half-space is all the space on the side of a plane, in the direction of the normal vector Represent it as a point and a normal
 CEcHalfSpaceDistanceAlgorithmClass for distance algorithm involving half space
 CEcHandGraspingModuleThis class provides a grasping module for a generic hand
 CEcHardwareCntrlA specialization of EcProtocolCntrl
 CEcHardwareDriveDrive side messaging
 CEcHardwarePluginEnableDirectionConcrete implementation of EcManipulationDirection for enabling or disabling a HardwarePlugin
 CEcHardwarePluginTorqueEnableDirectionConcrete implementation of EcManipulationDirection for enabling or disabling a HardwarePlugin
 CEcHasAttachmentConditionConcrete implementation of EcDirectionCondition for determining if the current role has an attachment
 CEcHashBufferHolds a hash buffer
 CEcHelpAboutDialog
 CEcHexapodEndEffectorPlacementConverterEnd-effector placement converter for hexapod robot
 CEcHookeJeevesOptimizerHolds a description of the Hooke-Jeeves optimization algorithm, described in the paper by Robert Hooke and T. A. Jeeves, "'Direct Search' Solution of Numerical and Statistical Problems", Journal of the ACM, v. 8, pp. 212-229, April 1961. Includes enhancements based on Bell and Pike, "Remark on Algorithm 178" (Comm. ACM v.9, no. 9, Sept 1966), Tomlin and Smith, "Remark on Algorithm 178" (Comm. ACM v.12, no. 11, Nov 1969), and Smith, "Remark on Algorithm 178," (Comm. ACM v. 12, no. 11, 1969). The Hooke-Jeeves algorithm is also discussed in Kaupe, "Algorithm 178, Direct Search," (Comm. ACM v. 6, no. 6, 1963)
 CEcHttpAgentUtility for http agent
 CEcHttpStreamBufferAdd HTTP capability to stream buffer
 CEcHydraulicActuatorA class describing power conversion by a hydraulic actuator. Hydraulic cylinder (linear) and hydraulic rotarty vane actuators derive from this class
 CEcHydraulicCylinderA class describing power conversion by a hydraulic cylinder. A simple hydraulic cylinder system consists of a hydraulic cylinder and a servo valve. (The cylinder could be asymmetric, i.e. the two areas of the two sides of the piston can be different). The flows from the supply (e.g. pump) to the cylinder and from the cylinder to drain are caused by the valve openings
 CEcHydraulicRotaryVaneA class describing power conversion by a hydraulic rotary vane actuator. A simple hydraulic rotary actuator with n vanes. (The chamber area can be different on either side) The flows from the supply (e.g. pump) to the chamber and chamber to drain are caused by valve opening
 CEcIdsFilterSampleSample code for EcIdsFilter
 CEcIdsProcessorSampleSample code for EcIdsProcessor
 CEcIfDirectionConcrete implementation of EcManipulationDirection for running if directions from the director
 CEcIfDirectionSimpleStateConcrete implementation of EcManipulationSceneDirectionSimpleState for if direction
 CEcIfDirectionStateConcrete implementation of EcManipulationSceneDirectionState for holding EcIfDirection state information
 CEcIfGzStreamInput file compressed stream class
 CEcIfHttpStreamInput file HTTP stream class
 CEcImageSensorHolds a basic description of an image sensor
 CEcImageSensorVectorHolds a vector of instances of EcImageSensor and its derived classes
 CEcImpedanceControlFunctionE = K^-1*( f - M e_dd - B e_d )
 CEcImplicitFilteringOptimizerHolds a description of a modified Implicit Filtering optimizier. References: 1) P. Gilmore, C.T. Kelly, C.T. Miller, and G.A. Williams, "Implicit Filtering and Optimal Design Problems", Progress in Systems and Control Theory, vol. 19, Birkhauser, Boston, pp. 159-176, 1995. 2) C.T. Kelly, "Iterative Methods for Optimization", SIAM, 1999. The second reference above gives a summary of many different optimization methods
 CEcIncrementalGraspContactLocatorCompute contact points and normals using incremental search method
 CEcIndexManipulatorsSytemStateA convenient struct that combines a manipulator index and a system state
 CEcIndividualDynamicSimulatorHolds a dynamic simulator for an individual manipulator
 CEcIndividualDynamicSimulatorVectorXML vector container for EcIndividualDynamicSimulatorVector
 CEcIndividualJointControllerHolds a description of a feedback controller for a single joint
 CEcIndividualJointControllerContainerHolds a container for a position control system
 CEcIndividualManipulatorAn individual manipulator is described through this class. It includes a string label, a physical extent of the base, a list of top-most links, and a dynamic reference frame
 CEcIndividualVelocityControlDescriptionHolds a description of a velocity control system for an individual manipulator
 CEcInputFileStreamInput file stream class
 CEcInputStreamBase input stream class
 CEcInsertDirectionVisitorVisitor implementation for inserting a direction
 CEcIntegerColorHolds an integer-valued description of a color, with a transparency value
 CEcIntegratorContainerHolds a container for a numerical integrator
 CEcInterpolatedGraspOffsetThis class provides a grasp offset that is interpolated
 CEcInterpolatedGraspOffsetStateThis class provides a grasp offset that is interpolated
 CEcInterpolatedManipulationOffsetStateThis class provides a manipulation offset that is interpolated
 CEcInterpolatedOffsetThis class provides a manipulation offset that is interpolated
 CEcInterpolatedPoint
 CEcInterpolatorLinear Interpolator Class
 CEcIntervalEndPointDefines an endpoint for an interval. Used for interval testing for collision detection
 CEcIntervalIntersectionProcessorTests for interval overlap between links using AABBs. This is a fast test: O(n log n+m) where n is the number of intervals and m is the number of collisions
 CEcIoChannelBaseA base interface class for an input or output channel
 CEcIODataBrokerManages flow of input and output data between plugins and simulation
 CEcIsAttachedToConditionConcrete implementation of EcDirectionCondition for determining if the role is attached to another role
 CEcJacobianStateHolds the Jacobian state of a manipulator
 CEcJacobianToolProvides a tool for calculating manipulator Jacobians
 CEcJacobianTransposeConvergenceToolHolds a base class for a joint solution finder
 CEcJerkLimitMotionFilterContains functions for jerk limiting planning
 CEcJerkLimitMotionSynchronizationToolContains functions for jerk limiting planning
 CEcJointAccelerationDataCaptureTypeA class for capturing joint accelerations
 CEcJointActuator
 CEcJointActuatorContainerHolds a container for joint actuator description
 CEcJointActuatorModificationA class for modifying a joint actuator in a stated system
 CEcJointActuatorQWrapperWrapper for EcShape
 CEcJointActuatorRandomVariation
 CEcJointAdmittanceControlToolHolds an admittance control tool class. Currently only works for 6 joints
 CecJointAdmittanceControlToolHolds an admittance control tool class. Currently only works for 6 joints
 CEcJointControllerSystemHolds joint controllers for a manipulator system
 CEcJointControllerSystemContainerHolds a container for a system-level joint controller
 CEcJointControllerSystemSampleSample code for EcJointControllerSystem
 CEcJointDeviationUtilFunctionProvides a measure of proximity to obstacles
 CEcJointFrameA single frame of a frame sequence
 CEcJointFrameSequenceDirectionA joint sequence
 CEcJointGroupHolds the index maps of sub-Jacobians
 CEcJointInterpolationTool
 CEcJointLimitConstraintThis caps the weighted infinity norm of the joint rates
 CEcJointLimitDisplayParametersDisplay option parameters for joint limits
 CEcJointPathPlanningActionA joint path planning action
 CEcJointPathPlanningDirection
 CEcJointPathPlanningSequenceDirection
 CEcJointPositionDataCaptureTypeA class for capturing joint positions
 CEcJointPositionWidgetWidget to numerically edit and display joint position values
 CEcJointSolutionConvergenceToolHolds a base class for a joint solution finder
 CEcJointSolutionConvergenceToolContainerHolds a container for a convergence tool
 CEcJointSolutionFinderHolds a base class for a joint solution finder
 CEcJointSolutionFinderContainerHolds a container for a position control system
 CEcJointTorqueControllerThe class for force controller handling joint torque sensors and coordinated joint control end-effectors
 CEcJointTorqueDataCaptureTypeA class for capturing joint torques
 CEcJointVelocityDataCaptureTypeA class for capturing joint velocities
 CEcKeyCaptureEdit
 CEcKinematicsConversionToolConvert manipulators and systems to alternative, equivalent representations
 CEcLabelPoolHolds a pool of used labels
 CEcLatchedDoorLinksDescribes behavior of two links that form a latched door
 CEcLeastSquaresToolProvides a tool for calculating the least squares solution for AX = b
 CEcLevenbergMarquardtOptimizerHolds a description of a Levenberg-Marquardt optimizier
 CEcLicenseHolds parameters that are sent to Nalpeiron library
 CEcLicenseFileHolds parameters that are sent to Nalpeiron library
 CEcLicenseFileUtilSet of utilities to find and read license numbers from file
 CEcLicenseLibraryManagerProvides utility methods for handling embedded license libraries
 CEcLightHolds a description of a light
 CEcLightParametersHolds a description of light parameters for viewing the system
 CEcLineHolds a class to describe a 3D line
 CEcLineAndNeighborsHold the lines and neighbors information
 CEcLinearConstraintEndEffectorHolds a base class for a end-effector component that represents a linear constraint on the joint values
 CEcLinearFrictionModelComponentHolds a description of a friction model for a joint actuator. The model can be used to calculate the resulting output torque of the actuator based on the input (controlled) torque minus actuator resistive torques including Coulumb and Viscous friction
 CEcLinearMoveSolutionValidatorExtends EcSolutionValidator to validate that the joint solution is not only collision-free but the robot is also able to move linearly from that joint solution to the goal as well. This is used to for example validate that a joint solution to an approach position is valid and that the linear move from from the approach position to an attach or pick position is also valid
 CEcLinearMultivariableConstraintA class for a linear constraint
 CEcLinearScalarFunctionHolds a description of a unitary map that is shaped like an s-curve. It uses two pieces of rational polynomials. The form used for each of the two pieces is a0 x^2 + a1 x f = ----------— (b-x)
 CEcLinearStateEqualityConstraintA linear state constraint
 CEcLinearTimeInvariantSystem
 CEcLinearTrajectoryGeneratorClass for generating linear trajectory
 CEcLineSegmentHolds a class to describe a 3D line segment
 CEcLinkAccelerationStateHolds the acceleration state of a single manipulator link
 CEcLinkArticulationStateHolds the link-articulation-dynamics state of a single manipulator link
 CEcLinkAttachmentHolds a class for single attachment to a link
 CEcLinkCollisionForceCompute the collision force at the link level
 CEcLinkDataCaptureA base class used for configuration data capture of link data
 CEcLinkExampleHolds the link example code described in the Users Guide
 CEcLinkForceStateHolds the force state of a single manipulator link
 CEcLinkInteractionsVectorHolds a description of a vector of link interactions
 CEcLinkInterfaceConnectionPropertiesThe connection properties that define how to connect two compatible link interfaces
 CEcLinkKey
 CEcLinkKinematicsHolds a description of a base class for link motion. It supports general joint types with one degree of freedom
 CEcLinkKinematicsContainerHolds a container for link-motion description
 CEcLinkKinematicsModificationA class for modifying the kinematics of a link in a stated system
 CEcLinkKinematicsRandomVariation
 CEcLinkMassStateHolds the mass-properties state of a single manipulator link
 CEcLinkPointEventHolds data describing a point event on a link
 CEcLinkPositionStateHolds the state of a single manipulator link
 CEcLinkPropertyRandomVariation
 CEcLinkProximityDataHolds a class to describe a link proximity related data
 CEcLinkProximityKey
 CEcLinkReferenceDescriptionHolds a description of references made by this link
 CEcLinkRelativeGraspOffsetThis class provides a grasp offset that is relative to a specified link on the object to be grasped
 CEcLinkRelativeGraspOffsetStateThis class provides a grasp offset that is relative to a specified link on the object to be grasped
 CEcLinkRelativeManipulationOffsetStateThis class provides a manipulation offset that is relative to a specified link on the object to be manipulationed
 CEcLinkRelativeOffsetThis class provides a manipulation offset that is relative to a specified link on the object to be manipulationed
 CEcLinkStateCacheKeyDefines a class for describing a key for accessing a link in the shape proximity database
 CEcLinkVelocityStateHolds the velocity state of a single manipulator link
 CEcLookAtEndEffectorA look-at end effector. This end effector is intended to use in relative to another link. It is like a point end effector but do not care about the distance from the link to the guide frame. The look at point is defined as an EE offset to the primary frame
 CEcLowPassFilterLow pass filter for online and offline applications
 CEcLozengeHolds a class to describe a 3D lozenge (a distance from a rectangle)
 CEcLozengeDistanceAlgorithmClass for distance algorithm involving lozenge
 CEcLozengeFittingMethods for fitting to a lozenge
 CEcMainWidgetContextMenu
 CEcManipLinkConnectedSensorHolds a description of a base sensor
 CEcManipLinkPoseDependentSensorHolds a description of a base sensor
 CEcManipLinkWidgetWidget for selecting manipulator and link
 CEcManipulationActiveStateDefines the active state for a manipulation action
 CEcManipulationDirectionVirtual base class of EcManipulationSceneDirection for implementing "manipulation" directions from the director
 CEcManipulationDirectionReferenceConcrete implementation of EcManipulationDirection that references a manipulation direction stored within the director's object directory
 CEcManipulationDirectionReferenceStateConcrete implementation of EcManipulationSceneDirectionState for holding EcManipulationDirectionReference state information
 CEcManipulationDirectionStateBase class for state of EcManipulationDirection
 CEcManipulationDirectorDirects a cast to run a manipulation script
 CEcManipulationDirectorExternalInterfaceExternal interface used within manipulationDirector library
 CEcManipulationDirectorSimpleStateHolds EcManipulationDirector simple state information
 CEcManipulationDirectorStateHolds EcManipulationDirector state information
 CEcManipulationDirectorUpdateParamsThis class is a container for paremeters used for manipulation director updates
 CEcManipulationDirectorVisitorVirtual base class for defining visitor algorithms for manipulationDirector objects
 CEcManipulationFrameStateA single frame of a manipulation sequence
 CEcManipulationFrameStateContainerContainer for manipulation frames
 CEcManipulationFrameTransitionEventStateAbstract class defining the interface for transition events
 CEcManipulationFrameTransitionEventStateContainerContainer for manipulation frame transition events
 CEcManipulationInitParamsThis class is a container for paremeters used for manipulation initialization
 CEcManipulationOffsetStateAbstract class defining the interface for manipulation offset states
 CEcManipulationOffsetStateContainerContainer for manipulation offsets
 CEcManipulationPlacementAchievedTransitionEventStateThis class provides a manipulation frame transition event state
 CEcManipulationSceneOrganizes manipulation scene directions for multiple manipulator roles
 CEcManipulationSceneContainerContainer for manipulation scene directions
 CEcManipulationSceneCueContains a cue used for synchronization between roles in a scene
 CEcManipulationSceneDirectionVirtual base class for manipulation scene directions
 CEcManipulationSceneDirectionContainerContainer for manipulation scene directions
 CEcManipulationSceneDirectionDirectorObjectConcrete implementation of EcDirectorObject that holds an EcManipulationSceneDirection object
 CEcManipulationSceneDirectionIssuesAbstract class defining the interface for manipulation scene direction issues
 CEcManipulationSceneDirectionIssuesContainerContainer for manipulation scene direction states
 CEcManipulationSceneDirectionIssuesContainer_H_Container for manipulation scene direction issues
 CEcManipulationSceneDirectionSimpleStateAbstract class defining the interface for manipulation scene direction states
 CEcManipulationSceneDirectionSimpleStateContainerContainer for manipulation scene direction states
 CEcManipulationSceneDirectionStateAbstract class defining the interface for manipulation scene direction states
 CEcManipulationSceneDirectionStateContainerContainer for manipulation scene direction states
 CEcManipulationSceneDirectorObjectConcrete implementation of EcDirectorObject that holds an EcManipulationScene object
 CEcManipulationSceneReferenceOrganizes manipulation scene directions for multiple manipulator roles
 CEcManipulationSceneReferenceSimpleStateHolds EcManipulationScene state information
 CEcManipulationSceneReferenceStateHolds EcManipulationScene state information
 CEcManipulationSceneSimpleStateHolds EcManipulationScene state information
 CEcManipulationSceneSimpleStateContainerContainer for manipulation scene direction states
 CEcManipulationSceneStateHolds EcManipulationScene state information
 CEcManipulationSceneStateContainerContainer for manipulation scene direction states
 CEcManipulationScriptOrganizes multiple manipulation scenes
 CEcManipulationScriptDirectorObjectConcrete implementation of EcDirectorObject that holds an EcManipulationScript object
 CEcManipulationScriptSimpleStateHolds EcManipulationScript simple state information
 CEcManipulationScriptStateHolds EcManipulationScript state information
 CEcManipulationSequenceDirectionA manipulation sequence
 CEcManipulationSequenceDirectionStateA manipulation sequence
 CEcManipulationTimeDurationTransitionEventStateThis class provides a manipulation frame transition event state based on time
 CEcManipulationWaypointA single waypoint of a waypoint sequence
 CEcManipulationWaypointVectorHolds a description of a vector of waypoints
 CEcManipulatorActiveAccelerationStateHolds the active acceleration state of a manipulator
 CEcManipulatorActiveArticulationStateHolds the active articulation-based state of a manipulator
 CEcManipulatorActiveForceStateHolds the active force state of a manipulator
 CEcManipulatorActiveMassStateHolds the active mass-properties state of a manipulator
 CEcManipulatorActivePositionStateHolds the active position state of a manipulator
 CEcManipulatorActiveStateThis class is a container for domain-specific active states
 CEcManipulatorActiveVelocityStateHolds the active velocity state of a manipulator
 CEcManipulatorAttachmentChange
 CEcManipulatorAttachmentMapHolds a map describing attachment among manipulators
 CEcManipulatorAttachmentNodeThe class defining a manipulator attachment node
 CEcManipulatorCollisionTool
 CecManipulatorCollisionToolHelper class for computing collision data between manipulators and/or links
 CEcManipulatorConstraintHolds a base class for single end-effector components
 CEcManipulatorConstraintToolManipulator constraints
 CEcManipulatorConstraintVectorHolds a description of a vector of general end effectors
 CEcManipulatorControlInputHolds a description of the control inputs applied to a manipulator
 CEcManipulatorDataCaptureA base class used for configuration data capture of manipulator data
 CEcManipulatorDataStorageHolds a description of captured manipulator data
 CEcManipulatorEndEffectorAccelerationHolds a description of the accelerations of all end effectors on a manipulator
 CEcManipulatorEndEffectorForceHolds a description of the forces of all end effectors on a manipulator
 CEcManipulatorEndEffectorPlacementHolds a description of the placement of all end effectors on a manipulator
 CEcManipulatorEndEffectorPlacementPathA series of time-parameterized sets of guide frames
 CEcManipulatorEndEffectorVelocityHolds a description of the velocities of all end effectors on a manipulator
 CEcManipulatorExampleDemonstrates EcIndividualManipulator
 CEcManipulatorExternalForceHolds a description of the external forces and moments applied to a manipulator
 CEcManipulatorGraspingModuleThis class is a container for hand grasping modules
 CEcManipulatorJointControllerHolds a description of a feedback controller for a single joint
 CEcManipulatorJointControllerSampleSample code for EcManipulatorJointController
 CEcManipulatorJointControllerVectorHolds a description of a vector of manipulator-level joint controllers
 CEcManipulatorLinkHolds a description of a manipulator link
 CEcManipulatorLinkIdentifierHelper class containing a link identifier and its manipulator index
 CEcManipulatorLinkIndexHelper class containing a link index and its manipulator index
 CEcManipulatorLinkLabelMappingHolds a link label mapping between manipulators
 CEcManipulatorLinkProximityStateHolds state information related to the proximity of links in a manipulator to those in others
 CEcManipulatorMotionAttachManipulatorMotion script for attaching manipulator
 CEcManipulatorMotionDetachManipulatorMotion script for detaching manipulator
 CEcManipulatorMotionExcludeCollisionMotion script for excluding collision check
 CEcManipulatorMotionIncludeCollisionMotion script for including collision check
 CEcManipulatorMotionManagerHolds a manager class for individual manipulator motion
 CEcManipulatorMotionRrtPlanRRT planning
 CEcManipulatorMotionSetActiveControlDescriptionHolds a motion script for setting base speed factor
 CEcManipulatorMotionSetActiveEndEffectorSetHolds a motion script for setting the active end effector set for a manipulator
 CEcManipulatorMotionSetActivePositionControlMethodHolds a motion script for setting the active position control method index
 CEcManipulatorMotionSetBaseSpeedFactorHolds a motion script for setting base speed factor
 CEcManipulatorMotionSetSensedStateHolds a motion script for setting sensed position state
 CEcManipulatorPointEventHolds a point event on a single manipulator
 CEcManipulatorPowerDataCaptureTypeA class for capturing power out of manipulator
 CEcManipulatorProximityToolHelper class to calculate distance between manipulators and/or links
 CEcManipulatorReferenceDescriptionHolds a description of references made by this manipulator
 CEcManipulatorSelfCollisionLinkMap
 CEcManipulatorStateCacheKeyDefines a class for describing a key for accessing manipulators in the shape proximity database
 CEcManipulatorStateObserverThis class defines a manipulator state estimator
 CEcManipulatorSystemHolds a description of an entire manipulator system
 CEcManipulatorSystemConfigurationHolds the data that is slowly or intermittently changing, i.e the data is neither permanent (like in system) nor changing every time step (like in state)
 CEcManipulatorSystemContainerHolds a container for manipulator system
 CEcManipulatorSystemStateHolds a description of the state of an entire manipulator system
 CEcManipulatorTorqueHolds a description of the intrinsic torques/forces applied to a manipulator
 CEcManualPauseDirectionConcrete implementation of EcManipulationDirection for running EcManipulationAction directions from the director
 CEcManualPauseDirectionStateConcrete implementation of EcManipulationSceneDirectionState for holding EcManualPauseDirection state information
 CEcManufacturerDataThe class defining manufacturer data
 CEcMassMatrixToolProvides a tool for calculating manipulator mass matrices
 CEcMassPropertyModificationA class for modifying mass property of a link in a stated system
 CEcMassPropertyRandomVariation
 CEcMassSpringCollisionForceProcessorDefines a class for computing collision force using a mass-spring model
 CEcMassSpringDamperCollisionForceProcessorDefines a class for computing collision force using a mass-spring model
 CEcMaterialDataMaterial data
 CEcMathContains general math functions
 CEcMathematicaOutputWriterA class for writing simulation outputs to files in Mathematica format
 CEcMatlabOutputWriterA class for writing simulation outputs to files in MATLAB format
 CEcMatrixDToolProvides a tool for calculating matrix D, which is the matrix such that D Ab gives the joint torques and D^T q-dot gives momentum
 CEcMaxSonarInterfaceMax Sonar sensor interface (www.maxbotix.com)
 CEcMcKyesExcavationInteractionDefines a class for computing bucket excavation force using McKyes model
 CEcMechanicalActuatorComponent
 CEcMechanicalActuatorComponentContainerHolds a container for mechanical component of a joint actuator
 CEcMedianAverageFilterTo perform combination of median filtering and average filter on signal
 CEcMedianFilterTo perform median filtering on signal
 CEcMergeToolProvides a tool for merging multiple XML files
 CEcMkManipulatorStateObserverThis class defines a manipulator state estimator
 CEcMkSystemIdJointResultsA struct to hold the results data from system identification of a single joint actuator
 CEcMobileBaseControllerBase
 CEcMobileBaseControllerContainer
 CEcMobileManipulatorController
 CEcMobilityParametersA class containing mobility parameters
 CEcModbusConstantsConstants for the Modbus protocol
 CEcModbusProtocolBaseGenerates Modbus protocol messages and checks the validity of the responses
 CEcModbusRtuImplements Modbus RTU communication
 CEcModbusRtuConstantsConstants for the Modbus/RTU protocol
 CEcModbusTcpImplements Modbus TCP communication
 CEcModbusTcpConstantsConstants for the Modbus/TCP protocol
 CEcMotionDirectionStateA manipulation sequence
 CEcMotionScriptAssertApproxEqualFind joint solution for a manipulation end effector placement
 CEcMotionScriptAssignVariableAssign value to a motion script variable
 CEcMotionScriptBooleanHolds a boolean literal for motion script
 CEcMotionScriptBooleanAndGet logic add of booleans for motion script
 CEcMotionScriptBooleanGetDigitalInputGet the digital input as a boolean for motion script
 CEcMotionScriptBooleanGreaterThanPerform the greater than on two variables for motion script
 CEcMotionScriptBooleanHitJointLimitGet hit joint limit flag
 CEcMotionScriptBooleanLessThanPerform the less than on two variables for motion script
 CEcMotionScriptBooleanNotGet logic not of a boolean for motion script
 CEcMotionScriptBooleanNotEqualCheck equality on two variables for motion script
 CEcMotionScriptBooleanObjectBase class of EcBoolean object for motion script
 CEcMotionScriptBooleanOrGet logic or of booleans for motion script
 CEcMotionScriptBooleanSymbolHolds a boolean symbol for motion script
 CEcMotionScriptDefineBooleanDefine a variable of boolean
 CEcMotionScriptDefineOrientationDefine a variable of orientation
 CEcMotionScriptDefinePoseDefine a variable of pose
 CEcMotionScriptDefineRealDefine a variable of real
 CEcMotionScriptDefineRealVectorDefine a variable of real vector
 CEcMotionScriptDefineStringDefine a variable of string
 CEcMotionScriptDefineTranslationDefine a variable of translation
 CEcMotionScriptDefineU32Define a variable of U32
 CEcMotionScriptDefineU32VectorDefine a variable of U32 vector
 CEcMotionScriptDirectionConcrete implementation of EcManipulationDirection that executes a specified motion script
 CEcMotionScriptDirectionStateConcrete implementation of EcMotionDirectionState for holding EcMotionScriptDirection state information
 CEcMotionScriptFindSolutionFind joint solution for a manipulation end effector placement
 CEcMotionScriptIfHolds motion script if
 CEcMotionScriptObjectBase motion script object class
 CEcMotionScriptOrientationHolds an orientation literal for motion script
 CEcMotionScriptOrientationGetFromPoseExtract an orientation form a pose for motion script
 CEcMotionScriptOrientationInvertInverse orientations for motion script
 CEcMotionScriptOrientationMultiplyMultiply orientations for motion script
 CEcMotionScriptOrientationObjectBase class of EcOrientation object for motion script
 CEcMotionScriptOrientationSymbolHolds an orientation symbol for motion script
 CEcMotionScriptParallelHolds parallel motion scripts (vector)
 CEcMotionScriptPoseHolds a pose literal for motion script
 CEcMotionScriptPoseFromRealVectorConvert a real vector into a pose for motion script
 CEcMotionScriptPoseGetFrameGet primary or named frame in the system frame for motion script
 CEcMotionScriptPoseInvertInvert a pose for motion script
 CEcMotionScriptPoseMultiplyMultiply poses for motion script
 CEcMotionScriptPoseObjectBase class of EcCoordinateSystemTransformation object for motion script
 CEcMotionScriptPoseSymbolHolds a pose symbol for motion script
 CEcMotionScriptPrintVariablePrint the value of a motion script variable to std::cout
 CEcMotionScriptRealHolds a real literal for motion script
 CEcMotionScriptRealAddAdd reals for motion script
 CEcMotionScriptRealDivideDivide reals for motion script
 CEcMotionScriptRealGetDataMapGet a real from data map for motion script
 CEcMotionScriptRealMultiplyMultiply reals for motion script
 CEcMotionScriptRealObjectBase class of EcReal object for motion script
 CEcMotionScriptRealSubtractSubtract reals for motion script
 CEcMotionScriptRealSymbolHolds a real symbol for motion script
 CEcMotionScriptRealVectorHolds a real vector literal for motion script
 CEcMotionScriptRealVectorGetDataMapGet a real vector from data map for motion script
 CEcMotionScriptRealVectorGetJointPositionsGet a real vector from data map for motion script
 CEcMotionScriptRealVectorObjectBase class of EcRealVector object for motion script
 CEcMotionScriptRealVectorSymbolHolds a real vector symbol for motion script
 CEcMotionScriptSequenceHolds motion script sequence (vector)
 CEcMotionScriptSetDataMapRealHolds a class of motion script for setting data map real
 CEcMotionScriptSetDataMapRealVectorHolds a class of motion script for setting data map real vector
 CEcMotionScriptSetDataMapStringHolds a class of motion script for setting data map string
 CEcMotionScriptSetDataMapU32Holds a class of motion script for setting data map U32
 CEcMotionScriptSetDataMapU32VectorHolds a class of motion script for setting data map U32 vector
 CEcMotionScriptSetDigitalInputHolds a motion script for setting digital input
 CEcMotionScriptSetDigitalOutputHolds a motion script for setting digital output
 CEcMotionScriptStreamSequenceHolds motion script sequence (vector)
 CEcMotionScriptStringHolds a string literal for motion script
 CEcMotionScriptStringGetDataMapGet a real vector from data map for motion script
 CEcMotionScriptStringObjectBase class of EcString object for motion script
 CEcMotionScriptStringSymbolHolds a string symbol for motion script
 CEcMotionScriptTokenTreeMotion script token tree
 CEcMotionScriptTranslationHolds a translation literal for motion script
 CEcMotionScriptTranslationAddAdd translations for motion script
 CEcMotionScriptTranslationCrossCross product translations for motion script
 CEcMotionScriptTranslationDotDot product translations for motion script
 CEcMotionScriptTranslationFromRealConvert a real into a translation for motion script
 CEcMotionScriptTranslationFromRealVectorConvert a real vector into a translation for motion script
 CEcMotionScriptTranslationGetFromPoseExtract a translation form a pose for motion script
 CEcMotionScriptTranslationMultiplyCross product translations for motion script
 CEcMotionScriptTranslationObjectBase class of EcVector object for motion script
 CEcMotionScriptTranslationSubtractSubstract translations for motion script
 CEcMotionScriptTranslationSymbolHolds a translation symbol for motion script
 CEcMotionScriptTransportHandleHolds a transport handle for motion script
 CEcMotionScriptU32Holds a U32 literal for motion script
 CEcMotionScriptU32AddAdd U32s for motion script
 CEcMotionScriptU32GetDataMapGet a u32 from data map for motion script
 CEcMotionScriptU32GetManipulatorIndexGet the manipulator index given its label for motion script
 CEcMotionScriptU32MultiplyMultiply U32s for motion script
 CEcMotionScriptU32ObjectBase class of EcU32 object for motion script
 CEcMotionScriptU32SubtractSubtract U32s for motion script
 CEcMotionScriptU32SymbolHolds a U32 symbol for motion script
 CEcMotionScriptU32VectorHolds a U32 vector literal for motion script
 CEcMotionScriptU32VectorGetDataMapGet a U32 vector from data map for motion script
 CEcMotionScriptU32VectorObjectBase class of EcU32Vector object for motion script
 CEcMotionScriptU32VectorSymbolHolds a U32 vector symbol for motion script
 CEcMotionScriptWaitHolds a motion script for waiting
 CEcMotionScriptWhileHolds motion script while loop
 CEcMotionSettleDirectionConcrete implementation of EcManipulationDirection for waiting for the motion to settle
 CEcMotionSettleDirectionStateConcrete implementation of EcManipulationSceneDirectionState for holding EcMotionSettleDirection state information
 CEcMotorPowerDataCaptureTypeA class for capturing motor power to a joint
 CEcMoveDirectionVisitorVisitor implementation for moving a direction
 CEcMrdOutputWriterA class for writing simulation outputs to files in MRD format
 CEcMultiArmWaypointSequenceDirectionA manipulation sequence
 CEcMultiArmWaypointSequenceDirectionStateA manipulation sequence
 CEcMultiCollisionForceProcessorCompute collision force
 CEcMultidirectionalSearchOptimizerHolds a description of a modified Multidirectional Search optimizer. References: 1) V. Torczon, "On the Convergence of Pattern Search Algorithms," SIAM J. Optimization, v. 7, no. 1, pp 1-25, 1997. 2) V. Torczon, Multi-Directional Search: A Direct Search Algorithm for Parallel Machines, Ph.D. Thesis, Rice University, 1989. 3) V. Torczon, "On the Convergence of Pattern Search Algorithms," SIAM J. Optimization, v. 7, no. 1, pp 1-25, 1997
 CEcMultipointScalarFunctionHolds a function defined through multiple points
 CEcMultivariableConstraintContainerA conttainer of EcBaseMultivariableConstraint
 CEcMultivariableConstraintVectorThe vector of multivariable constraints
 CEcMultivariableJointStateConstraintA state constraint the uses a multivariable constraint for joint state
 CEcNalpeironNSLFunctionsClass for Nalpeiron NSL license functions
 CEcNelderMeadOptimizerHolds a description of a modified Nelder-Mead optimizier
 CEcNetworkOperationExampleHolds the network-operation code described in the Users Guide
 CEcNLOptOptimizerHolds a description of a NLopt (http://ab-initio.mit.edu/wiki/index.php/NLopt) optimizier
 CEcNonNegRealA nonnegative floating-point number
 CEcNotDirectionConditionConcrete implementation of EcUnaryDirectionCondition for returning the negative test of a wrapped condition
 CEcNullDeleter
 CEcObjectGraspingModuleContainer for object grasping modules
 CEcObjectRelativeGraspOffsetThis class provides a grasp offset that is relative to the object to be grasped
 CEcObjectRelativeGraspOffsetStateThis class provides a grasp offset that is relative to the object to be grasped
 CEcObjectRelativeManipulationOffsetStateThis class provides a manipulation offset that is relative to the object to be manipulationed
 CEcObjectRelativeOffsetThis class provides a manipulation offset that is relative to the object to be manipulationed
 CEcObstacleProximityFunctionProvides a measure of proximity to obstacles
 CEcOffsetAbstract class defining the interface for manipulation offsets
 CEcOffsetContainerContainer for manipulation offsets
 CEcOfGzStreamOutput file compressed stream class
 CEcOldJointActuatorHolds a description of an actuator on a joint
 CEcOldManipulatorAttachmentMapHolds a map describing attachment among manipulators (deprecated)
 CEcOneDofGripperEndEffectorA class for end effector that can be used as 1-dof gripper
 CEcOptimizerIterationResultDataData structure to describe the results of an iteration of the optimization algorithm
 CEcOrDirectionConditionConcrete implementation of EcBinaryDirectionCondition for returning the logical OR of two conditions
 CEcOrientationDescription of a 3D rotation
 CEcOrientationEndEffectorHolds a 3D orientation end-effector component
 CEcOrientationWidgetWidget to numerically edit and display guide frame values
 CEcOutputFileStreamOutput stream base class
 CEcOutputStreamOutput stream base class
 CEcOutputWriterVectorXML Vector container for EcOutputWriterVector
 CEcPa10ArmInfo
 CEcPa10SimulationCreator
 CEcParallelSimJobThis class used for passing a job from a tasker to the requesting worker
 CEcParallelSimJobBranchThis class used for passing a job from a tasker to the requesting worker
 CEcParallelSimJobResultsThis class used for passing job results from worker to the requesting tasker
 CEcParallelSimJobWorkerThis class used for passing job results from worker to the requesting tasker
 CEcParallelSimResultsThis class is used for storing job results
 CEcParametricFrameA single frame of a manipulation sequence
 CEcParametricGraspFrameA single frame of a grasp sequence
 CEcParametricGraspFrameStateA single frame of a grasp sequence
 CEcParametricManipulationFrameStateA single frame of a manipulation sequence
 CEcParametricTranslationGraspOffsetThis class provides a translation grasp offset that is parametrically defined
 CEcParametricTranslationGraspOffsetStateThis class provides a translation grasp offset that is parametrically defined
 CEcParametricTranslationManipulationOffsetStateThis class provides a translation manipulation offset that is parametrically defined
 CEcParametricTranslationOffsetThis class provides a translation manipulation offset that is parametrically defined
 CEcParkExcavationInteractionDefines a class for computing bucket excavation force using Park model
 CEcPassThroughPowerConverterA class describing power conversion that does nothing
 CEcPathAdherenceUtilityFunctionProvides a measure of proximity to obstacles
 CEcPathDirectionA path Direction
 CEcPathFollowingExampleHolds the path-following code described in the Users Guide
 CEcPathPlannerHelperClass that contains joint positions and path to help speed up RRT path planning calculations
 CEcPathPlannerHelperManager
 CEcPathPlanningCoreExampleRRT path planner tool (can be used for inverse kinematics)
 CEcPathPlanningDirectionA end-effector path planning action
 CEcPathPlanningDirectionStateA manipulation sequence
 CEcPathPlanningDirectionUtil
 CEcPathPlanningExampleRRT path planner tool (can be used for inverse kinematics)
 CEcPathPlanningSequenceDirection
 CEcPathPlanningSequenceDirectionStateA manipulation sequence
 CEcPathPoint
 CEcPathShorteningToolThe EcPathShortening class
 CEcPauseActionA pause action. It's used to pause for a specified duration
 CEcPerformGraspCallbacksControl interface used inside EcPerformGraspFunctor
 CEcPermissionProvides a permission for user account management
 CEcPermissionData
 CEcPerumpralExcavationInteractionDefines a class for computing bucket excavation force using Perumpral model
 CEcPhysicalSystemExpanderHolds a tool for expanding physical components into stated systems
 CEcPiForceControlFunctionV = ( kp*deltaF + ki*integral(deltaF)dt)
 CEcPlacementAchievedTransitionEventThis class provides foundation stage I grasping for a Robonaut hand
 CEcPlacementAchievedTransitionEventStateThis class provides foundation stage I grasping for a Robonaut hand
 CEcPlanarAxisAlignedBoxA planar axis-aligned box defined by a center and extents
 CEcPlanarCircleA planar circle defined by a center and radius
 CEcPlanarCircleFittingMethods for fitting to a planar circle
 CEcPlanarEndEffectorAn end effector that defines a planar motion
 CEcPlanarPolygonA planar polygon defined by points specified in a clockwise direction
 CEcPlanarShapeVirtual base class for all planar (2D) shapes
 CEcPlanarShapeContainerA container to hold planar shapes
 CEcPlanarShapeLayersA collection of EcPlanarhape objects arranged in layers from bottom to top
 CEcPlanarShapeUnionA union of non-composite EcPlanarhape objects
 CEcPlanarShapeVectorImplementation of the EcPlanarShapeVector class
 CEcPlanarVectorA two-dimensional vector
 CEcPlaneHolds a description of a plane
 CEcPlaneFittingMethods for fitting to a plane
 CEcPlatformCommandsProvides a series of methods that offer platform specific facilities
 CEcPluginConfigPairXml string pair that sets custom tags
 CEcPluginPreferencePagePage for plugin preferences
 CEcPointBasedEndEffectorAn abstract class for end effector that uses point motion filter
 CEcPointDistanceEndEffectorA point-distance end effector
 CEcPointEndEffectorA point end effector
 CEcPointMotionFilterHolds a description of a point-motion filter system. Given an existing point, a desired point, a desired point velocity, what is the best overall point velocity? This uses proportional scaling with capping
 CEcPointRotateEndEffectorA 4-dof end effector with 3-dof point and 1-dof rotation
 CEcPointStateEqualityConstraintA 3D point state constraint
 CEcPolygonA polygon class. It holds a list of indices into a vertex list, as well as a surface property string
 CEcPolygonWithKeyInterface for the EcPolygonWithKey class
 CEcPolyPhysicalExtentA class describing the physical extent of a link. It includes a description of the mesh and the surface properties
 CEcPoseThe EcPose class EcPose is used to specified a 3D location (position and orientation) in space. It can be either relative or absolute (relative to system). If it's relative, it can be relative to a primary frame of a named frame of a link
 CEcPoseDirectorObjectConcrete implementation of EcDirectorObject that holds an EcPose object
 CEcPoseSetA class that organizes poses into a hierarchy structure
 CEcPoseUtilUtility class
 CEcPositionControlContainerHolds a container for a position control system
 CEcPositionControlExampleHolds the position-control code described in the Users Guide
 CEcPositionControllerHolds a description of a position controller for one manipulator
 CEcPositionControllerVectorHolds a description of a vector of general end effectors
 CEcPositionControlMethodHolds a description of a position control method
 CEcPositionControlMethodVectorHolds a description of a vector of general end effectors
 CEcPositionControlSystemHolds a description of a position control system
 CEcPositionControlSystemWithConverterEcPositionControlSystem with end-effector placement converter
 CEcPositionStateHolds a description of the position state of a manipulator
 CEcPositionStateModificationHolds a description of a modification to a link (joint position)
 CEcPositionStatePathA time stepped sequence of position states
 CEcPositionStateRandomVariationDescription of random variation for positin state of an individual manipulator
 CEcPovParametersHolds a description of point-of-view parameters for viewing the system, including the eyepoint, the center of interest, and the field of view
 CEcPowellsQuarticFunctionProvides an example function for testing
 CEcPowerConverterContainerHolds a container for power converter description
 CEcPowerUnitaryMapHolds a description of a unitary map that is defined by a power function. I.e., f= pow(x,e)
 CEcPreferenceDlgDialog for editing preferences
 CEcPrintDirectionConcrete implementation of EcStageDirection for printing a message
 CEcProcessingTaskManagerManages a pool of threads for processing tasks in EcProcessingTaskQueue
 CEcProcessingTaskQueueManages a thread-safe queue of tasks to be processed
 CEcProfilingExampleA class to profile the low-level position control performance
 CEcProgrammaticConstructionExampleHolds the collision-avoidance code described in the Users Guide
 CEcProjectedCenterOfMassEndEffectorA 2D center-of-mass constraint, i.e. the 3D center of mass projected on to a virtual plane
 CEcPropagationDescriptor
 CEcPropagationResultDataHolds a class to describe the results of a manipulator propagation
 CEcPropertyDelegate
 CEcPropertyTableViewTable view for editing properties
 CEcProtocolCBufBasic messaging protocol
 CEcProtocolCntrlA specialization of EcProtocolNode
 CEcProtocolConfig
 CEcProtocolDriveDrive side messaging
 CEcProtocolMsgsBasic messaging protocol
 CEcProtocolNodeBasic messaging protocol
 CEcProtocolQueueMessage queueing
 CEcPullTypeMlpdSensorHolds a description of a base sensor
 CEcQinsenExcavationInteractionDefines a class for computing bulldoze blade excavation force using Qinsen model
 CEcQuadraticMultivariableConstraintA class for a quadratic constraint
 CEcQuadrilateralFixedSliderJointCBObject
 CEcQuadrilateralFixedSliderJointOAObject
 CEcQuadrilateralPivotedSliderJointBObject
 CEcQuadrilateralPivotedSliderJointCObject
 CEcQuadrilateralTypeLinkA type of joint that converts a linear motion into an angular motion using a quadrilateral-shaped mechanism. This is conceptually the same as the slider-crank mechanism
 CEcQuickStartExampleHolds the quick-start code described in the Users Guide
 CEcQuickStartKinematicsExampleQuick-start code for forward and inverse kinematics
 CEcQuickStartPythonExampleHolds python example with C++ embedded
 CEcQuickStartSimulinkExample
 CEcQuinticSplineQuintic spline
 CEcRandomA utility class to generate random numbers
 CEcRandomJointSolutionFinderA joint solution finder using random approach
 CEcRandomNoiseA class representing fixed pattern noise in an image sensor
 CEcRandomTensorToolHolds a tool for creating random arrays and tensors
 CEcRCMEndEffectorA RCM end effector. Modified from frame sliding end effector. We will let it free along x in the EE space but fix on y-z. Free to rotate. A 2 DOC EE
 CEcReachabilityStudyHolds a description of reachability study
 CEcReachTargetDataCaptureTypeA class for capturing whether EE target location is reached
 CEcRealRealUnaryFunctionA unary function object that takes EcReal as an argument and returns EcReal
 CEcReArrayHolds a class to describe real arrays. Includes operations such as addition, subtraction, and multiplication
 CEcRectangleHold a class to describe a rectangle in R3. The rectangle is described by two
 CEcReferencePoseManipulationOffsetStateThis class provides a manipulation offset that remains constant
 CEcReferencePoseOffsetThis class provides a manipulation offset that remains constant
 CEcRelativeEndEffectorToolProvides a tool for calculating relative end effector placement
 CEcRelativeGraspOffsetThis class is an abstract interface for relative grasp offsets
 CEcRelativeGraspOffsetStateThis class is an abstract interface for relative grasp offsets
 CEcRelativeManipulationOffsetStateThis class is an abstract interface for relative manipulation offsets
 CEcRelativeOffsetThis class is an abstract interface for relative manipulation offsets
 CEcRemoteCommandExampleThis class uses the remote commands API to communicate with the
 CEcRemoveDirectionVisitorVisitor implementation for removing a direction
 CEcRenderParametersHolds parameters used for rendering, including lighting, point of view, and rendering technical settings
 CEcRigidBodyMassPropertiesRepresents rigid body mass properties: mass, first moment, and second moment. The second moment is with respect to the origin of the representation (not with respect to the center of mass)
 CEcRigidBodyMassQWrapperWrapper for EcShape
 CEcRigidWheelSoilForceProcessorDefines a class for computing interaction force between rigid wheel and soil
 CEcRigidWheelSoilInteractionDefines a class for computing interaction force between rigid wheel and soil
 CEcRigidWheelSoilInteractionContainerAn container class for computing interaction force between rigid wheel and soil
 CEcRoadmapRrtPathPlannerImplements a path planner using Actin control and Rapidly-exploring Random Tree, with pre-populated road map. The road map can help signficantly speed up the path planning calculations
 CEcRobonautArmInfo
 CEcRobonautHandInfo
 CEcRobonautSimulationCreator
 CEcRobotArmInfo
 CEcRobotGraspingExampleHolds the Robonaut grasping example
 CEcRobotHandInfo
 CEcRobotHardwareBase
 CEcRobotHardwareStateInclude headers
 CEcRobotHardwareStatusInclude headers
 CEcRobotServoConfigBaseParameters for individual servos
 CEcRobotServoConfigVectorXML Vector container for EcHardwareConfigBase
 CEcRobotSimulationCreator
 CEcRobotSimulationFactory
 CEcROImanipEcImage helper class for performing image calibration methods
 CEcRoleLocationConditionConcrete implementation of EcDirectionCondition for determining if a role is located inside a bounded region
 CEcRotateZSolutionFinderDerives from EcSolutionFinder to add a step to help finding a valid joint solution by rotating the end effector placement around the Z axis
 CEcRotationBasedEndEffectorAn abstract class for end effector that uses rotation motion filter
 CEcRotationMotionFilterHolds a description of a rotation-motion filter system
 CEcRrtAlgorithmImplements Rapidly-exploring Random EcTree algorithm
 CEcRrtPathPlannerImplements a path planner using Actin control and Rapidly-exploring Random Tree
 CEcRrtPathPlannerContainerHolds a container for RRT-based path planner
 CEcRrtPathPlannerLoader
 CEcRrtUtilityClass that contains utility methods for RRT-based algorithms and path planners
 CEcRrtUtilityContainerHolds a container for EcRrtUtility
 CEcRunNextTaskWhileWaiting
 CEcRunningAverageFilterPerforming running average for both on-line and off-line applications
 CEcRunTimeSimulationModificationAn abstract base class for modifying a simulation
 CEcRunTimeSimulationModificationVectorA vector of classes derived from EcRunTimeSimulationModification
 CEcSagEndEffectorA gravitational sag constraint
 CEcSbJointActuatorHolds a class to describe the link joint actuator
 CEcSbKinematicsHolds a class to describe link kinematics
 CEcSbLinkDataHolds a class to describe a link
 CEcSbManipulatorCollectionDataHolds a class to describe a manipulator
 CEcSbManipulatorDataHolds a class to describe a manipulator
 CEcSbManipulatorDataVectorHolds a container for manipulator data
 CEcSbPhysicalExtentHolds a class to describe the link physical extent
 CEcScalarBasedEndEffectorAn abstract class for end effector that uses scalar motion filter
 CEcScalarFunctionContainerA container for a unitary map (a scalar function mapping 0-1 to 0-1)
 CEcScalarManipulatorFunctionProvides a base class for scalar functions of a manipulator's position state
 CEcScalarMotionFilterHolds a description of a scalar-motion filter system
 CEcScalarMultivariableFunctionProvides a base class for scalar functions of multiple variables
 CEcScalarMultivariableOptimizerHolds a description of a base class for optimizers
 CEcScalarMultivariableOptimizerContainerHolds an optimizer container
 CEcScalarMultivariableOptimizerVectorHolds a description of a vector of scalar multivariable optimizer objects
 CEcSchunkArmInfo
 CEcSchunkHandInfo
 CEcSchunkSimulationCreator
 CEcScrewTypeLinkA type of joint to rotate and translate at the same time
 CEcSCurveUnitaryMapHolds a description of a unitary map that is shaped like an s-curve. It uses two pieces of rational polynomials. The form used for each of the two pieces is a0 x^2 + a1 x f = ----------— (b-x)
 CEcSecondMomentRepresents a 3D second moment. To do this, it uses six quatities, Jxx, Jyy, Jzz, Jxy, Jxz, Jyz. When organized into the traditional symmetric 3x3 matrix these give the following: |Jxx Jxy Jxz| J = |Jxy Jyy Jyz| |Jxy Jyz Jzz| Jxx= Integrate[y*y + z*z dm] Jyy= Integrate[x*x + z*z dm] Jzz= Integrate[x*x + y*y dm] Jxy=-Integrate[x*y dm] Jxz=-Integrate[x*z dm] Jyz=-Integrate[y*z dm]
 CEcSendSignalDirectionConcrete implementation of EcStageDirection for sending a signal that can be handled in the external interface
 CEcSendSignalExampleDirectionConcrete implementation of EcStageDirection for sending a signal that can be handled in the external interface
 CEcSendSignalExampleDirectionEditorConcrete implementation of EcManipulationSceneDirectionEditor for creating EcSendSignalExampleDirectionWidget
 CEcSendSignalExampleDirectionWidget
 CEcSensorBaseHolds a description of a base sensor
 CEcSensorBaseDataCaptureTypeA class for capturing joint velocities
 CEcSensorDataCaptureA base class used for configuration data capture of link data
 CEcSensorNoiseBase Class of image sensor noise
 CEcSensorNoiseVectorHolds a vector of instances of EcSensorNoise and its derived classes
 CEcSensorStateMapHolds a vector of instances of EcSensorBase::State and its derived classes
 CEcSensorStateVectorHolds a vector of instances of EcSensorBase::State derived classes
 CEcSensorVectorHolds a vector of instances of EcSensorBase and its derived classes
 CEcSequenceOptimizerHolds an optimizer that itself contains a sequence of other optimizers
 CEcSerialSerial port implementation
 CEcSerialBaseAbstract serial port base class
 CEcServoJointCalibrationPointIndividual parameters used to configure hardware
 CEcServoJointCalibrationPointVectorXML Vector container for EcServoJointCalibrationPoint
 CEcSetAttachmentDirectionConcrete implementation of EcStageDirection for attaching another role to the specified link of this role in the scene
 CEcSettings
 CEcSettingsXml
 CEcSewAngleEndEffectorAn end-effector component that represents a SEW (Shoulder-Elbow-Wrist) angle
 CEcSG3DInputData
 CEcSGWidgetQt
 CEcShadowParametersHolds a description of shadow parameters for viewing the system
 CEcShaferXmlParamsHolds parameters that are sent to Nalpeiron library
 CEcShapeVirtual base class for all shapes
 CEcShapeAccumulatorAccumulator class for managing shapes
 CEcShapeCollisionDataHolds a class for caching collision data between two shapes
 CEcShapeCollisionEventHolds a class to describe a shape query descriptor
 CEcShapeCollisionSurfaceHolds the collision surface of at most 4 points between two shapes
 CEcShapeCollisionToolHelper class for computing collision data between shapes
 CEcShapeContactSurfaceHolds the contact surface of at most 4 points between two shapes
 CEcShapeContainerHolds a description on a shape container
 CEcShapeFeatureHistogramA histogram produced from EcShapeFeatureSet
 CEcShapeFeatureNormalizedHistogramA histogram produced from EcShapeFeatureSet
 CEcShapeFeatureSetA set of features that define a shape for shape matching
 CEcShapeKey
 CEcShapeMatchingAlgorithmAlgorithms used for shape matching
 CEcShapePointEventHolds data describing a point event on a shape
 CEcShapeProximityDataHolds a class to describe a shape proximity related data
 CEcShapeProximityDescriptorHolds a class to describe a shape query descriptor
 CEcShapeProximityKey
 CEcShapeProximityToolHelper class to calculate distance between shapes
 CEcShapeQueryDataHolds a class to describe a shape query result
 CEcShapeQueryDescriptorHolds a descriptor class to describe a shape query
 CEcShapeQueryResultHolds a class to describe a shape query result
 CEcShapeStateCacheKeyDefines a class for describing a key for accessing the shape proximity database
 CEcShapeUnion
 CEcShapeVectorImplementation of the EcShapeVector class
 CEcSharedDataContainer
 CEcSharedDataStore
 CEcSimpleIssuesHolds the details of issues EcSimpleIssues
 CEcSimpleStudyHolds a set of basic studies, each of which corresponds to a single simulation run
 CEcSimulationAllLoaderHolds a tool for loading simulations from various file types
 CEcSimulationAndStudyContainer of simulation and study
 CEcSimulationBuilderBaseHolds a base class to describe a simulation builder
 CEcSimulationBuilderContainerHolds a container for a simulation builder
 CEcSimulationConversionToolProvides a tool for coverting other formats to XML
 CEcSimulationCoreA class to handle simulation in Viewer. It provides additional GUI-based functionality to EcIODataBroker. It contains an instance of EcSystemSimuation and a timer
 CEcSimulationExpanderHolds a tool for expanding physical components into stated systems and simulations
 CEcSimulationGraspingControlInterfaceControl interface used inside EcPerformGraspFunctor
 CEcSimulationModificationAn abstract base class for modifying a simulation
 CEcSimulationModificationVectorA vector of classes derived from EcSimulationModification
 CEcSimulationPreferencePagePage for Simulation preferences
 CEcSingleStepValueExampleConditionConcrete implementation of EcDirectionCondition for determining if the current role has an attachment
 CEcSingleStepValueExampleConditionEditorConcrete implementation of EcDirectionConditionEditor for creating EcSingleStepValueExampleConditionWidget
 CEcSingleStepValueExampleConditionWidget
 CEcSingularityProximityFunctionProvides a measure of proximity to a avoidance
 CEcSixAxisFTSensorSimulates and processes a six-axis force/torque sensor
 CEcSixBarSliderToRotaryMechanismA Six bar linkage mechanism converting prime mover's linear motion (for ex. hydraulic piston) into rotational joint motion about joint axis
 CEcSlideXSpinZEndEffector
 CEcSlidingEndEffectorA sliding end effector. Modified from frame endeffector. We will let it move along x but fix everything else
 CEcSmartMutexA smart mutex is one that combines the characteristics of both a shared mutex (one writer/multiple readers) with that of a recursive mutex (multi-locking within same thread). This implementation builds upon a shared mutex and provides checking against the currently running thread to remove the occurrance of deadlocks
 CEcSocketBaseBase class for TCP/UDP socket support
 CEcSocketHeaderDefinition of socket message header
 CEcSoftConstraintHandlerContainerHolds a container for a soft-constraint handler
 CEcSolutionFinderImplements a IK solution finder used to find a joint solution given the end-effector placement
 CEcSolutionFinderContainerHolds a container for EcSolutionFinder
 CEcSolutionFindingDirectionStateA manipulation sequence
 CEcSolutionValidatorUsed to validate a joint solution. The most commonly used case is to validate whether the joint solution is collision-free. But it can used for other validation purposes as well. Other validations can be done in the derived class
 CEcSolutionValidatorContainerHolds a container for EcSolutionValidator
 CEcSpatialMatrixHolds a 3x3 matrix as three row vectors
 CEcSpatialMomentumEndEffectorA momentum end effector
 CEcSphereHolds a class to describe a 3D sphere
 CEcSphereDistanceAlgorithmClass for distance algorithm involving sphere
 CEcSphereFittingMethods for fitting to a sphere
 CEcSplineControlPointSpline control point class
 CEcSplineTrajectorySpline trajectory class
 CEcSplineVectorSpline vector class
 CEcSpringAndDamperBetweenLinksDescribes a spring and damper between two links
 CEcSpringDamperPropertiesQWrapperWrapper for EcSpringProperties
 CEcSpringPropertiesDefines the spring force on a joint as a function of this and other joint values
 CEcStageDirectionVirtual base class of EcManipulationSceneDirection for implementing "stage" directions from the director
 CEcStageDirectionReferenceConcrete implementation of EcStageDirection that references a manipulation direction stored within the director's object directory
 CEcStageDirectionReferenceStateConcrete implementation of EcManipulationSceneDirectionState for holding EcStageirectionReference state information
 CEcStageIBarbellGraspingRhThis class provides stage I barbell grasping for the Robonaut hand
 CEcStageIBoxGraspingRhThis class provides stage I box grasping for the Robonaut hand
 CEcStageICapsuleGraspingRhThis class provides stage I capsule grasping for the Robonaut hand
 CEcStageIGraspingContainerContainer for stage I grasping
 CEcStageIIGraspingContainerContainer for stage I grasping
 CEcStageIIGraspingPassThroughThis class provides a pass-through Stage II processor
 CEcStageIIIGraspingContainerContainer for stage I grasping
 CEcStageIIIGraspingPassThroughThis class provides a pass-through Stage II processor
 CEcStageINewSphereGraspingRhThis class provides stage I sphere grasping for the Robonaut hand
 CEcStageIRobonautPalmAndFingersThis class provides foundation stage I grasping for a Robonaut hand
 CEcStageISequenceGraspingThis class provides foundation stage I grasping for a Robonaut hand
 CEcStageISphereGraspingRhThis class provides stage I sphere grasping for the Robonaut hand
 CEcStandardFrameA single frame of a manipulation sequence
 CEcStandardGraspFrameA single frame of a grasp sequence
 CEcStandardGraspFrameStateA single frame of a grasp sequence
 CEcStandardGraspRunManager
 CEcStandardManipulationFrameStateA single frame of a manipulation sequence
 CEcStartFromHereVisitorVisitor implementation for starting in a different spot in the script
 CEcStartStateAndPathClass that contains a start position state and path (vector of position states)
 CEcStateCallbackClass for publishing new data
 CEcStateConstraintContainerContainer of EcBaseStateConstraint
 CEcStateConstraintVectorVector of EcBaseStateConstraint
 CEcStatedSystemHolds a description of the manipulator system and its state
 CEcStatedSystemExampleDemonstrates EcStatedSystem
 CEcStatedSystemStructA convenience class that contains a stated system and the index of a manipulator of interest
 CEcStateEqualityConstraintVectorVector of EcBaseStateEqualityConstraint
 CEcStateModificationHolds a description of a modification to a desired end-effector position
 CEcStatePathA time stepped sequence of manipulator states
 CEcStateRandomModificationA class for modifying the state of the whole system with random variation
 CEcStateRandomVariationDescription of random variation for manipulator state
 CEcStochasticContinuousLinearTimeInvariantSystem
 CEcStochasticDiscreteLinearTimeInvariantSystem
 CEcStopDirectionConcrete implementation of EcStageDirection that simply returns false. This is useful to use in exceptions for conditional directions
 CEcStoppingCriterionVectorHolds a description of a vector of criteria for stopping a single manipulator
 CEcStrengthOptimizationFunctionComputes the sum of the normalized joint torques, to be used for strength optimization
 CEcStringValueDirectionSimpleStateConcrete implementation of EcManipulationSceneDirectionSimpleState for conditional direction
 CEcStructuralForceDataCaptureTypeA class for capturing structural forces
 CEcStudyGraspRunManager
 CEcSubJacobianMapHolds the index maps of sub-Jacobians
 CEcSubsequenceGraspFrameA single frame of a grasp sequence
 CEcSubsequenceGraspFrameStateA single frame of a grasp sequence
 CEcSubsequenceManipulationFrameA single frame of a manipulation sequence
 CEcSubsequenceManipulationFrameStateA single frame of a manipulation sequence
 CEcSupplementalControlStateHolds the supplemental state of a control system
 CEcSurfaceColorFactoryProvides methods to create default color surface properties (data maps)
 CEcSurfacePropertyModificationA class for modifying surface property of a link in a stated system
 CEcSurfacePropertyRandomVariation
 CEcSvdToolProvides a tool for calculating the singular value decomposition
 CEcSyntheticColorImageSensorA concrete class describing a "synthetic" or "virtual" color image sensor
 CEcSyntheticImageSensorDescriptorA class describing the "synthetic" or "virtual" part of an image sensor
 CEcSystem3dsLoader3DS file loader
 CEcSystemActiveBoundingBoxStateClass for holding the system wide active bounding box state. This maintains a sorted list of bounding boxes for each link and base in the system that can be used for fast intersection testing
 CEcSystemActiveCollisionStateClass for holding the system wide active bounding box state. This maintains a sorted list of bounding boxes for each link and base in the system that can be used for fast intersection testing
 CEcSystemActiveStateThis class is a container for all active states in a system. These are used for dynamic programming in manipulator control and simulation
 CEcSystemAllLoaderHolds a tool for loading system from various file types
 CEcSystemCfgLoaderHolds a tool for loading systems from NASA .cfg file types
 CEcSystemCollisionExclusionMapHolds a map describing which collision pairs should be excluded
 CEcSystemControlExecutiveHolds a stated system and its position control system
 CEcSystemDataCaptureCapture the data of the whole system
 CEcSystemDataStorageHolds a description of captured system data
 CEcSystemDataVectorHolds a vector of various types of system data
 CEcSystemEmbeddedUrdfLoaderEmbedded URDF file loader
 CEcSystemEnvironmentHolds a description of a manipulator system environment
 CEcSystemModificationAn abstract base class for modifying a system
 CEcSystemPntpLoaderHolds a tool for loading system from pntp files, which define the .pp,.sys, and .state files for the manipulator
 CEcSystemPointEventHolds data describing a point collision
 CEcSystemRandomModificationA class for modifying the whole system with random variation
 CEcSystemRandomVariationDescription of random variation for link properties for the whole system
 CEcSystemS3dsLoaderHolds a tool for loading system from s3ds files, which define the .p3ds,.sys, .state, and .txtr files
 CEcSystemShapeCollisionCacheHolds state information related to the proximity of shapes in the system
 CEcSystemShapeProximityStateHolds state information related to the proximity of shapes in the system
 CEcSystemSimulationHolds a simulation environment for a stated system and its position control system
 CEcSystemStoredDataA class used to manage data storage
 CEcSystemTecplotLoaderTecplot file loader
 CEcSystemVecLoaderHolds a tool for loading system from NASA .vec file types
 CEcSystemVrml97LoaderVRML97 file loader
 CEcTableFunctionInterpolatorInterpolator class for table functions
 CEcTableFunctionVectorSearchIndependent variable class for table functions
 CEcTaskFunctorTypeInfo
 CEcTaskStatus
 CecTcpEchoBase
 CEcTcpQueue
 CEcTcpServerThreadTCP server
 CEcTcpSocketTCP socket class
 CEcTcpStreamOutput TCP stream class
 CEcTerrainHolds a class to describe a terrain field (height data)
 CEcTerrainDistanceAlgorithmClass for distance algorithm involving terrain
 CEcTerrainUnion
 CEcTestSimulationBuilderHolds a class to create test manipulators
 CEcTetrahedralLozengeHolds a class to describe a tetrahedral lozenge
 CEcTetrahedralLozengeDistanceAlgorithmClass for distance algorithm involving tetrahedral lozenge
 CEcTetrahedronHolds a class to describe a tetrahedron
 CEcTetrahedronDistanceAlgorithmClass for distance algorithm involving Tetrahedron
 CEcTextOutputWriterA class for writing simulation outputs to files in comma-delimited text format
 CEcThreadSafeMotionScriptProvides thread-safe access to a manipulator motion script
 CEcTimeDurationTransitionEventThis class provides foundation stage I grasping for a Robonaut hand
 CEcTimeDurationTransitionEventStateThis class provides foundation stage I grasping for a Robonaut hand
 CEcTimedWaitDirectionConcrete implementation of EcManipulationDirection for waiting a specified amount of time from the director
 CEcTimedWaitDirectionStateConcrete implementation of EcManipulationSceneDirectionState for holding EcTimedWaitDirection state information
 CEcTimedWaitExampleDirectionConcrete implementation of EcManipulationDirection for waiting a specified amount of time from the director
 CEcTimedWaitExampleDirectionEditorConcrete implementation of EcManipulationSceneDirectionEditor for creating EcTimedWaitExampleDirectionWidget
 CEcTimedWaitExampleDirectionStateConcrete implementation of EcManipulationSceneDirectionState for holding EcTimedWaitExampleDirection state information
 CEcTimedWaitExampleDirectionWidget
 CEcTimerProvides wall clock timing functionality
 CEcTimerUtilA utility class for timing
 CEcTireBackendBaseCompute the external cosimulation force(s)
 CEcTireBackendDummyCompute the external cosimulation force(s)
 CEcTireCosimulationModuleCompute the external cosimulation force(s)
 CEcTireProviderBaseCompute the external cosimulation force(s)
 CEcTireProviderDirectCompute the external cosimulation force(s)
 CEcTireRequesterBaseCompute the external cosimulation force(s)
 CEcTireRequesterDirectCompute the external cosimulation force(s)
 CEcTokenAn EcString-like class that holds a tag and a namespace
 CEcToolOffsetDirectionConcrete implementation of EcStageDirection for modifying a tool offset
 CEcToolPath
 CEcToolPathDirectionA manipulation sequence
 CEcToolPathDirectionStateA manipulation sequence
 CEcTorqueSensorSimulating and processing a joint torque sensor
 CEcTotalTorqueToolProvides a tool for torque/force calculation
 CEcTouchLinearForceControllerThe class for force controller handling touch sensors and linear-constraint end-effectors
 CEcTouchSensorSimulating and processing a touch sensor
 CEcTrainingSet1Holds example code for training set 1
 CEcTrainingSet2Holds example code for training set 2
 CEcTrainingSet3Holds example code for training set 3
 CEcTrainingSet4Holds example code for training set 4
 CEcTrainingSet5Holds example code for training set 5
 CEcTrajectoryGeneratorVectorVector of trajectory generators
 CEcTrapezoidalProfileTool
 CEcTreeNodeClass that represents a node in a tree used in RRT path planning
 CEcTreeNodeGraph
 CEcTreeNodeIndex
 CEcTriangleA tiangle class. It holds a list of indices into a vertex list,
 CEcTriangularLozengeHolds a class to describe a 3D triangular lozenge (fixed distance from a filled 3D triangle)
 CEcTriangularLozengeDistanceAlgorithmClass for distance algorithm involving triangular lozenge
 CEcTriangularLozengeFittingMethods for fitting to a triangular lozenge
 CEcTriIndTriangle indices
 CEcTriPhysicalExtentA class describing the physical extent of a link. It includes a description of the mesh and the surface properties
 CEcTruncatedIcosahedronProvides a tool for operating with a truncated icosahedron, or buckyball, a three-dimensional polytope with 60 vertices, 90 edges, 12 pentagon faces, and 20 hexagon faces. All vertices lie on the surface of a sphere
 CEcUdpQueue
 CEcUdpServerThreadUDP server
 CEcUdpSocketUDP socket class
 CEcUnaryDirectionConditionAbstract EcDirectionCondition for unary operations on a wrapped condition
 CEcUnitaryMapContainerA container for a unitary map (a scalar function mapping 0-1 to 0-1)
 CEcUnitManagerClass to manage unit
 CEcUpdateManipDirScriptVisitorVisitor implementation for appending a scene
 CEcUserManagerProvides user account management
 CEcUserManagerDataProvides data for user managers
 CEcVecPhysicalExtentConverterHolds a description of a class for converting Enigma vec files into physical extents
 CEcVectorA three-element vector
 CEcVectorF2For texture coordinates
 CEcVectorF3For vertices
 CEcVectorMultivariableFunctionProvides a base class for scalar functions of multiple variables
 CEcVectorMultivariableOptimizerHolds a description of a base class for optimizers
 CEcVectorMultivariableOptimizerContainerHolds an optimizer container
 CEcVectorMultivariableOptimizerVectorHolds a description of a vector of vector multivariable optimizer objects
 CEcVectorSearchIndependent Variable Search Class
 CEcVectorSearchEnumsEnumeration class to support EcVectorSearch
 CEcVectorWidgetWidget to numerically edit and display guide frame values
 CEcVelocityControlDataJoint rates with extra data, all of which is used as the result of a control expression
 CEcVelocityControlExampleHolds the velocity-control code described in the Users Guide
 CEcVelocityControllerHolds a description of a velocity controller for one manipulator
 CEcVelocityControlSystemHolds a description of a velocity control system, which includes a manipulator system, a description of end effectors, and a description of control systems
 CEcVelocityStateHolds a description of the position state of a manipulator. This includes the joint velocities and the frame velocity of the base. The base velocity is the motion of the base with respect to the system, expressed in system coordinates, with point of application at the origin of the base frame
 CEcVelocityStateModificationHolds a description of a modification to a link (joint velocity)
 CEcVelocityStateRandomVariationDescription of random variation for velocity state of an individual manipulator
 CEcViewerParametersHolds a description of parameters to control the GUI viewer
 CEcViewerPreferencePagePage for viewer user interaction preferences
 CEcViewPointOrientationSamplerProvides a tool for sampling the orientation space specified via view parameters azimuth, elevation, and roll
 CEcVisualizableStatedSystemHolds a description of a stated system and all the parameters needed to visualize it
 CEcVisualizationParametersHolds a description of all the parameters related to visualizing the simulation
 CEcVrml97ConversionHandlerConverter for VRML model to stated system
 CEcVrml97GrammarHolds VRML 97 grammar
 CEcVrml97ParserVRML 97 parser
 CEcVrml97SkipGrammarVRML 97 skip grammar
 CEcWaitCollection of waiting methods
 CEcWaitDirectionConcrete implementation of EcManipulationDirection for waiting for conditions
 CEcWaitDirectionStateConcrete implementation of EcManipulationSceneDirectionState for holding EcWaitDirection state information
 CEcWalkingExampleHolds the code for creating hexapod walking demo
 CEcWaypointInterpolatorAn abstract base class for waypoint interpolator
 CEcWaypointInterpolatorContainerContainer for manipulation actions
 CEcWaypointSequenceDirectionA waypoint sequence
 CEcWaypointSequenceDirectionStateA manipulation sequence
 CEcWelcomeForm
 CEcWelcomeWidget
 CEcWhileDirectionConcrete implementation of EcManipulationDirection for running While directions from the director
 CEcWlsSoftConstraintHandler
 CEcWorkerThreadPoolManaging threads used for long-running calculations
 CEcX2FunctionProvides an example function for testing
 CEcXEndEffectorHolds a base class for a 1D point end-effector component
 CEcXml2DCircleImplementation of the EcXml2DCircle class;
 CEcXml2DEllipseImplementation of the EcXml2DEllipse class;
 CEcXml2DPointImplementation of the EcXml2DPoint class;
 CEcXml2DPolygonImplementation of the EcXml2DPolygon class;
 CEcXml2DRectangleImplementation of the EcXml2DRectangle class;
 CEcXml2DShapeImplementation of the EcXml2DShape class; base class for all the 2D shapes
 CEcXml2DShapeVectorImplementation of the EcXml2DShapeVector class
 CEcXmlBaseVariableCompoundTypeHolds a compound set of XML data
 CEcXmlBasicTypeA template class for basic types that can be read and written to XML streams
 CEcXmlBinaryStringXML wrapper to provide customized serialization for binary strings
 CEcXmlCompoundTypeAn XML object that holds a compound set of XML data
 CEcXmlDomAttributeXML attribute
 CEcXmlDomDocSimple XML document
 CecXmlDomDoc
 CEcXmlDomNodeXML node object
 CEcXmlEmbeddedStringAn XML wrapper to provide customized reading for embedded XML
 CEcXmlEnumTypeA template class for basic enumeration types that can be read from and written to XML streams
 CEcXmlExampleHolds a description of an example XML compound type
 CEcXmlFactoryHolds a factory for creating XML objects
 CEcXmlFileReaderAn XML parser object that can read a single file
 CEcXmlListTypeAn XML readable/writable list container
 CEcXmlMapTypeAn XML readable/writable Map
 CEcXmlObjectA base class for xml objects
 CEcXmlObjectReaderWriterHelper class to support reading and writing of an EcXmlObject using several methods
 CEcXmlOrientationDefined class for describing orientation
 CEcXmlOutputWriterA class for writing simulation outputs to files in XML format
 CEcXmlPairTypeAn XML readable/writable Pair. Can hold any to types of XML objects
 CEcXmlReaderAn XML file reader
 CEcXmlSchemaClass for generating schemas
 CEcXmlSchemaAttributeTypeCode for schema attributes
 CEcXmlSchemaComplexTypeCode for schema complex types
 CEcXmlSchemaElementClass defines each element of the schema
 CEcXmlSchemaElementTypeAn Xml schema element type
 CEcXmlSchemaGlobalElementTypeCode for schema global element types
 CEcXmlSchemaGroupTypeCode for schema group types
 CEcXmlSetTypeAn XML readable/writable set container
 CEcXmlSubclassExampleHolds a description of an example XML subclassed compound type
 CEcXmlVariableElementTypeHolds an abstract base class for a variable element type
 CEcXmlVariableMapTypeA template class that is XML readable/writable for holding maps of XML objects
 CEcXmlVariablePropertyEditorTemplate class for property editor customized for EcXmlVariableElementType
 CEcXmlVariableSharedElementTypeHolds an abstract base class for a variable shared element type
 CEcXmlVariableVectorTypeA template class that is XML readable/writable for holding vectors of XML objects
 CEcXmlVectorThis compound type is added as wrapper to the EcVector basic type. This allows flexibility in the XML read and write operations
 CEcXmlVectorBasicTypeA template class that is XML readable/writable for holding vectors of basic XML objects. Underlying container is vector of basic non-xml type
 CEcXmlVectorTypeA template class that is XML readable/writable for holding vectors of XML objects
 CEcXmlVectorVectorA template class that is XML readable/writable for holding vectors of XML objects
 CEcXmlWriterXML file writer
 CEcXorDirectionConditionConcrete implementation of EcBinaryDirectionCondition for returning the logical XOR of two conditions
 CEcXyEndEffectorHolds a base class for a 2D point end-effector component
 CEcXyStateEqualityConstraintA 2D point state constraint
 CEcZeroTrapezoidalProfileTool
 CexampleDockWidgetPlugin
 CexampleGUIPluginA Qt-based GUI plugin example for creating code that will interface with Energid's viewer
 CexampleHardwarePluginProvides additional response and support in the plugin that is mainly targeted at hardware-connections
 CexampleIoDirectionPluginThis example show how to use EcDataMapDirections in director for Digital IO
 CexamplePluginPlugin device driver example for creating code that will interface with Energid's viewer. It can be used for a variety of applications, from a simple data logger, to a hardware interface, to a customized GUI
 CLinkKeyCollisionPair
 ClinkProximityKeyHash
 CMainWidgetSoftware update widget
 CmelodramaPluginResponds to signals from the melodrama manipulation director
 CnamedFramePluginA plugin to view and edit named frames
 CsimulationPlugin
 CviewerInteractionPluginModifies parameter to reflect user interaction choices from the viewer preference page
Created by Energid Technologies www.energid.com
Copyright © 2016 Energid. All trademarks mentioned in this document are property of their respective owners.