Program Listing for File OrientedChainedFrameToFrame.h#
↰ Return to documentation for file (include/Karana/Frame/OrientedChainedFrameToFrame.h)
/*
* Copyright (c) 2024-2026 Karana Dynamics Pty Ltd. All rights reserved.
*
* NOTICE TO USER:
*
* This source code and/or documentation (the "Licensed Materials") is
* the confidential and proprietary information of Karana Dynamics Inc.
* Use of these Licensed Materials is governed by the terms and conditions
* of a separate software license agreement between Karana Dynamics and the
* Licensee ("License Agreement"). Unless expressly permitted under that
* agreement, any reproduction, modification, distribution, or disclosure
* of the Licensed Materials, in whole or in part, to any third party
* without the prior written consent of Karana Dynamics is strictly prohibited.
*
* THE LICENSED MATERIALS ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND.
* KARANA DYNAMICS DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING
* BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-INFRINGEMENT, AND
* FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL KARANA DYNAMICS BE LIABLE FOR ANY DAMAGES WHATSOEVER,
* INCLUDING BUT NOT LIMITED TO LOSS OF PROFITS, DATA, OR USE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, WHETHER IN CONTRACT, TORT,
* OR OTHERWISE ARISING OUT OF OR IN CONNECTION WITH THE LICENSED MATERIALS.
*
* U.S. Government End Users: The Licensed Materials are a "commercial item"
* as defined at 48 C.F.R. 2.101, and are provided to the U.S. Government
* only as a commercial end item under the terms of this license.
*
* Any use of the Licensed Materials in individual or commercial software must
* include, in the user documentation and internal source code comments,
* this Notice, Disclaimer, and U.S. Government Use Provision.
*/
/**
* @file
* @brief Contains the declarations for the OrientedChainedFrameToFrame class.
*/
#pragma once
#include "Karana/Frame/FrameToFrame.h"
namespace Karana::Frame {
namespace kc = Karana::Core;
namespace km = Karana::Math;
class ChainedFrameToFrame;
/**
* @class OrientedChainedFrameToFrame
* @brief FrameToFrame class connecting an oframe with a downstream pframe
*
* The pframe can be arbitrary - as long as it is downstream of the oframe
* frames tree.
*
* See \sref{frames_layer_sec} for more discussion on
* the frames layer.
*/
class OrientedChainedFrameToFrame : public FrameToFrame {
// For access to our DataCache members
friend ChainedFrameToFrame;
// For access to _empty
friend class Frame;
friend class FrameContainer;
public:
/**
* @brief Constructor for OrientedChainedFrameToFrame.
* @param oframe oframe of the OrientedChainedFrameToFrame.
* @param pframe pframe of the OrientedChainedFrameToFrame.
* @param name the name for the chain
*/
OrientedChainedFrameToFrame(const kc::ks_ptr<Frame> &oframe,
const kc::ks_ptr<Frame> &pframe,
std::string_view name = "");
/**
* @brief Looks up or creates an OrientedChainedFrameToFrame two frames.
* @param oframe - The oframe of the oriented chain.
* @param pframe - The pframe of the oriented chain.
* @return The OrientedChainedFrameToFrame that connects the oframe and pframe.
*/
static const kc::ks_ptr<OrientedChainedFrameToFrame> &
lookupOrCreate(const kc::ks_ptr<Frame> &oframe, const kc::ks_ptr<Frame> &pframe);
/**
* @brief Return the number of edges in this oriented chain
* @return the number of edges in the chain
*/
size_t numEdges() const;
/**
* @brief Return the sequence of edge names in this chain as a string
* @return string with the sequence of edge names
*/
std::string getPath() const;
/** options struct for dumpString */
struct DumpOptions : FrameToFrame::DumpOptions {
bool path = true; ///< Display the edges that make up the path for this chain
/**
* @brief Assignment operator.
*
* @param p The DumpOptions to copy from.
* @return A reference to the newly assigned DumpOptions.
*/
// Adding suppression, as CodeChecker complains this method has the same name as a
// method in the base version. This is just a CodeChecker false positive.
// codechecker_suppress [cppcheck-duplInheritedMember]
DumpOptions &operator=(const DumpOptions &p) {
if (this != &p) {
FrameToFrame::DumpOptions::operator=(p); // Call base class assignment operator
// Assign Derived-specific members here
path = p.path;
}
return *this;
}
};
/**
* @brief Return a formatted string containing information about this object.
*
* @param prefix String prefix to use for formatting.
* @param options Dump options (if null, defaults will be used).
* @return A string representation of the object.
*/
std::string dumpString(std::string_view prefix = "",
const Base::DumpOptions *options = nullptr) const override;
protected:
/**
* @brief Empty out the OrientedChainedFrameToFrame completely. This happens when the oframe
* or pframe associated with the OrientedFrameToFrame is deleted.
*/
void _empty() override;
/**
* @brief Compute the transformation between the oframe and pframe.
*
* @param T The buffer to place the computed homogeneous transformation in.
*/
void _computeTransform(km::HomTran &T) override;
/**
* @brief Compute the spatial velocity between the oframe and pframe.
*
* This method uses Exercise 1.8 (Evaluating spatial
* velocities) to combine the oframe/pframe parent spatial
* velocity with the pframe edge spatial velocity.
*
* @param V The buffer to put the computed spatial velocity in.
*/
void _computeVelocity(km::SpatialVector &V) override;
/**
* @brief Compute the spatial acceleration between the oframe and pframe.
*
* This method uses Exercise 1.15 (Evaluating spatial
* accelerations) to combine the oframe/pframe parent spatial
* acceleration with the pframe edge spatial acceleration and in
* the Coriolis contribution.
*
* @param a The buffer to put the computed spatial acceleration in.
*/
void _computeAccel(km::SpatialVector &a) override;
/**
* @brief Used to lock the OrientedChainedFrameToFrame.
*/
void _makeHealthy() override;
/**
* @brief Used to unlock the OrientedChainedFrameToFrame.
*/
void _makeNotHealthy() override;
/**
* @brief Used to setup the OrientedChainedFrameToFrame.
*/
void _setup();
/**
* @brief Discard the provided OrientedChainedFrameToFrame.
* @param base - Base pointer to the OrientedChainedFrameToFrame to discard.
*/
void _discard(kc::ks_ptr<Base> &base) override;
/// The pframe's parent frame
kc::ks_ptr<Frame> _pframe_parent = nullptr;
/// The pframe's edge
kc::ks_ptr<EdgeFrameToFrame> _pframe_edge_f2f = nullptr;
/// The OrientedChainedFrameToFrame that goes from the oframe to the pframe's parent
kc::ks_ptr<OrientedChainedFrameToFrame> _to_parent_f2f = nullptr;
};
} // namespace Karana::Frame