stkvisualization.cpp

Go to the documentation of this file.

//////////////////////////////////////////////////////////////////////////////////////////////////
/**     \class StkVisualization
*       \brief Visualize satellite position and attitude using STK
*       \author: spikeinferno
*       \version $Revision: 1.8 $
*       \date    $Date: 2006/07/31 19:07:53 $
*//////////////////////////////////////////////////////////////////////////////////////////////////
/*
*       Suggested Future Improvements:
*       - Configuration file read by xml parser: use an external file to set 
*               all the visualization parameters so the program does not need
*               to be compiled every time something is changed
*       - Add error messages and error checking for improper inputs 
*/
//////////////////////////////////////////////////////////////////////////////////////////////////

#define AGCONNECT
#include <AgConnect.h>
#include "stkvisualization.h"
#include <sys/time.h>
#include <string>
#include <sstream>
#include <iostream>
using std::string;
using std::ostringstream;
using namespace std;

extern "C" {
char AgEAppName[ ]="stkvisualization";
}

// Finds the current time (in Epoch seconds) + user-input offset time
double StkVisualization::GetOffsetTime()
{
        struct timeval curtime;
        const double microSecPerSec = 1000000.0;

        gettimeofday(&curtime, NULL);
        return curtime.tv_sec + (curtime.tv_usec / microSecPerSec) + Offset;
}

// Cleans up ErrorExists and ReturnInfo; used at the beginning of each function
void StkVisualization::ClearError()
{
        if (ErrorExists)
                {
                ErrorExists = false;
                AgConCleanupReturnInfo(ReturnInfo);
                }
}

// Sends commands to STK 
// SendCommand copies a command of type ostringstream to the CommandBuffer and sends it to STK 
bool StkVisualization::SendCommand(ostringstream & commandLine)
{       
        // AgConInit takes a char* for hostname, so copying string to buffer
        strcpy(CommandBuffer, commandLine.str().c_str()); 

        // Sends command and returns any error
        if (AgConProcessSTKCmd(ConID, CommandBuffer, ReturnInfo) == AgCError)
                {
                ErrorExists = true;
                return false;
                }

        AgConCleanupReturnInfo(ReturnInfo);
}

// Sends commands to STK
// SendCommand Overload: Copies a command of type string to the CommandBuffer and sends it to STK
bool StkVisualization::SendCommand(string commandLine)
{
        strcpy(CommandBuffer, commandLine.c_str());     // AgConInit takes a char* for hostname, 
                                                        //      so copying string to buffer

        // Sends command and returns any error
        if (AgConProcessSTKCmd(ConID, CommandBuffer, ReturnInfo) == AgCError)
                {
                ErrorExists = true;
                return false;
                }

        AgConCleanupReturnInfo(ReturnInfo);
}

// StkVisualization constructor
StkVisualization::StkVisualization(double offset) :
        // Initializes Offset, ConID, and ErrorExists
        Offset(offset), ConID(NULL), ErrorExists(false)
{
        strcpy(CommandBuffer, "");                      // UGLY HACK -- JRS -- AgConInit takes a char* 
                                                        //      for hostname, so copying string to buffer
        ReturnInfo = new AgTConReturnInfo;
}

// StkVisualization destructor
StkVisualization::~StkVisualization()
{
        ClearError(); 

        delete ReturnInfo;
}

// Establishes connection to STK
bool StkVisualization::ConnectStk(const char* stkHostAddress, const char* stkHostPort)
{
        ClearError();

        // initialize STK and check for errors
        if (AgConInit(NULL) == AgCError)
                return false;

        // Create string: <stkHostAddress:stkHostPort>
        ostringstream stk;
        stk << stkHostAddress;
        stk << ":";
        stk << stkHostPort;
        strcpy(CommandBuffer, stk.str().c_str());       // AgConInit takes a char* for 
                                                        //      hostname, so copying string to buffer

        // Calls the const char* version of stk string and checks for error
        if (AgConOpenSTK(&ConID, CommandBuffer) == AgCError)    
                return false;

        return true;
}

