/usr/include/kido/dynamics/SimpleFrame.hpp is in libkido-dev 0.1.0+dfsg-2build9.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 | /*
* Copyright (c) 2015, Georgia Tech Research Corporation
* All rights reserved.
*
* Author(s): Michael X. Grey <mxgrey@gatech.edu>
*
* Georgia Tech Graphics Lab and Humanoid Robotics Lab
*
* Directed by Prof. C. Karen Liu and Prof. Mike Stilman
* <karenliu@cc.gatech.edu> <mstilman@cc.gatech.edu>
*
* This file is provided under the following "BSD-style" License:
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef KIDO_DYNAMICS_SIMPLEFRAME_HPP_
#define KIDO_DYNAMICS_SIMPLEFRAME_HPP_
#include "kido/dynamics/Frame.hpp"
namespace kido {
namespace dynamics {
/// The SimpleFrame class offers a user-friendly way of creating arbitrary
/// Frames within the kinematic tree structure of KIDO. The user is free to
/// specify the relative transform, relative velocity, and relative acceleration
/// of this Frame.
///
/// While many classes (such as BodyNode and EndEffector) inherit the Frame
/// class, they all have restrictions (constraints) on how their properties
/// (such as position, velocity, and acceleration) can be modified. Conversely,
/// the SimpleFrame class is nothing but a simple abstract Frame whose
/// properties can be arbitrarily set and modified by the user.
class SimpleFrame : public Detachable, public Frame
{
public:
/// Constructor
explicit SimpleFrame(Frame* _refFrame,
const std::string& _name = "simple_frame",
const Eigen::Isometry3d& _relativeTransform = Eigen::Isometry3d::Identity());
/// Copy constructor. Note that the parent frame of _otherFrame will not be
/// copied as the reference frame for the newly created SimpleFrame.
SimpleFrame(const SimpleFrame& _otherFrame, Frame* _refFrame = Frame::World());
/// Destructor
virtual ~SimpleFrame();
/// Create a new SimpleFrame with the same world transform, velocity, and
/// acceleration as this one. _refFrame will be used as the reference Frame
/// of the new SimpleFrame.
virtual std::shared_ptr<SimpleFrame> clone(Frame* _refFrame = Frame::World()) const;
/// Make the world transform, world velocity, and world acceleration of this
/// SimpleFrame match another Frame. The _refFrame argument will be the new
/// parent Frame of this SimpleFrame. Also copies the Entity Properties if
/// _copyProperties is left as true.
void copy(const Frame& _otherFrame, Frame* _refFrame = Frame::World(),
bool _copyProperties=true);
/// Same as copy(const Frame&)
void copy(const Frame* _otherFrame, Frame* _refFrame = Frame::World(),
bool _copyProperties=true);
/// Same as copy(const Frame&) except the parent frame of this SimpleFrame is
/// left the same, and _copyProperties is set to false.
SimpleFrame& operator=(const SimpleFrame& _otherFrame);
//--------------------------------------------------------------------------
// Transform
//--------------------------------------------------------------------------
/// Set the relative transform of this SimpleFrame
void setRelativeTransform(const Eigen::Isometry3d& _newRelTransform);
/// Set the transform of this SimpleFrame so that its transform with respect
/// to Frame _withRespectTo is equal to _newTransform. Note that the parent
/// Frame of this SimpleFrame will not be changed.
void setTransform(const Eigen::Isometry3d& _newTransform,
const Frame* _withRespectTo = Frame::World());
// Documentation inherited
const Eigen::Isometry3d& getRelativeTransform() const;
//--------------------------------------------------------------------------
// Velocity
//--------------------------------------------------------------------------
/// Set the spatial velocity of this SimpleFrame relative to its parent Frame.
/// Must be in the coordinates of THIS Frame.
///
/// This is the most computationally efficient way of setting relative
/// velocity.
///
/// Use setClassicDerivatives to set the velocity according to classic
/// relative linear and angular velocity values.
void setRelativeSpatialVelocity(const Eigen::Vector6d& _newSpatialVelocity);
/// Set the spatial velocity of this SimpleFrame relative to its parent Frame.
/// Specify the coordinate Frame of _newSpatialVelocity.
///
/// Use setClassicDerivatives to set the velocity according to classic
/// relative linear and angular velocity values.
void setRelativeSpatialVelocity(const Eigen::Vector6d& _newSpatialVelocity,
const Frame* _inCoordinatesOf);
// Documentation inherited
virtual const Eigen::Vector6d& getRelativeSpatialVelocity() const;
//--------------------------------------------------------------------------
// Acceleration
//--------------------------------------------------------------------------
/// Set the spatial acceleration of this SimpleFrame relative to its parent
/// Frame. Must be in the coordinates of THIS Frame.
///
/// This is the most computationally efficient way of setting relative
/// acceleration.
void setRelativeSpatialAcceleration(
const Eigen::Vector6d& _newSpatialAcceleration);
/// Set the spatial acceleration of this SimpleFrame relative to its parent
/// Frame. Specify the coordinate Frame of _newSpatialAcceleration.
void setRelativeSpatialAcceleration(
const Eigen::Vector6d& _newSpatialAcceleration,
const Frame* _inCoordinatesOf);
// Documentation inherited
virtual const Eigen::Vector6d& getRelativeSpatialAcceleration() const;
// Documentation inherited
virtual const Eigen::Vector6d& getPrimaryRelativeAcceleration() const;
// Documentation inherited
virtual const Eigen::Vector6d& getPartialAcceleration() const;
//--------------------------------------------------------------------------
// Classic Method
//--------------------------------------------------------------------------
/// Set the relative velocity and acceleration of this Frame according to
/// classical (non-spatial) relative velocity and relative acceleration
/// vectors. These values must be given with respect to this Frame's parent
/// (note: this is unlike setRelativeSpatialVelocity and
/// setRelativeSpatialAcceleration which expect values in the Frame's own
/// coordinates).
///
/// This method is slightly less computationally efficient than using
/// setRelativeSpatialVelocity and setRelativeSpatialAcceleration, but offers
/// the most intuitive way of setting relative velocities and relative
/// accelerations.
///
/// These values are equivalent to the terms in the Newton-Euler
void setClassicDerivatives(
const Eigen::Vector3d& _linearVelocity = Eigen::Vector3d::Zero(),
const Eigen::Vector3d& _angularVelocity = Eigen::Vector3d::Zero(),
const Eigen::Vector3d& _linearAcceleration = Eigen::Vector3d::Zero(),
const Eigen::Vector3d& _angularAcceleration = Eigen::Vector3d::Zero());
protected:
/// Relative transform of the SimpleFrame
Eigen::Isometry3d mRelativeTf;
/// Relative spatial velocity of the SimpleFrame
Eigen::Vector6d mRelativeVelocity;
/// Relative spatial acceleration of the SimpleFrame
Eigen::Vector6d mRelativeAcceleration;
/// Partial Acceleration of this Frame
mutable Eigen::Vector6d mPartialAcceleration;
};
} // namespace kido
} // namespace dynamics
#endif // KIDO_DYNAMICS_SIMPLEFRAME_HPP_
|