VisualsModel.h

/******************************************************************************
* Copyright (c) ATTX LLC 2024. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX, LLC. The Software is 
* furnished under a license agreement between ATTX and the user organization 
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION 
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or 
* transmitted in any form or by any means, for any purpose, without the express 
* written permission of ATTX, LLC.
******************************************************************************/
/*
Visuals model header file
 
Author: Alex Reynolds
*/
 
#ifndef SIMULATION_VISUALS_MODEL_H
#define SIMULATION_VISUALS_MODEL_H
 
#include <string>
 
#include "architecture/Time.h"
#include "architecture/Tasks.h"
#include "simulation/SimulationSteps.h"
#include "six_dof_dynamics/Frame.hpp"
 
namespace modelspace {
 
    // Variables to control socket output from ModelSpace
    const std::string OBJNAME = "MSO";
    const std::string JSONSTART = "{";
    const std::string JSONEND = "}";
    const std::string OBJSTART = "[";
    const std::string OBJEND = "]";
    const std::string FRAMESTART = "{";
    const std::string FRAMEEND = "}";
    const std::string QUOTEMARK = "\'";
 
    /**
     * @brief   Class to write out frame information via socket using a standard interface as follows:
     * 
     * INTERFACE DEFINITION
     * Data is written to the interface in JSON format with any number of named objects, which correspond
     * to the frame names, and expected fields (x,y,z)pos and (x,y,z,w)rot for each named object. Quaternions
     * are written in scalar-last format.
     * 
     * Full example: {'Mickey':[]'xpos':<value>,'ypos':<value>,'zpos':<value>,'xrot':<value>,'yrot':<value>,'zrot':<value>,'wrot':<value>]}
     * 
     * This interface is designed to communicate frame state information in a 
     * frame-agnostic way across a socket interface. Every step, based on real
     * time timing, this model will broadcast frame state information across a 
     * socket via the interface definition above.
     * 
     * Alex Reynolds <alex.reynolds@attx.tech>
    */
    class VisualsModel : public clockwerk::Task {
    public:
        // Model params
        //         NAME                     TYPE                    DEFAULT VALUE
        START_PARAMS
            /** The IP address on which the visuals client socket will bind. Default is 127.0.0.1 (local)*/
            SIGNAL(ip,                      std::string,            "127.0.0.1")
            /** The port to which the visuals client socket will bind. Default is 25001*/
            SIGNAL(port,                    int,                    25001)
            /** The maximum rate at which ModelSpace will write out updates -- should correspond roughly to framerate.
             * ModelSpace will not output updates any faster than this rate, but may output slower.*/
            SIGNAL(max_frame_rate,          int,                    35)
        END_PARAMS
 
        // Model inputs
        //         NAME                     TYPE                    DEFAULT VALUE
        START_INPUTS
 
        END_INPUTS
 
        // Model outputs
        //         NAME                     TYPE                    DEFAULT VALUE
        START_OUTPUTS
            /** An exact mirror of the data written out to the visuals socket for testing */
            SIGNAL(socket_output,           std::string,            "")
        END_OUTPUTS
 
        /// @brief Function to add a simulation frame to the model as a visual output for 3D graphics
        /// @param frame_ptr    The frame to be added as a visual output 
        /// @param type         The type of object being output. Valid choices are: [SAT]
        int addVisualFrame(FrameD* frame_ptr, const std::string &type="SAT");
 
        /// @brief Function to set the reference frame for the visuals. If not set, the default is the root frame
        /// @param frame_ptr Pointer to the reference frame for the visuals
        void setVisualsReference(FrameD* frame_ptr);
 
        // Model-specific implementations of startup and derivative
        VisualsModel(clockwerk::Executive &e, int schedule_slot=END_STEP, const std::string &m_name="visuals_model")
            : clockwerk::Task(e, schedule_slot, m_name) {}
        virtual ~VisualsModel();
    protected:
        int start();
        int execute();
 
        /// @brief Function to write the frame root position in the appropriate format to str
        /// @param frame_ptr Frame to write position of
        /// @param str Implicit return of state string
        void _writeFrameRootPosition(FrameD* frame_ptr, std::string &str);
 
        /// @brief Function to write the frame root attitude in the appropriate format to str
        /// @param frame_ptr Frame to write attitude of
        /// @param str Implicit return of state string
        void _writeFrameRootAttitude(FrameD* frame_ptr, std::string &str);
 
        /// @brief Function to write the full frame state in json format to string
        /// @param frame_ptr Frame to write state of
        /// @param type The type of frame
        /// @param str Implicit return of state string
        void _writeFullFrameNameState(FrameD* frame_ptr, const std::string &type, std::string &str);
 
        // The socket to which all data will be written
        int _client_socket = -9999;
 
        // The reference frame relative to which visuals states are defined
        FrameD* _reference_frame_ptr = nullptr;
 
        // Vector of frames which will be "tracked" by the visuals model and written out across the socket
        std::vector<FrameD*> _tracked_frame_ptrs;
        std::vector<std::string> _types;
 
        // Strings to which various frame parameters will be written
        std::string _pos_str;
        std::string _att_str;
        std::string _full_frame_str;
        std::string _full_str;
 
        // Temporary variables
        CartesianVector3D _tmp_vec;
        QuaternionD _tmp_quat;
        DCMD _tmp_dcm;
 
        // Timing variables. 
        clockwerk::Time _step_size;
        clockwerk::Time _next_write;
    };
 
}
 
#endif