// Create and set up the scenario
bool StkVisualization::SetUpScenario()
{
        ClearError();

        // Creates the scenario
        string createScenario = "New / Scenario " + ScenarioName;
        SendCommand(createScenario);

        // Set the GUI units for Date to Gregorian Coordinated Universal Time (UTC)
        string setGUIDate = "SetGUIUnits * Date GREGUTC";
        SendCommand(setGUIDate);
        
        // Set the Connect unit for Date to Gregorian Coordinated Universal Time (UTC)
        // Set the Connect unit for Distance to kilometers
        string setConnectDate = "SetUnits / km GREGUTC";
        SendCommand(setConnectDate);

        /// Set Start and Stop times for the scenario

        string setTimePeriod = "SetTimePeriod * \"Today\" \"+3 days\"";
        SendCommand(setTimePeriod);

        // Set Epoch time for the scenario
        if (AgConProcessSTKCmd(ConID, "SetEpoch * \"1 Jan 1970 00:00:00.0\"", ReturnInfo) == AgCError)
                {
                ErrorExists = true;
                return false;
                }

        AgConCleanupReturnInfo(ReturnInfo);

        // Put scenario into Real Time mode
        string setAnimationMode = "Animate * SetAnimationMode RealTime";
        SendCommand(setAnimationMode);
        
        // Set animation Real Time offset to -26 seconds
        string realTimeOffset = "Animate * RealTimeOffset -26"; 
        SendCommand(realTimeOffset);

        // Set animation refresh mode to "High speed"
        string setRefreshMode = "Animate * SetRefreshMode HighSpeed";
        SendCommand(setRefreshMode);
        
        return true;
}


// Set up array of satellite names
// Uses the number of satellites specified by the user to set the size of the SatelliteName array
bool StkVisualization::SetUpNumberOfSatellites()
{
        // Allocate memory for string array to store satellite names
        SatelliteName = new (nothrow) string[NumberOfSatellites];
        
        // Allocate memory for bool array to store if satellites have positions
        SatellitePositionUpdate = new (nothrow) bool[NumberOfSatellites];       
        
        AllSatellitesUpdated = false;                   // Not all satellites have a position yet
        WindowsSet = false;                             // Animation windows have not been set yet

        // Every satellite currently have no position
        for (int iterator = 0; iterator < NumberOfSatellites; iterator++)
        {
                SatellitePositionUpdate[iterator] = false;
        }

        // Error messages if memory allocation for dynamic arrays fail
        if (SatelliteName == 0)
        {
                cout << "Error in memory allocation for array of satellite names" << endl;
                return false;
        }
        else if (SatellitePositionUpdate == 0)
        {
                cout << "Error in memory allocation for array of satellite names" << endl;
                return false;
        }
        return true;
}


// Set up the satellites in STK
bool StkVisualization::SetUpSatellite()
{
        ClearError();
        
        // cycle through each satellite
        for(int counter = 0; counter < NumberOfSatellites; counter++)
        {
        
                // Creates satellite with user-specified name
                // Command is in following format: "New / Scenario/<userInputScenarioName>/Satellite <userInputSatelliteName>"
                string createSatellite = "New / Scenario/" + ScenarioName + "/Satellite " + SatelliteName[counter];
                SendCommand(createSatellite);

                // Set propagator to RealTime
                string setRealTime;
                setRealTime = "Realtime */Satellite/" + SatelliteName[counter]+ " SetProp ";
                SendCommand(setRealTime);

                // Set look-ahead propagator (required for setting propagator to RealTime)
                // HoldCBIPosition: does not display a forward orbit track based on current position and velocity
                //                  orbit is entirely based on a realtime data stream
                // TwoBody: displays a partial forward orbit track based on two body motion
                string setLookAhead;
                setLookAhead = "Realtime */Satellite/" + SatelliteName[counter] + " SetLookAhead HoldCBIPosition 1500 3 30";
                SendCommand(setLookAhead);      

                // Set Start and Stop times for the satellite (same as scroenario)
                string setTimePeriod = "SetTimePeriod * \"Today\" \"+3 days\"";
                SendCommand(setTimePeriod);

                // Set Attitude to Real Time mode (1800 is the default value)
                ostringstream setAttitudeRealTime;
                setAttitudeRealTime << "SetAttitude */Satellite/" + SatelliteName[counter] + " RealTime Extrapolate 1800 1800";
                SendCommand(setAttitudeRealTime);

                // Show attitude sphere
                // ENHANCEMENT - make this command optional
                string showAttitudeSphere = "VO */Satellite/" + SatelliteName[counter] + " AttitudeView Sphere Show On";        
                SendCommand(showAttitudeSphere);

                // Show Body Axes
                // ENHANCEMENT - create set of body axes to match whorl 1 and 2 and use that set instead of the default 
                string showBodyAxes = "VO */Satellite/" + SatelliteName[counter] + " SetVectorGeometry Modify \"Satellite/" + SatelliteName[counter] + " Body Axes\" Show On";
                SendCommand(showBodyAxes);

                // Show VVLH (Vehicle Velocity, Local Horizontal) Axes
                // ENHANCEMENT - make this command optional
                string showVVLHAxes = "VO */Satellite/" + SatelliteName[counter] + " SetVectorGeometry Modify \"Satellite/" + SatelliteName[counter] + " VVLH Axes\" Show On Color red";
                SendCommand(showVVLHAxes);

                // Ensure grpahics window is updated whenever a change takes place
                string allowAnimationUpdate = "AllowAnimationUpdate * On";
                SendCommand(allowAnimationUpdate);

                // Reset the Animation
                string resetAnimation = "Animate * Reset";
                SendCommand(resetAnimation);

                //Turn on max ambient lighting for satellite so that the satellite is visable at all times
                string satelliteLighting = "VO * Lighting ObjAmbient 100";
                SendCommand(satelliteLighting);
        }

        return true;
}

