prmBaseFrame.h

Go to the documentation of this file.

// file automatically generated, do not modify
// cisst version: 1.5.0
// source file: /Users/anton/devel/cisst-saw-doxygen/tmp/cisst-saw/cisst/cisstParameterTypes/code/../prmBaseFrame.cdg
 
#pragma once
#ifndef _cisstParameterTypes_prmBaseFrame_h
#define _cisstParameterTypes_prmBaseFrame_h
 
#include <cisstCommon/cmnDataFunctions.h>
#include <cisstCommon/cmnDataFunctionsEnumMacros.h>
#if CISST_HAS_JSON
#include <cisstCommon/cmnDataFunctionsJSON.h>
#endif // CISST_HAS_JSON
 
/* source line: 1 */
 
 
 
 
// for mts-proxy 
#include <cisstCommon/cmnClassServices.h>
#include <cisstCommon/cmnClassRegisterMacros.h>
#include <cisstMultiTask/mtsGenericObjectProxy.h>
 
/* source line: 1 */
/* source line: 4 */
 
#include <cisstVector/vctTransformationTypes.h>
#include <cisstVector/vctFixedSizeVectorRef.h>
#include <cisstParameterTypes/prmStateCartesian.h>
 
// Always include last
#include <cisstParameterTypes/prmExport.h>
 
// Following needed on Windows
#ifdef interface
#undef interface
#endif
 
/* source line: 18 */
class CISST_EXPORT prmBaseFrame: public mtsGenericObject
{
 /* default constructors and destructors. */
 public:
    prmBaseFrame(void);
    prmBaseFrame(const prmBaseFrame & other);
    prmBaseFrame & operator = (const prmBaseFrame & other);
    ~prmBaseFrame();
 
/* source line: 28 */
 protected:
    std::string mreference_frame; // Name of reference frame for a fixed base frame
 public:
    /* accessors is set to: all */
#ifndef SWIG
     void Getreference_frame(std::string & placeHolder) const;
#endif
    inline  std::string Getreference_frame(void) const {
        return mreference_frame;
    }
     void Setreference_frame(const std::string & newValue);
    /* accessors is set to: all */
     const std::string & reference_frame(void) const;
     std::string & reference_frame(void);
/* source line: 35 */
 protected:
    vctFrm4x4 mtransform; // Homogeneous transform from local frame to base frame
 public:
    /* accessors is set to: all */
#ifndef SWIG
     void Gettransform(vctFrm4x4 & placeHolder) const;
#endif
    inline  vctFrm4x4 Gettransform(void) const {
        return mtransform;
    }
     void Settransform(const vctFrm4x4 & newValue);
    /* accessors is set to: all */
     const vctFrm4x4 & transform(void) const;
     vctFrm4x4 & transform(void);
/* source line: 42 */
 protected:
    std::string mcomponent; // Component name for a dynamic base frame provider
 public:
    /* accessors is set to: all */
#ifndef SWIG
     void Getcomponent(std::string & placeHolder) const;
#endif
    inline  std::string Getcomponent(void) const {
        return mcomponent;
    }
     void Setcomponent(const std::string & newValue);
    /* accessors is set to: all */
     const std::string & component(void) const;
     std::string & component(void);
/* source line: 49 */
 protected:
    std::string minterface; // Interface name for a dynamic base frame provider
 public:
    /* accessors is set to: all */
#ifndef SWIG
     void Getinterface(std::string & placeHolder) const;
#endif
    inline  std::string Getinterface(void) const {
        return minterface;
    }
     void Setinterface(const std::string & newValue);
    /* accessors is set to: all */
     const std::string & interface(void) const;
     std::string & interface(void);
/* source line: 56 */
 
    private:
        CMN_DECLARE_SERVICES(CMN_DYNAMIC_CREATION, CMN_LOG_ALLOW_DEFAULT);
 
    public:
        inline bool ValidDefinition(void) const {
            return (((!reference_frame().empty())
                     && component().empty()
                     && interface().empty())
                    || (reference_frame().empty()
                        && (transform() == vctFrm4x4::Identity())
                        && !component().empty()
                        && !interface().empty()));
        }
 
        inline bool Fixed(void) const {
            return !reference_frame().empty();
        }
 
        inline bool Dynamic(void) const {
            return !component().empty();
        }
 
