| OSCAR::AbsPosMC | |
| OSCAR::ArmMC | |
| OSCAR::Array< Type > | |
| OSCAR::Array< Type > | This class is a generic template array class |
| OSCAR::ArtificialPotentialF | A function to calculate artificial potential field (APF) |
| OSCAR::ATISensor | Derived class for ATI Force/Torque sensors. This class is derived from the abstract template class Sensor<Type>. Since this class is used to sense 6D end-effector force vectors accompanied by an error state, Sensor<Type> is customized to Sensor<Vector7> Note: This implementation of the ATI F/T sensor interfaces through the serial port. However, it can interface through DAQ too. The sensor controller supports tool transformations, temperature compensation, biasing, and a variety of error checking |
| OSCAR::Base | Acts as the base class for all OSCAR classes |
| OSCAR::BaseController | |
| OSCAR::BezierCurve | This class can be used to generate Bezier Curves from provided control points. A Bezier Curve will interpolate the starting and end points and will stay within the convex hull of the control points |
| OSCAR::Bit3IO | |
| OSCAR::Box | A box obstacle used for modeling of objects in workcells |
| OSCAR::BoxData | Reads and writes a Box to and from an XML data file |
| OSCAR::BSpline | This class can be used to generate B-Spline curves. B-Splines are an advanced curve form that allows for the order to be set by the user instead of being defined by the number of control points. The Bezier curve is a special form of the B-Spline |
| OSCAR::CartesianControl | |
| OSCAR::CollisionDetection | Collision Detection Class |
| OSCAR::CollisionPoint | |
| OSCAR::Cone | A cone primitive used for modeling of objects in workcells The cone (in its local frame) will be symmetric about the y axis and its total height will be centered at y=0 with the tip of the cone at y=height/2. The cone can then be moved in its local from by specifying a local transform |
| OSCAR::ConeData | Reads and writes a Cone to and from an XML data file |
| OSCAR::Control | |
| OSCAR::ControlInformation | |
| OSCAR::Controller | |
| OSCAR::ControlParam | |
| OSCAR::CoordinateSpace | Specifies the properties of a coordinate space |
| OSCAR::CoordinateVector | Create a vector that has coordinate space information |
| OSCAR::CriteriaProperties | |
| CriteriaProperties | Class that holds properties for each option evaluated by a particular criterion |
| OSCAR::CriteriaPropertiesRepository | CriteriaPropertiesRepository is a repository class which holds results \ calculated by the criteria to allow data sharing |
| OSCAR::CTPDJointControl | |
| OSCAR::CubicPoly | This class allows the user to create a cubic polynomial trajectory by specifying initial and final positions and accelerations |
| OSCAR::Cylisphere | A cylispherical object for use in robot or as obstacle |
| OSCAR::CylisphereData | Reads and writes a Cylisphere to and from an XML data file |
| OSCAR::DeltaMC | |
| OSCAR::DeltaWithForceMC | |
| OSCAR::Device | |
| OSCAR::DHData | Reads DH parameters from a data file or programmatically create them |
| OSCAR::Diff | A class for numerically computing derivatives |
| OSCAR::DIO | Abstract class for Digital IO |
| OSCAR::DistanceCalculator | Interface class for Distance Calculators |
| OSCAR::DistanceResults | |
| OSCAR::DistanceResultsRepository | DistanceResultsRepository is a repository which holds DistanceResults objects, which in turn contain the witness points between manipulators and their surroundings, unit vectors pointing from the manipulator witness points, the magnitude of the distance between witness points, and the G and H functions of the witness points |
| OSCAR::DLSEqnSolver | This class contains methods for calculating solutions to the linear system Ax=b |
| OSCAR::Drill | Drill provides a C++ interface to the custom drill tool for the Robotics Research Arm. This class uses DIO abstract class for IO with the drill. The tool frame for the drill is also set during the construction of this object. A call to GetToolFrame will return the tool frame. The units in which the tool frame is returned are inches. The base plate of the drill is defined in the XY plane, with the Z axis from the drill base plate to the center contact point of the drill |
| OSCAR::DynamicScaling | This class allows the user to scale joint trajectories to meet velocity, acceleration or torque limits. Time is scaled |
| OSCAR::EEPerturbation | This class creates a series of options in a sphere around the end-effector |
| OSCAR::EqnSolver | This class contains methods for calculating solutions to the linear system Ax=b |
| OSCAR::FifthOrderPoly | This class allows the user to create a fifth order polynomial trajectory by specifying initial and final conditions for positions,velocities and accelerations |
| OSCAR::FixedSizeArray< Arr, sz > | A template class that allows the creation of specific type arrays with a defined fixed size |
| OSCAR::FixedSizeMatrix< nRows, nCols > | A template class that allows the creation of specific matrices with a defined fixed size |
| OSCAR::FKAcceleration | |
| OSCAR::FKJacobian | |
| OSCAR::FKJacobianBase | |
| OSCAR::FKJacobianMitsubishi | This class computes a semi closed-form of the Jacobian matrix for the Mitsubishi robot |
| OSCAR::FKJacobianPlanar3R | |
| OSCAR::FKPosition | |
| OSCAR::FKPositionBase | Interface class that specifes the minimum interface a derived class should have that implements a forward position solution. Derived classes can implement this interface and also inherit from Kinematics to implement additional functionality |
| OSCAR::FKPositionMitsubishi | This class contains the ForwardKinematics interface for a Mitsubishi manipulator |
| OSCAR::FKPositionPuma | This class contains the ForwardKinematics interface for a Puma manipulator |
| OSCAR::FKPositionSpatial3R | This class contains the ForwardKinematics interface for a Spatial 3R manipulator |
| OSCAR::FKVelocity | |
| OSCAR::ForwardDynamics | A class to calculate forward dynamics dynamic simulation purposes |
| OSCAR::GeneralKeyboard | |
| OSCAR::GeneralKinematicsHandler | |
| OSCAR::HandPose | Represents a 6 element vector whose 1st 3 elements hold the X,Y,Z positions and the last three hold the orientation |
| OSCAR::HandPoseMotion | This class is designed specifically for developing Cartesian space End-Effector motion using HandPoses |
| OSCAR::HandPoseRepository | HandPoseRepository is a repository class which holds HandPose data calculated by the criteria to allow data sharing |
| OSCAR::IDLagrange | Inverse dynamics using Lagrange |
| OSCAR::IDNewtonEuler | Inverse dynamics using Newton-Euler |
| OSCAR::IDSANewtonEuler | Standalone inverse dynamics using Newton-Euler |
| OSCAR::IDStandAlone | An abstract class for stand-alone inverse dynamics |
| OSCAR::IKCCD | |
| OSCAR::IKDirectSearch | This class contains methods for calculating inverse position and velocity solutions for serial manipulators using the Resolved Rate technique |
| OSCAR::IKJacobian< JacobianType > | This class contains methods for calculating inverse position and velocity solutions for serial manipulators using the Resolved Rate technique |
| OSCAR::IKJAvoidLimits< JacobianType > | This class is used to calculate the inverse position solution using a weighting matrix based on the joint limits |
| OSCAR::IKJDLS< JacobianType > | IKJacobian with Damped Least Square (DLS) technique |
| OSCAR::IKJGenerateOptions< JacobianType > | Generates a set of inverse kinematics solutions for redundant serial manipulators |
| OSCAR::IKJReconfig< JacobianType > | Used to calculate the inverse position solution using the active/inactive functionality |
| OSCAR::IKJTranspose | This class contains methods for calculating inverse position solutions for serial manipulators (especially low DOF manipulators) using the Jacobian Transpose technique |
| OSCAR::IKMitsubishi | IKMitsubishi Implements a closed form solution for a standard Mitsubishi Robot |
| OSCAR::IKPosition | IKPosition acts as the base class for inverse position functionality |
| OSCAR::IKPuma | IKPuma Implements a closed form solution for a standard Puma Robot |
| OSCAR::IKVelocity | IKVelocity acts as the base class for inverse velocity functionality |
| OSCAR::ImpedanceControl | |
| OSCAR::ImpedanceFilter | |
| OSCAR::Integrator | Integrator class is used to solve an ODE problem, i.e |
| OSCAR::InverseDynamics | An abstract class for calculating inverse dynamics. All the calculated torque values are the "required" actuator torques (not the torques acting on the actuators) |
| OSCAR::JointControl | |
| OSCAR::JointVector | Used to pass joint position values |
| OSCAR::KB2017Interface | |
| OSCAR::KeyboardMC | |
| OSCAR::Kinematics | |
| OSCAR::KinematicsHandler | KinematicsHandler describes an abstract class for computing the forward and inverse kinematics of serial robot arms. This class also checks for position limits. User should derive a specific class from this or use the GeneralKinematicsHandler class that is derived from KinematicsHandler. This class and dervied classes implement functionality that computes the forward and inverse position solution. It also checks joint travel limits and singularities. Objects of this class will always maintain a valid joint state and the corresponding cartesian state. Inputs that violate position limits or lead to singularities will not lead to an erroneous state of the system |
| OSCAR::KraftMC | |
| OSCAR::Limit | |
| OSCAR::Limits | A Limits object is used to store binary limits data for robot joints. These include min and max. These limits are generally used for Position, Velocity, Current, Acceleration and Torque. In additon to limits, the Limits object can also contain the excess error associated with a joint. These excess errors can be specified for all different limits type. Generally, they are specified for position and current |
| OSCAR::LimitsData | Reads Limits data from a data file or programmatically create them. LimitsType template argument should either be "Position", "Velocity", "Acceleration", "Current", or "Torque" |
| OSCAR::LimitStatusArray | |
| OSCAR::MachineInterface | |
| OSCAR::MagellanMC | |
| OSCAR::ManipulatorData | Reads a manipulator model from a data file or programmatically create them |
| OSCAR::ManipulatorData::Configuration | |
| OSCAR::ManipulatorData::ConfigurationData | Stores a named joint configuration |
| OSCAR::ManualController | |
| OSCAR::Matrix | This class is a 2D array of doubles that contains the appropriate functionality for managing robotics data |
| OSCAR::MatrixCol | This class creates a pointer to a column in a Matrix |
| OSCAR::MatrixData | Reads data from a file that is represented in matrix format |
| OSCAR::MatrixRepository | MatrixRepository is a repository class which holds vector data calculated by the criteria to allow data sharing |
| OSCAR::MatrixRow | This class creates a pointer to a row in a Matrix |
| OSCAR::MCDIO | Class for digital IO using Measurement Computing DAQ boards |
| OSCAR::ModelingObject | Abstract base class for Primitives and Nodes |
| OSCAR::ModelingObjectMap | Contains an STL map which indexes the name of ModelingObjects (Nodes and Primitives) with their address. Useful for finding the address of a modeling Node or Primitive just by knowing its name. The key to the STL map is an OSCAR::String, the data type being stored is ModelingObject* |
| OSCAR::MotionParameters | This class is used to store the parameters used for generating trajectories. These parameters include: total time for trajectory, sampling time, a vector of start positions, a vector of stop positions, and a filename/matrix of motion constraints. This class is passed to the OfflineMotionPlanner before calculating a trajectory |
| OSCAR::MotionPlanner | |
| OSCAR::NiDaqIO | This class is used to interface with NI DAQ IO boards |
| OSCAR::NIDIO | Class for digital IO using National Instruments DAQ boards |
| OSCAR::Node | A Node a tree modeling structure containing instances of the primitives and child nodes, as well as methods to update the locations of the Node and the modeling objects contained within this Node and its children. Basically, a Node has a list of Node's inside it. This list of nodes constitutes its children. A Node also has a list of Primitive's in it. This list of Primitives constitutes the obstacles associated with just itself |
| OSCAR::NodeObstacleData | Reads a node's obstacle model. A node can have primitive shapes in it and also children nodes |
| OSCAR::ObAvData | Contains the functionality to read/write data from/to a file for obstacle avoidance |
| OSCAR::ObAvInfo | Holds results of manipulator-obstacle distance calculations |
| OSCAR::ObAvInfoRepository | ObAvInfoRepository is a repository which holds ObAvInfo objects, which in turn contain the witness points between manipulators and their surroundings, unit vectors pointing from the manipulator witness points, the magnitude of the distance between witness points, and the G and H functions of the witness points |
| OSCAR::OfflineMotionPlanner | This class is used for generating and storing trajectories off-line (not in real-time) |
| OSCAR::OnlineMotionPlanner | |
| OSCAR::Orientation | Represents a 3 long vector whose elements hold the spatial orientation |
| OSCAR::OSCARError | Defines an error object that contains an integer value and an error description |
| OSCAR::OSCARXMLErrorReporter | |
| OSCAR::ParabolicBlend | This class can be used to develop a parabolic blend through a set of control points. This creates a smooth 3rd degree curve that passes through each of the control points with C1 continuity |
| OSCAR::PathBlend | This class implements the constant velocity path blending technique developed R. H. Taylor in "Planning and Execution of Straight-Line Manipulator Trajectories." This class will develop a trajectory that smoothly interpolates straight line motions through a set of via points |
| OSCAR::PCAccelerationLimitsAvoidance | PCAccelerationLimitsAvoidance is a class for criteria which avoids the acceleration limits for the joints on a manipulator. PCAccelerationLimitsAvoidance is derived from PCVectorLimits. It is a class that computes the manipulator's distance from acceleration limits |
| OSCAR::PCADistToEEWrench | PCADistToEEWrench is derived from PCADistToTorque and PCJacobianPseudoInverse |
| OSCAR::PCADistToEEWrenchD1 | PCADistToEEWrenchD1 is derived from PCADistToTorque and PCJacobianPseudoInverse. This class is not currently functional and can not be instantiated |
| OSCAR::PCADistToForce | PCADistToForce computes the joint Forces/forces based on distances to surrounding obstacles |
| OSCAR::PCADistToForceD1 | PCADistToForceD1 is derived from PCADistToForce |
| OSCAR::PCADistToTorque | PCADistToTorque computes the joint torques/forces based on distances to surrounding obstacles |
| OSCAR::PCADistToTorqueD1 | Computes the first derivative of the torques due to artificial forces. This class is not currently functional |
| OSCAR::PCAverageDistReciprocal | PCAverageDistReciprocal calculates the average of the reciprocal of the minimum distance from the robot arm to obstacles |
| OSCAR::PCAWorkCell | PCAWorkCell uses a WorkCell to compute and store the obstacle avoidance information (see DistanceResults) |
| OSCAR::PCCompliance | PCCompliance is an abstract class for criteria which are based on the compliance matrix. PCCompliance is derived from PCJacobian. It is an intermediate abstract class that contains the functionality to compute the compliance matrix necessary for certain criteria |
| OSCAR::PCComplianceEigenVectors | PCComplianceEigenVectors is an abstract class for criteria which are based on the eigenvalues or eigenvectors of the compliance matrix. PCComplianceEigenVectors is derived from PCCompliance. It is an intermediate abstract class that contains the functionality to compute the eigenvalues and eigenvectors for compliance certain criteria. This class is only available if you are using the Matrix class that uses Matlab libraries |
| OSCAR::PCDexterity | PCDexterity is a criteria which is based on the condition number of the Jacobian, minimum and maximum eigenvalues. The condition number specifies the Jacobian's sensitivity to error, therefore well-conditioned Jacobians are less likely to produce significant error for any specified motion. Dexterity minimizes any error at the EEF due to errors in the actuators. Another definition is the EEF's ability to react to any commanded position equally well. Since it is based on Jacobian eigenvalues, it also indicates proximity to a singulatity. PCDexterity is derived from PCJacobianEigenValues |
| OSCAR::PCDirectionalEEFStiffness | PCDirectionalEEFStiffness is a criteria that evaluates stiffness in a given direction. Knowing the direction of force will allow the manipulator to reorient itself in a stiffer orientation. PCDirectionalEEFStiffness is derived from PCComplianceEigenVectors |
| OSCAR::PCEEFInertia | PCEEFInertia is an intermediate class for criteria which are based on the Transferred EEF Inertia matrix. PCEEFInertia is derived from RRCInertia. It is an intermediate abstract class that contains the functionality to compute the transfer the Inertia matrix to the EEF necessary for certain criteria |
| OSCAR::PCEEFKineticEnergy | PCEEFKineticEnergy is a criteria which is based on the transferred inertia matrix and the velocity of the end-effector. This criteria attempts to minimize the kinetic energy in the direction of motion ofthe EEF. PCEEFKineticEnergy is derived from PCEEFInertia |
| OSCAR::PCEEWrench | PCEEWrench is derived from PCADistToEEWrench |
| OSCAR::PCEEWrenchD1 | PCEEWrenchD1 is derived from PCAWorkCell |
| OSCAR::PCFilter | PCFilter should be used to filter using multiple criteria. It can be used to choose the first solution which passes all critical limits or it can be placed in a fusion scheme to filter solutions before another PC or Fusion object chooses the optimal solution. It is derived from PerformanceCriteria so the same methods are available. By deriving from PerformanceCriteria it allows multiple PCFilters to be further fused to allow more complicated combinational RRTs |
| OSCAR::PCForceTransmissibility | PCForceTransmissibility is a criteria which is based on the jacobian and force direction of the end-effector. This criteria attempts to maximize the ease with which joint torques are transmitted to the EEF force. PCForceTransmissibility is derived from PCJacobian |
| OSCAR::PCFusion | PCFusion should be used to fuse multiple criteria into a single metric to allow optimal solution selection. PCFusion is setup to be as general as possible to allow many different redundancy resolution techniques. It is derived from PerformanceCriteria so the same methods are available. By deriving from PerformanceCriteria it allows multiple PCFusion or PCFilter objects to be further fused to allow more complicated combinational RRTs |
| OSCAR::PCGeneralizedDynamicEfficiency | PCGeneralizedDynamicEfficiency is a criteria based upon the ratio of the largest inertial eigenvalue and the largest jacobian eigenvalue. The purpose of this criterion is to minimize joint torques in terms of inertial loading. PCGeneralizedDynamicEfficiency is derived from PCInertiaEigenValues and PCJacobianEigenValues |
| OSCAR::PCGeneralizedInertialEfficiency | PCGeneralizedInertialEfficiency is a criteria based upon the largest inertial eigenvalue. PCGeneralizedInertialEfficiency is derived from PCInertiaEigenValues |
| OSCAR::PCGeneralizedStiffness | PCGeneralizedStiffness is a criteria that evaluates the overall stiffness of a give manipulator configuration. It is done by taking the frobenius norm of the stiffness matrix. PCGeneralizedStiffness is derived from PCCompliance |
| OSCAR::PCGeneralizedTorqueMinimization | PCGeneralizedTorqueMinimization is a criteria based upon the Inertia and JacobianPseudoInverse matrices. The infinity norms of the Inertia and JacobianPseudoInverse matrices are multiplied together to get an estimate on the necessary torque to move the manipulator from one configuration to another. PCGeneralizedTorqueMinimization is derived from PCInertia and PCJacobianPseudoInverse |
| OSCAR::PCGeneralizedVelocityMinimization | PCGeneralizedVelocityMinimization is a criteria based upon the JacobianPseudoInverse, that aims to reduce joint velocities. It only takes the largest row sum of the pseudoinverse which is the largest transformation of a joint velocity. This criteria does not actually calculate velocities so there is no check to make sure operation velocity limits are not violated. PCGeneralizedVelocityMinimization is derived from PCJacobianPseudoInverse |
| OSCAR::PCInertia | PCInertia is an abstract class for criteria which are based on the inertia matrix. PCInertia is derived from PerformanceCriteria. It is an intermediate abstract class that contains the functionality to compute the inertia matrix necessary for certain criteria |
| OSCAR::PCInertiaEigenValues | PCInertiaEigenValues is an abstract class for criteria which are based on the inertia eigenvalues. PCInertia is derived from PCInertia. It is an intermediate abstract class that contains the functionality to compute the inertia eigenvalues necessary for certain criteria |
| OSCAR::PCInertialFrobeniusNorm | PCInertialFrobeniusNorm takes the frobenius norm of the iStar inertia matrix. Minimizing the effective inertia matrix leads to a decrease in the kinetic energy of the system. PCGeneralizedTorqueMinimization is derived from PCInertia |
| OSCAR::PCInverseMeasureOfTransmissibility | PCInverseMeasureOfTransmissibility is a criteria which is based on determinant of the jacobian. This criteria attempts to maximize the ease with which joint velocities are transmitted to the EEF velocities. This criteria is computationally fast and can have multiple physical meanings. Because of the dual nature of the Jacobian, transmission transmissibility or velocity transmissibility could be optimized. The determinant is also an indicator of proximity to a singularity. PCInverseMeasureOfTransmissibility is derived from PCJacobian |
| OSCAR::PCJacobian | PCJacobian is an abstract class for criteria which are based on the jacobian. PCJacobian is derived from PerformanceCriteria. It is an intermediate abstract class that contains the functionality to compute jacobians. Derived classes update the necessary repositories by calling the protected method update() |
| OSCAR::PCJacobianEigenValues | PCJacobianEigenValues is an intermediate abstract class which adds the functionality to calculate jacobian eigenvalues. PCJacobianEigenValues is derived from PCJacobian |
| OSCAR::PCJacobianFrobeniusNorm | PCJacobianFrobeniusNorm is a criteria which is based on the frobenius norm of the Jacobian matrix. This criterion can be viewed as a generalized efficiency criterion for both velocity and torque transmission. Mitch Pryor suggests this is the most effective criteria in terms of avoiding singularities. PCJacobianFrobeniusNorm is derived from PCJacobian |
| OSCAR::PCJacobianPseudoInverse | PCPseudoInverse is an intermediate abstract class which adds the functionality to calculate jacobian pseudoinverses. PCJacobianPseudoInverse is derived from PCJacobian |
| OSCAR::PCJointRangeAvailability | PCJointRangeAvailability is a criteria which calculates the distance from the joint limits of a manipulator. PCJointRangeAvailability is derived from PCVectorLimits. The methods to get and set individual joint parameters are in PCVectorLimits |
| OSCAR::PCJointTorque | Minimizes joint torques due to artificial forces |
| OSCAR::PCKeyboard | |
| OSCAR::PCKeyboardMC | |
| OSCAR::PCKineticEnergy | PCKineticEnergy calculates the kinetic energy of the manipulator using the iStar inertia matrix and the current positions. Time is not explicitly included in the formulation, so the criteria value is not the true kinetic energy value, but allows solutions to be ranked. It could easily be modified to take into account time. PCKineticEnergy is derived from PCInertia |
| OSCAR::PCLinkForce | PCLinkForce minimizes the average of the artificial forces acting on the links |
| OSCAR::PCLoadTorqueMinimization | PCLoadTorqueMinimization is a criteria which is based on the Jacobian matrix. This criterion attempts to reduce the actuator torques due to the load at the EEF. PCLoadTorqueMinimization is derived from PCJacobian |
| OSCAR::PCMagneticEEF | PCMagneticEEF is a criteria which calculates the distance to a point. PCMagneticEEF works like a magnet attracting the EEF to the specified point or repelling the EEF from an obstacle |
| OSCAR::PCMeasureOfTransmissibility | PCMeasureOfTransmissibility is a criteria which is based on determinant of the jacobian. This criteria attempts to maximize the ease with which joint velocities are transmitted to the EEF velocities. This criteria is computationally fast and can have multiple physical meanings. Because of the dual nature of the Jacobian, transmission transmissibility or velocity transmissibility could be optimized. The determinant is also an indicator of proximity to a singularity. PCMeasureOfTransmissibility is derived from PCJacobian |
| OSCAR::PCPotentialEnergy | PCPotentialEnergy is a criteria that calculates the potential energy in the manipulator due to deflections. Deflections due to forces at the EEF are the only deflections considered. Minimizing this criteria should reduce deflections due to loads at the EEF. PCPotentialEnergy is derived from PCCompliance |
| OSCAR::PCRoboworksInterface | This class multiply inherits from RoboworksInterface and PowerCubeBase classes. This is an interface for PowerCube simulation (when simulation is done in Roboworks.). It has following functionality. -Object construction and initialization -Homing -Resetting -Halting -Getting and setting positions of modules and gripper(if any) Note: for giving position commands call SetServoValue() (See RobotServoInterface.h). The implementation is in SetPosition() |
| OSCAR::PCSHandPose | |
| OSCAR::PCSingularityAvoidance | PCSingularityAvoidance is a criteria which is based on the minimum eigenvalue of the Jacobian. Exclusively tracking the minimum singular value may exhibit a better indication of a manipulator's nearness to a mathematical singularity. Transmissibilty can be improved by maximizing the distance from singularities, therefore minimizing the joint torques required to maintain a desired EEF force. PCSingularityAvoidance is derived from PCJacobianEigenValues |
| OSCAR::PCSmallestMinDist | PCSmallestMinDist calculates the minimum distance from the robot arm to any obstacle in the environment |
| OSCAR::PCTorqueLimitsAvoidance | PCTorqueLimitsAvoidance is a class for criteria which avoids the torque limits for the joints on a manipulator. PCTorqueLimitsAvoidance is derived from PCVectorLimits. It is a class that computes the manipulator's distance from torque limits |
| OSCAR::PCVectorLimits | PCVectorLimits is an abstract class for criteria which avoids the limits of a vector |
| OSCAR::PCVelocityLimitsAvoidance | PCVelocityLimitsAvoidance is a class for criteria which avoids the velocity limits for the joints on a manipulator. PCVelocityLimitsAvoidance is derived from PCVectorLimits. It is a class that computes the manipulator's distance from velocity limits |
| OSCAR::PCVelocityTransmissibility | PCVelocityTransmissibility is a criteria which is based on the jacobian pseudo-inverse and the velocity of the end-effector. This criteria attempts to maximize the efficiency with which joint velocities are transmitted to the EEF velocity. PCVelocityTransmissibility is derived from PCJacobian |
| OSCAR::PerformanceCriteria | PerformanceCriteria should be used to select a solution from a set of options for a manipulator |
| OSCAR::Perturbation | Perturbation can be called to generate patterned perturbations for Vector and RRJointVector |
| OSCAR::Plane | Define a planar primitive for use in robot obstacle avoidance |
| OSCAR::PlaneData | Reads and writes a Plane to and from an XML data file |
| OSCAR::Polytope | Class for STL based polytope obstacle models Currently an empty class which can be instantiated but can not be used for anything useful |
| OSCAR::PolytopeData | Reads and writes a Polytope to and from an XML data file |
| OSCAR::PowerCubeBase | This is an abstract class for Amtec's PowerCube Interface (both hardware and simulation modules inherit from this class.) having following functionality -Initialization -Homing -Resetting -functionality related to gripper -retrieving and setting different attributes (like current limits) |
| OSCAR::PowerCubeInterface | This class, derived from PowerCubeBase class, implements the software interface to control mechanism/robot hardware assembled from PowerCube modules manufactured by Amtec Robotics (http://www.amtec-robotics.com/index.html) that is part of the Schunk group(http://www.schunk.com/) |
| OSCAR::Primitive | Base for geometric primitives |
| OSCAR::Quaternion | Used to reperesent a quaternion rotation |
| OSCAR::RedundantKinematicsHandler | |
| OSCAR::Relay | |
| OSCAR::Repository | Repository is a base repository class from which all repository types will derive. These repositories store data computed by the criteria in order to prevent repeat calculations. All computational ability is in the performance criteria - repositories store data only. Repository contains the functionality to keep track of whether the repository has been updated. The methods to get and set the data members inside the repository were placed in the derived template class TypeRepository so the same methods could be used for several repository types. The reason this base class is necessary is because RepositoryList cannot point to a template class |
| OSCAR::RepositoryList | RepositoryList is a list which holds Repository objects. This list will be passed to criteria to give them a place to read and write data for criteria computations |
| OSCAR::RK4 | Fixed step size Runge Kutta Integrator Used to integrate ODEs in a manner similar to ode45 in matlab |
| OSCAR::RobixInterface | |
| OSCAR::RobotData | Acts as the base class for all classes that are used to read and parse data files |
| OSCAR::RobotServoInterface | |
| OSCAR::RoboworksInterface | |
| OSCAR::Rot3by3 | This class is used to represent a 3x3 rotation matrix |
| OSCAR::RRMotionPlan | This class is the base class for the Motion Planning library. It contains the functionality for setting the motion parameters and performs some of the low level calculations |
| OSCAR::RROnlineMotionPlanner | This class defines the base interface for performing online motion planning. This class is not currently implemented |
| OSCAR::RRStatics | An abstract class for calculating static forces |
| OSCAR::RSIMC | |
| OSCAR::RungeKutta | |
| OSCAR::Saw | Saw provides a C++ interface to the custom saw tool for the Robotics Research Arm. This class uses Digital IO hardware for IO with the saw. The tool frame for the saw is also set during the construction of this object. A call to GetToolFrame will return the tool frame. The units in which the tool frame is returned are inches. The tool point for the saw is defined as point on the leading edge of the skid plate of the saw which is colinear with the saw blade |
| OSCAR::ScalarRepository | ScalarRepository is a repository class which holds scalar data calculated by the criteria to allow data sharing |
| OSCAR::ScaleInverseF | \ ScaleInverseF One type of APF where Scalar function goes as the inverse of the argument The function is F(x) = k*[(mx-mn)/(x-mn)]^z + thresh, so that as (x->inf), (F(x)->thresh), (x=mx), (F(x) = k + thresh), and as (x->mn), (F(x)->inf). Note: this function object does not check for x < mn. A special case is when k=1, z=1, mx=1, mn=0, and thresh=0, then F(x) = 1/x |
| OSCAR::ScaleInverseVanishF | \ ScaleInverseVanishF One type of APF where Scalar function starts from infinity at a certain value and decreases as the argument grows until vanishing completely at a certain value. The function is F(x) = k*[(mx-x)/(x-mn)]^z + thresh, so that if (x>=mx), (F(x) = thresh), and as (x->mn), (F(x)->inf). If thres = 0, then it means that APF will have no effect when x >= mx. Note: this function object does not check for x < mn |
| OSCAR::Sensor< Type > | Base class for all Sensors. Each Sensor should be derived from this class and should support all the methods |
| OSCAR::ServoInterface | |
| OSCAR::Shared | |
| OSCAR::SimpleObAv | |
| OSCAR::Simulator | |
| OSCAR::SkeletalPrimitive | Base for skeletal geometric primitives |
| OSCAR::SpaceballMC | |
| OSCAR::SpatialXform | This class represents a 6 by 6 spatial transformation matrix |
| OSCAR::SpecificationsData | Reads specifications for a particular system (robot, tool, etc.) from a data file or programmatically create them |
| OSCAR::Sphere | Define a spherical primitive for use in robot obstacle avoidance |
| OSCAR::SphereData | Reads and writes a Sphere to and from an XML data file |
| OSCAR::Spline | An abstract class defining the base-level interface for spline curve generation. This includes the ability to set, insert, and delete the control points |
| OSCAR::SprayGun | SprayGun provides a C++ interface to the custom spray gun tool for the Robotics Research Arm. This class uses digitial IO data-acquisition hardware for IO with the spray gun. The tool frame for the spray gun is also set during the construction of this object. A call to GetToolFrame will return the tool frame. The units in which the tool frame is returned are inches. The tool point for the spray gun is defined at the output nozzle of the spray gun |
| OSCAR::TCP | This class contains base interface for TCP/IP communication |
| OSCAR::TCPClient | This class contains functionality for setting up a TCP client |
| OSCAR::TCPServer | This class contains functionality for setting up a TCP server |
| OSCAR::Tensor | Represents a tensor (basically an array of matrices) |
| OSCAR::TensorData | Reads data from a file that is represented in tensor format (array of matrices) |
| OSCAR::TensorRepository | TensorRepository is a repository class which holds tensor data calculated by the criteria to allow data sharing |
| OSCAR::ThreeStateTool | Base class for all tools that support Forward, Reverse, and Off functionality |
| OSCAR::Timer | Measures code execution time |
| OSCAR::Tool | Base class for all end effector tools. Each tool should be derived from this class and should support all the methods |
| OSCAR::ToolChanger | ToolChanger provides a C++ interface to the tool changers mounted on the Robotics Research Arm. This class uses ditial IO data-acquisition drivers for IO with the tool changers. The tool frame for the ToolChangers is also set during the construction of this object. A call to #GetToolFrame will return the tool frame. The units in which the tool frame is returned are inches. The base plate of the tool changer is defined in the XY plane, with the Z axis from the tool changer base plate towards the tool attachment plate |
| OSCAR::ToolData | Reads a tool model from a data file or programmatically create them |
| OSCAR::TOSMC | |
| OSCAR::TwoStateSwitch | Base class for all switches that support On and Off functionality |
| OSCAR::TwoStateTool | Base class for all tools that support Forward (On) and Off functionality |
| OSCAR::TypeRepository< type > | TypeRepository is a repository template class which holds the functionality for retrieving and setting data in the repositories. Derived classes will set the template type and allocate the type size depending on needs. The type has to be a pointer so get and set methods will be taking or returning pointers |
| Vector | |
| Vector | |
| OSCAR::Vector3 | Represents a spatial position vector |
| OSCAR::VectorArray | Stores arrays of vectors |
| OSCAR::VectorNumeric< Type > | Represents a vector |
| OSCAR::VectorRepository | VectorRepository is a repository class which holds vector data \ calculated by the criteria to allow data sharing |
| OSCAR::WorkCell | Contains a geometric description of the work cell (from an ObAvData object) and computes witness points (minimum distances between robots and other models) and derivatives of witness points (stored in an ObAvInfo object) |
| OSCAR::WorkcellData | Reads a Workcell model from a data file or programmatically create them |
| OSCAR::Xform | Defines a 4 by 4 homogeneous transformation matrix |
| OSCAR::XMLData | Reads OSCAR specific data specifiedf in XML This is the base class for all data to be loaded in XML format. This class sets up the XML parser (Xerces), sets its properties (validation, schema, etc.) sets namespace, etc. Dervied classes have to define the parseParameters method for the specific data they are loading |
| OSCAR::XMLDHData | Reads DH parameters from a data file or programmatically create them |