// Start Animation
bool StkVisualization::StartAnimation()
{
        ClearError();

        // Set the unit for Date to Epoch seconds
        string setDateToEpoch = "SetUnits / EpochSec";
        SendCommand(setDateToEpoch);

        // Set initial values of animation
        ostringstream timeWithOffset;
        timeWithOffset.flags(std::ios_base::fixed);             // Allows decimal format for time
        timeWithOffset << "Animate * SetValues \"";
        timeWithOffset << GetOffsetTime();
        timeWithOffset << "\" ";
        timeWithOffset << "0.1 ";
        timeWithOffset << "0.1";
        SendCommand(timeWithOffset);
        
        // Start the animation
        string startAnimation = "Animate * Start Realtime";
        SendCommand(startAnimation);

        for (int counter = 0; counter < NumberOfSatellites; counter++)
        {
                // Clear any old attitude information
                ostringstream clearAttitudeData;
                clearAttitudeData << "SetAttitude ";
                clearAttitudeData << "*/Satellite/";
                clearAttitudeData << SatelliteName[counter];
                clearAttitudeData << " ClearData";
                SendCommand(clearAttitudeData);
        }
        
        return true;
}

// Divides the screen with 2D and 3D windows
// A single 2D window displays the ground track of all the satellites in the simulation
// Each satellite has is own 3D window to visualize attitude
// This function needs to run only once
//      NOTE: Creating 3D attitude graphics windows and centering 3D windows about the 
//            satellites cannot be done unless the satellite has been given a position. 
//            Therefore, this function is called once the update function for position  
//            has been called for all of the satellites.  
bool StkVisualization::SetWindows()
{
        int screenWidth = 1200;                                         // Screen width in pixels
        int screenHeight = 750;                                         // Screen height in pixels
        int windowWidth3D = (screenWidth/2)/(NumberOfSatellites/4+1);   // Set width of each 3D window 
                                                                        // Splits the right half of 
                                                                        //      the screen for every 
                                                                        //      4th window
        int windowHeight3D;

        if (NumberOfSatellites <= 3)
                windowHeight3D = screenHeight/(NumberOfSatellites);     // set height of each 3D window
        else
                windowHeight3D = screenHeight/(3);

        int windowWidth2D = screenWidth/2;                              // set width of 2D window
        int windowHeight2D = screenHeight;                              // set height of 2D window
        int reducedCounter;                                             // used to store the for-loop 
                                                                        //      counter with a value 
                                                                        //      between 0 and 2
        // removes default 3D window
        string removeFirst3DWindow = "Window3D * Remove 1";
        SendCommand(removeFirst3DWindow);               

        // cycle through each satellite
        for (int counter = 0; counter < NumberOfSatellites; counter++)
        {
                // creates a new 3D window for each 2nd and any additional satellites
                //      one 3D window already exists by default

                string create3DWindow = "Window3D * CreateWindow Type Normal";  
                SendCommand(create3DWindow);
        
                string create3DWindowAttitude =  "Window3D * CreateWindow Type Attitude Path Satellite/"
                                         + SatelliteName[counter];
//              SendCommand(create3DWindowAttitude);

                // set size of 3D windows
                ostringstream set3DWindowSize;
                set3DWindowSize << "Window3D * Size ";
                set3DWindowSize << windowWidth3D;
                set3DWindowSize << " ";
                set3DWindowSize << windowHeight3D;
                set3DWindowSize << " ";
                set3DWindowSize << counter+1;
                SendCommand(set3DWindowSize);
        
                reducedCounter = counter;                               // used to determine vertical window  
                                                                        //      location when more than 3
                while(reducedCounter>2)                                 //      windows are used
                        reducedCounter = reducedCounter - 3;            // ex: a 4th window would have a counter 
                                                                        // value of 3 but would be reduced to 0,
                                                                        // thus giving it the same vertical  
                                                                        // window location as the first window
                // set location of each 3D window
                // current max = 4 windows
                ostringstream set3DWindowPlace;
                set3DWindowPlace << "Window3D * Place ";
                set3DWindowPlace << (counter/3)*windowWidth3D;          // changes horizontal location of 
                set3DWindowPlace << " ";                                // every 4th window by one window width
                set3DWindowPlace << reducedCounter*windowHeight3D;
                set3DWindowPlace << " ";
                set3DWindowPlace << counter+1;
                SendCommand(set3DWindowPlace);

                // Center window about the satellite and allow free rotation and zoom
                ostringstream setView;
                setView << "VO * View FromTo FromRegName \"STK Object\" FromName \"Satellite/";
                setView << SatelliteName[counter];
                setView << "\" ToRegName \"STK Object\" ToName \"Satellite/";
                setView << SatelliteName[counter];
                setView << "\" WindowID ";
                setView << counter+1;
                SendCommand(setView);
                
                // Automatically zoom in by 0.8 times the central body's radius
                ostringstream setZoom;  
                setZoom << "VO * View Zoom WindowID ";
                setZoom << counter+1;
                setZoom << " FractionofCB 0.8";
                setZoom << "\" WindowID ";
                setZoom << counter+1;
                SendCommand(setZoom);
        }

        // set 2D window to take up right half of screen
        ostringstream set2DWindowSize;
        set2DWindowSize << "Window2D * Size";
        set2DWindowSize << screenWidth/2;
        set2DWindowSize << " ";
        set2DWindowSize << screenHeight;
        SendCommand(set2DWindowSize);

        ostringstream set2DWindowPlace;
        set2DWindowPlace << "Window2D * Place ";
        set2DWindowPlace << screenWidth/2; 
        set2DWindowPlace << " 0";
        SendCommand(set2DWindowPlace);

        return true;
}