        inline void ApplyTo(const prmStateCartesian & local,
                            prmStateCartesian & withBase) const {
            withBase = local;
            if (!ValidDefinition()) {
                cmnThrow("prmBaseFrame::ApplyTo: invalid base frame");
            }
            if (!Fixed()) {
                cmnThrow("prmBaseFrame::ApplyTo: only fixed base frames can be applied directly");
            }
 
            vctFrm3 fixedTransform;
            fixedTransform.From(transform());
            const vctRot3 & rotation = fixedTransform.Rotation();
            withBase.ReferenceFrame() = reference_frame();
 
            if (local.PositionIsValid()) {
                withBase.Position() = fixedTransform * local.Position();
                withBase.PositionIsValid() = true;
            }
 
            if (local.VelocityIsValid()) {
                const vctFixedSizeConstVectorRef<double, 3, 1> localLinear(local.Velocity().XYZ());
                const vctFixedSizeConstVectorRef<double, 3, 1> localAngular(local.Velocity().Pointer(3));
                vctFixedSizeVectorRef<double, 3, 1> withBaseLinear(withBase.Velocity().XYZ());
                vctFixedSizeVectorRef<double, 3, 1> withBaseAngular(withBase.Velocity().Pointer(3));
                rotation.ApplyTo(localLinear, withBaseLinear);
                rotation.ApplyTo(localAngular, withBaseAngular);
                withBase.VelocityIsValid() = true;
            }
 
            if (local.ForceIsValid()) {
                const vctFixedSizeConstVectorRef<double, 3, 1> localForce(local.Force().XYZ());
                const vctFixedSizeConstVectorRef<double, 3, 1> localTorque(local.Force().Pointer(3));
                vctFixedSizeVectorRef<double, 3, 1> withBaseForce(withBase.Force().XYZ());
                vctFixedSizeVectorRef<double, 3, 1> withBaseTorque(withBase.Force().Pointer(3));
                rotation.ApplyTo(localForce, withBaseForce);
                rotation.ApplyTo(localTorque, withBaseTorque);
                withBase.ForceIsValid() = true;
            }
        }
        /* default methods */
 public:
    void SerializeRaw(std::ostream & outputStream) const override;
    void DeSerializeRaw(std::istream & inputStream) override;
    void ToStream(std::ostream & outputStream) const override;
    void ToStreamRaw(std::ostream & outputStream, const char delimiter = ' ',
                     bool headerOnly = false, const std::string & headerPrefix = "") const override;
    /* default data methods */
 public:
    void Copy(const prmBaseFrame & source);
    void SerializeBinary(std::ostream & outputStream) const CISST_THROW(std::runtime_error);
    void DeSerializeBinary(std::istream & inputStream, const cmnDataFormat & localFormat, const cmnDataFormat & remoteFormat) CISST_THROW(std::runtime_error);
    void SerializeText(std::ostream & outputStream, const char delimiter = ',') const CISST_THROW(std::runtime_error);
    std::string SerializeDescription(const char delimiter = ',', const std::string & userDescription = "") const;
    void DeSerializeText(std::istream & inputStream, const char delimiter = ',') CISST_THROW(std::runtime_error);
    std::string HumanReadable(void) const;
    bool ScalarNumberIsFixed(void) const override;
    size_t ScalarNumber(void) const override;
    double Scalar(const size_t index) const CISST_THROW(std::out_of_range) override;
    std::string ScalarDescription(const size_t index, const std::string & userDescription = "") const CISST_THROW(std::out_of_range) override;
#if CISST_HAS_JSON
    void SerializeTextJSON(Json::Value & jsonValue) const override;
    void DeSerializeTextJSON(const Json::Value & jsonValue) CISST_THROW(std::runtime_error) override;
#endif // CISST_HAS_JSON
 
}; // prmBaseFrame
 
// mts-proxy set to true
typedef mtsGenericObjectProxy<prmBaseFrame> prmBaseFrameProxy;
CMN_DECLARE_SERVICES_INSTANTIATION(prmBaseFrameProxy);
 
/* default functions */
void CISST_EXPORT cmnSerializeRaw(std::ostream & outputStream, const prmBaseFrame & object);
void CISST_EXPORT cmnDeSerializeRaw(std::istream & inputStream, prmBaseFrame & placeHolder);
/* data functions */
template <> class cmnData<prmBaseFrame > {
public: 
    enum {IS_SPECIALIZED = 1};
    typedef prmBaseFrame DataType;
    static void Copy(DataType & data, const DataType & source) {
        data.Copy(source);
    }
    static std::string SerializeDescription(const DataType & data, const char delimiter, const std::string & userDescription) {
        return data.SerializeDescription(delimiter, userDescription);
    }
    static void SerializeBinary(const DataType & data, std::ostream & outputStream) CISST_THROW(std::runtime_error) {
        data.SerializeBinary(outputStream);
    }
    static void DeSerializeBinary(DataType & data, std::istream & inputStream, const cmnDataFormat & localFormat, const cmnDataFormat & remoteFormat) CISST_THROW(std::runtime_error) {
        data.DeSerializeBinary(inputStream, localFormat, remoteFormat);
    }
    static void SerializeText(const DataType & data, std::ostream & outputStream, const char delimiter = ',') CISST_THROW(std::runtime_error) {
        data.SerializeText(outputStream, delimiter);
    }
    static void DeSerializeText(DataType & data, std::istream & inputStream, const char delimiter = ',') CISST_THROW(std::runtime_error) {
        data.DeSerializeText(inputStream, delimiter);
    }
    static std::string HumanReadable(const DataType & data) {
        return data.HumanReadable();
    }
    static bool ScalarNumberIsFixed(const DataType & data) {
        return data.ScalarNumberIsFixed();
    }
    static size_t ScalarNumber(const DataType & data) {
        return data.ScalarNumber();
    }
    static std::string ScalarDescription(const DataType & data, const size_t index, const std::string & userDescription = "") CISST_THROW(std::out_of_range) {
        return data.ScalarDescription(index, userDescription);
    }
    static double Scalar(const DataType & data, const size_t index) CISST_THROW(std::out_of_range) {
        return data.Scalar(index);
    }
};
inline std::ostream & operator << (std::ostream & outputStream, const prmBaseFrame & data) {
    outputStream << cmnData<prmBaseFrame >::HumanReadable(data);
    return outputStream;
}
#if CISST_HAS_JSON
template <> void CISST_EXPORT cmnDataJSON<prmBaseFrame >::SerializeText(const prmBaseFrame & data, Json::Value & jsonValue);
template <> void CISST_EXPORT cmnDataJSON<prmBaseFrame >::DeSerializeText(prmBaseFrame & data, const Json::Value & jsonValue) CISST_THROW(std::runtime_error);
#endif // CISST_HAS_JSON
 
/* source line: 122 */
 
CMN_DECLARE_SERVICES_INSTANTIATION(prmBaseFrame);
 
 
#endif // _cisstParameterTypes_prmBaseFrame_h