// Updates the animation with the current time and next set of Euler angles, angles 1-3
bool StkVisualization::Update(  int satelliteNumber,    // (index number + 1): number assigned to satellite
                                int rotationSequence,   // 3-2-1 => rotationSequence = 321
                                double angle1,          // first angle in rotation sequence (deg)
                                double angle2,          // second angle in rotation sequence (deg)
                                double angle3)          // third angle in rotation sequence (deg)
{
        ClearError();

        double offsetTime = GetOffsetTime();            // Current animation time

        ostringstream newAttitude;                      // Stores new attitude information
        newAttitude.flags(std::ios_base::fixed);        // Allows decimal format for time
        newAttitude << "AddAttitude ";
        newAttitude << "*/Satellite/";
        newAttitude << SatelliteName[satelliteNumber-1];
        newAttitude <<  " Euler \"";
        newAttitude << offsetTime;
        newAttitude <<  "\" ";
        newAttitude << rotationSequence;
        newAttitude << " ";
        newAttitude << angle1;
        newAttitude << " ";
        newAttitude << angle2;
        newAttitude << " ";
        newAttitude << angle3;
        SendCommand(newAttitude);                       // Send new attitude information to STK

        return true;    
}

// Updates the animation with new attitude in quaternions
bool StkVisualization::Update(  int satelliteNumber,    // (index number + 1): number assigned to satellite     
                                double Q1,              // first vector component of quaternion
                                double Q2,              // second vector component of quaternion
                                double Q3,              // third vector component of quaternion
                                double Q4)              // scalar component of quaternion
{
        ClearError();

        double offsetTime = GetOffsetTime();            // Current animation time

        ostringstream newAttitude;                      // Stores new attitude information
        newAttitude.flags(std::ios_base::fixed);
        newAttitude << "AddAttitude ";
        newAttitude << "*/Satellite/";
        newAttitude << SatelliteName[satelliteNumber-1];
        newAttitude << " Quat \"";
        newAttitude << offsetTime;
        newAttitude << "\" ";
        newAttitude << Q1;
        newAttitude << " ";
        newAttitude << Q2;
        newAttitude << " ";
        newAttitude << Q3;
        newAttitude << " ";
        newAttitude << Q4;
        SendCommand(newAttitude);                       // Send new attitude information to STK

        return true;
}

// Updates orbit position with latitude, longitude, altitude, latitude rate, longitude rate, and altitude rate
bool StkVisualization::Update(  int satelliteNumber,    // (index number + 1): number assigned to satellite
                                double latitude,        // latitude of subsatellite point (deg)
                                double longitude,       // longitude of subsatellite point (deg)
                                double altitude,        // altitude of satellite (km) [distance units set in SetUpScenario] 
                                double latitudeRate,    // latitude rate (deg/sec)
                                double longitudeRate,   // longitude rate (deg/sec)
                                double altitudeRate)    // altitude rate (km/sec)
{
        ClearError();

        double offsetTime = GetOffsetTime();            // Current animation time

        ostringstream newPosition;                      // Stores new position information
        newPosition.flags(std::ios_base::fixed);
        newPosition << "SetPosition ";
        newPosition << "*/Satellite/";
        newPosition << SatelliteName[satelliteNumber-1];
        newPosition << " LLA \"";
        newPosition << offsetTime;
        newPosition << "\" ";
        newPosition << latitude;
        newPosition << " ";
        newPosition << longitude;
        newPosition << " ";
        newPosition << altitude;
        newPosition << " ";
        newPosition << latitudeRate;
        newPosition << " ";
        newPosition << longitudeRate;
        newPosition << " ";
        newPosition << altitudeRate;
        SendCommand(newPosition);                       // Send new orbit information to STK

        // Record that satellite has some initial position 
        SatellitePositionUpdate[satelliteNumber-1] = true;      

        // Verifies if all satellites have some initial position
        if (WindowsSet == false)
        {
                for(int iterator = 0; iterator < NumberOfSatellites; iterator++)
                {
                        if(SatellitePositionUpdate[iterator] == false)  // If any satellite does not have a position, 
                        {                                               //      AllSatellitesUpdated is set to false
                                AllSatellitesUpdated = false;
                                break;
                        }
                        else 
                                AllSatellitesUpdated = true;    
                }
        }
        
        if ((AllSatellitesUpdated == true) && (WindowsSet == false))    // Set up windows once all satellites have a position
        {                                                               //      and set up windows only once
                SetWindows();                                           // Divides the screen with 2D and 3D windows
                WindowsSet = true;                                      // Insures that windows are only set once
        }

        return true;
}

// Generates a string for the error message(s)
// ENHANCEMENT - error is output to user without user request - 
//      read about AgConProcessSTKCmd in STK Help and make sure that this GetLastError is set up correctly.
const char* StkVisualization::GetLastError(char* buffer)
{
        if (ErrorExists)
                {
                string errorMessage;
                for (int i=0; i < ReturnInfo->numEntries; i++)
                        {
                        errorMessage += ReturnInfo->returnList[i];
                        errorMessage += "\n";
                        }
                strcpy (buffer, errorMessage.c_str());                  // convert string to a const char*
                return buffer;
                }
        else
                {
                strcpy (buffer, "No data about error exists.");
                return buffer;
                }
}

// Stops animation and closes connection with STK
bool StkVisualization::ShutDownStk()
{
        ClearError();

        string stopAnimation = "Animate * Reset";
        SendCommand(stopAnimation);

        bool conClosed = true;
        if (AgConCloseSTK(&ConID) == AgCError)
                conClosed == false;

        AgConShutdownConnect();

        return conClosed;
}


// Do not change the comments below - they will be added automatically by CVS
/*****************************************************************************
*       $Log: stkvisualization.cpp,v $
*       Revision 1.8  2006/07/31 19:07:53  spikeinferno
*       Additional comments
*       
******************************************************************************/

---