F18 Initialization Class

The DtF18Initializer class is a subclass of VR-Link's DtVrlApplicationInitializer.

This class processes the command line and reads the F18's mtl file.

---

Header file:

/*******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*******************************************************************************/

#pragma once

#include <vl/exConnInit.h>
#include <vlutil/vlString.h>
#include <mtl/lispEnv.h>
#include <matrix/vlVector.h>

#include <mtl/configVar.h>

class DtMtlEnvironment;

class DtF18Initializer : public DtVrlApplicationInitializer
{
public:

   DtF18Initializer(int argc, char* argv[], DtString AppName);

   virtual ~DtF18Initializer();

private:

   DtF18Initializer(const DtF18Initializer& other);

   DtF18Initializer &operator=(const DtF18Initializer &other);

public:

   virtual void parseCmdLine();
   virtual void initializeMtlParams();

   virtual void setInitialPosition(const DtVector& loc);
   virtual DtVector initialPosition() const;

   virtual void setLispFileName(const DtString& name);
   virtual DtString lispFileName() const;

   virtual void setDeadReckonAlgorithm(unsigned long alg);
   virtual unsigned long deadReckonAlgorithm() const;

   virtual void setInitialTurnRadius(double radius);
   virtual double initialTurnRadius() const;

   virtual void setInitialSpeed(double speed);
   virtual double initialSpeed() const;

   virtual void setEntityTypeStr(const DtString& type);
   virtual DtString entityTypeStr() const;

   virtual void setF18Markings(const DtString& markings);
   virtual DtString f18Markings() const;

   virtual void setF18Name(const DtString& name);
   virtual DtString f18Name() const;

   virtual void setDestroyedToFinalDelay(double delay);
   virtual double destroyedToFinalDelay() const;

   virtual void setInitialHeading(double heading);
   virtual double initialHeading() const;

   virtual void setLethalDetonationRange(double range);
   virtual double lethalDetonationRange() const;

   virtual void setMunitionFlightTime(double time);
   virtual double munitionFlightTime() const;

   virtual void setInitialPitch(double pitch);
   virtual double initialPitch() const;

   virtual void setInitialRoll(double roll);
   virtual double initialRoll() const;

   virtual void setAutoRoll(bool onOff);
   virtual bool autoRoll() const;

   virtual void setEntityNumber(int number);
   virtual int entityNumber() const;

   virtual void setHaveArtParts(bool onOff);
   virtual bool haveArtParts() const;

   virtual void setDeltaTime(DtTime time);
   virtual DtTime deltaTime() const;

   virtual void setRefLatitude(double lat);
   virtual double refLatitude() const;

   virtual void setRefLongitude(double lon);
   virtual double refLongitude() const;

#if DtHLA
   virtual void setApplicationNumber(int num);
   virtual int applicationNumber() const;

   virtual void setSiteId(int id);
   virtual int siteId() const;
#endif

protected:
   virtual void loadMtlFile(const DtString& fileName);


protected:
   DtConfigVariable<DtVector> myInitialPosition;
   DtConfigVariable<DtString> myLispFileName;
   DtConfigVariable<int>      myDeadReckonAlgorithm;
   DtConfigVariable<double>   myInitialTurnRadius;
   DtConfigVariable<double>   myInitialSpeed;
   DtConfigVariable<DtString> myEntityTypeString;
   DtConfigVariable<DtString> myMarkings;
   DtConfigVariable<DtString> myName;
   DtConfigVariable<double>   myDestroyedToFinalDelay;
   DtConfigVariable<double>   myInitialHeading;
   DtConfigVariable<DtString> myTopoOrigin;
   DtConfigVariable<DtVector> myWorldPosition;
   DtConfigVariable<double>   myLethalDetonationRange;
   DtConfigVariable<double>   myMunitionFlightTime;
   DtConfigVariable<double>   myInitialPitch;
   DtConfigVariable<double>   myInitialRoll;
   DtConfigVariable<bool>     myAutoRoll;
   DtConfigVariable<int>      myEntityNumber;
   DtConfigVariable<bool>     myHaveArtParts;
   DtConfigVariable<double>   myRefLatitude;
   DtConfigVariable<double>   myRefLongitude;
   DtConfigVariable<double>   myDeltaTime;
#if DtHLA


   DtConfigVariable<int> myConfigVarApplicationNumber;
   DtConfigVariable<int> mySiteId;
#endif

   int myMtlAutoRoll;
   int myMtlHaveArtParts;
   DtVector myMtlInitialPosition;
};

---

Implementation:

/*******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*******************************************************************************/


#include "f18Init.h"

#include <matrix/vlVector.h>
#include <matrix/geodCoord.h>
#include <stdio.h>

// Constructor -- Initialize the base class (will initialize protocol-specific
// parameters), command line arguments and mtl parameters
DtF18Initializer::DtF18Initializer(int argc, char* argv[], DtString appName ) :
   DtVrlApplicationInitializer(argc, argv, appName),
   myInitialPosition(mySettings, "initialPosition", DtVector(0.0, 0.0, -1230.0), "Initial Location", 
      DtBaseConfigVariable::DtScopeBoth, false, "L"),
   myLispFileName(mySettings, "&lispFile", "f18.xml", "LISP File Name"),
   myDeadReckonAlgorithm(mySettings, "deadReckonAlgorithm", 4, "Dead Reckon Algorithm", 
      DtBaseConfigVariable::DtScopeBoth, false, "D"),
   myInitialTurnRadius(mySettings, "initialTRadius", -250.0, "Initial Turn Radius", 
      DtBaseConfigVariable::DtScopeBoth, false, "r"),
   myInitialSpeed(mySettings, "initialSpeed", 40.0, "Initial Speed"),
   myEntityTypeString(mySettings, "entity&TypeStr", "1:2:225:1:9:0:0", "Entity Type String"),
   myMarkings(mySettings, "f18&Markings", "MAK-VRLink-F18", "F18 Markings"),
   myName(mySettings, "f18Name", "MaK-F18", "F18 Object Name"),
   myDestroyedToFinalDelay(mySettings, "&destroyedToFinalDelay", 20.0, 
      "Destroyed To Final Delay"),
   myInitialHeading(mySettings, "initial&Heading", 180.0, "Initial Heading"),
   myTopoOrigin(mySettings, "topo&Origin", "35.699760,-121.326577", 
      "Topographic Coordinate System Origin"),
   myWorldPosition(mySettings, "worldPos", DtVector(0.0, 0.0, 0.0), 
      "Initial Position in Geocentric Coordinates", 
      DtBaseConfigVariable::DtScopeBoth, false, "W"),
   myLethalDetonationRange(mySettings, "lethalDetonationRange", 20.0, 
      "Lethal Detonation Range", DtBaseConfigVariable::DtScopeConfigFile),
   myMunitionFlightTime(mySettings, "munitionFlightTime", 3.0, "Munition Flight Time",
      DtBaseConfigVariable::DtScopeConfigFile),
   myInitialPitch(mySettings, "initialPitch", 0.0, "Initial Pitch",
      DtBaseConfigVariable::DtScopeConfigFile),
   myInitialRoll(mySettings, "initialRoll", 0.0, "Initial Roll",
      DtBaseConfigVariable::DtScopeConfigFile),
   myAutoRoll(mySettings, "autoRoll", true, "Auto Roll",
      DtBaseConfigVariable::DtScopeConfigFile),
   myEntityNumber(mySettings, "entNum", 1, "Entity Number",
      DtBaseConfigVariable::DtScopeConfigFile),
   myHaveArtParts(mySettings, "haveArtParts", false, "Have Articulated Parts",
      DtBaseConfigVariable::DtScopeConfigFile),
   myRefLatitude(mySettings, "refLatitude", 35.699760, "Reference Latitude",
      DtBaseConfigVariable::DtScopeConfigFile),
   myRefLongitude(mySettings, "refLongitude", -121.326577, "Reference Longitude",
      DtBaseConfigVariable::DtScopeConfigFile),
   myDeltaTime(mySettings, "deltaTime", 0.05, "Delta Time", 
      DtBaseConfigVariable::DtScopeConfigFile),
   myMtlAutoRoll(1),
#if DtHLA
   myConfigVarApplicationNumber(mySettings, "&appNumber", 2, "Application Number"),
   mySiteId(mySettings, "&siteId", 1, "Site ID"),
#endif
   myMtlHaveArtParts(0),
   myMtlInitialPosition(0.0, 0.0, -1230.0)
{
   mySettings.setChangeOnce(true);
}

DtF18Initializer::~DtF18Initializer()
{

}

void DtF18Initializer::initializeMtlParams()
{
   DtVrlApplicationInitializer::initializeMtlParams();
   myMtlEnv->registerConfigVar(myDeadReckonAlgorithm);
   myMtlEnv->registerConfigVar(myInitialTurnRadius);
   myMtlEnv->registerConfigVar(myInitialSpeed);
   myMtlEnv->registerConfigVar(myInitialHeading);
   myMtlEnv->registerConfigVar(myEntityTypeString);
   myMtlEnv->registerConfigVar(myMarkings);
   myMtlEnv->registerConfigVar(myName);
   myMtlEnv->registerConfigVar(myDestroyedToFinalDelay);
   myMtlEnv->registerConfigVar(myLethalDetonationRange);
   myMtlEnv->registerConfigVar(myMunitionFlightTime);
   myMtlEnv->registerConfigVar(myInitialPitch);
   myMtlEnv->registerConfigVar(myInitialRoll);
   myMtlEnv->registerConfigVar(myEntityNumber);
   myMtlEnv->registerConfigVar(myRefLatitude);
   myMtlEnv->registerConfigVar(myRefLongitude);
   myMtlEnv->registerConfigVar(myDeltaTime);
   myMtlEnv->registerVar("autoRoll", &myMtlAutoRoll);
   myMtlEnv->registerVar("haveArtParts", &myMtlHaveArtParts);
   myMtlEnv->registerVar("initialPos[0]", &myMtlInitialPosition[0]);
   myMtlEnv->registerVar("initialPos[1]", &myMtlInitialPosition[1]);
   myMtlEnv->registerVar("initialPos[2]", &myMtlInitialPosition[2]);
#if DtHLA
   myMtlEnv->registerConfigVar(myConfigVarApplicationNumber);
   myMtlEnv->registerConfigVar(mySiteId);
#endif

}

// Parses the command line
void DtF18Initializer::parseCmdLine()
{
   // Note that we're manually parsing the command line here in order to
   // see whether a file has been specified.  This is due to the support of
   // MTL files.  If the command line is parsed, and then an MTL file is loaded,
   // the command line values will be overridden.  This is not the case with XML.
   // As long as "changeOnce" is set to true on the application settings object,
   // values can only be changed once.  In other words, if the command line is parsed,
   // and values are set, and a file is then loaded, the values set by the command
   // line will not be overridden.  This is not the case with MTL yet.
   for (int index = 1; index < myArgc; ++index)
   {
      if (!strcmp(myArgv[index], "-l") || !strcmp(myArgv[index], "--lispFile"))
      {
         if ((index + 1) < myArgc)
         {
            myLispFileName.setValue(myArgv[index+1]);
            break;
         }
      }
   }

   loadFile(myLispFileName.value());

   DtVrlApplicationInitializer::parseCmdLine();

   if (myInitialPosition.isSet())
   {
      // NOTE: only -L specifies X, Y, and -Z (north, east, and up)
      // All local positions are north, east, down [not up]
      DtVector posVec = myInitialPosition.value();
      posVec[2] = -posVec[2];
      myInitialPosition.setValue(posVec);
   }

   if (myTopoOrigin.isSet())
   {
      double refLat = myRefLatitude.defaultValue();
      double refLon = myRefLongitude.defaultValue();
      int numReads = sscanf( myTopoOrigin.value().c_str(), "%lf,%lf", &refLat, &refLon);

      if (numReads > 0)
      {
         myRefLatitude.setValue(refLat);
         if (numReads > 1)
            myRefLongitude.setValue(refLon);
      }
   }

   if (myWorldPosition.isSet())
   {           
      DtGeodeticCoord initPos;
      initPos.setGeocentric( myWorldPosition.value());
      myRefLatitude.setValue(DtRad2Deg( initPos.lat() ));
      myRefLongitude.setValue(DtRad2Deg( initPos.lon() ));
   }
}
//--------------------------------------------------------------
//    ACCESSORS/MODIFIERS
//    Provide a way to inspect/modify the data
//--------------------------------------------------------------

void DtF18Initializer::setInitialPosition(const DtVector& loc)
{
   myInitialPosition.setValue(loc);
}

DtVector DtF18Initializer::initialPosition() const
{
   return myInitialPosition.value();
}

void DtF18Initializer::setLispFileName(const DtString& name)
{
   myLispFileName.setValue(name);
}

DtString DtF18Initializer::lispFileName() const
{
   return myLispFileName.value();
}

void DtF18Initializer::setDeadReckonAlgorithm(unsigned long alg)
{
   myDeadReckonAlgorithm.setValue(alg);
}

unsigned long DtF18Initializer::deadReckonAlgorithm() const
{
   return myDeadReckonAlgorithm.value();
}

void DtF18Initializer::setInitialTurnRadius(double radius)
{
   myInitialTurnRadius.setValue(radius);
}

double DtF18Initializer::initialTurnRadius() const
{
   return myInitialTurnRadius.value();
}

void DtF18Initializer::setInitialSpeed(double speed)
{
   myInitialSpeed.setValue(speed);
}

double DtF18Initializer::initialSpeed() const
{
   return myInitialSpeed.value();
}

void DtF18Initializer::setEntityTypeStr(const DtString& type)
{
   myEntityTypeString.setValue(type);
}

DtString DtF18Initializer::entityTypeStr() const
{
   return myEntityTypeString.value();
}

void DtF18Initializer::setF18Markings(const DtString& markings)
{
   myMarkings.setValue(markings);
}

DtString DtF18Initializer::f18Markings() const
{
   return myMarkings.value();
}

void DtF18Initializer::setF18Name(const DtString& name)
{
   myName.setValue(name);
}

DtString DtF18Initializer::f18Name() const
{
   return myName.value();
}

void DtF18Initializer::setDestroyedToFinalDelay(double delay)
{
   myDestroyedToFinalDelay.setValue(delay);
}

double DtF18Initializer::destroyedToFinalDelay() const
{
   return myDestroyedToFinalDelay.value();
}

void DtF18Initializer::setInitialHeading(double heading)
{
   myInitialHeading.setValue(heading);
}

double DtF18Initializer::initialHeading() const
{
   return myInitialHeading.value();
}

void DtF18Initializer::setLethalDetonationRange(double range) 
{
   myLethalDetonationRange.setValue(range);
}

double DtF18Initializer::lethalDetonationRange() const
{
   return myLethalDetonationRange.value();
}

void DtF18Initializer::setMunitionFlightTime(double time)
{
   myMunitionFlightTime.setValue(time);
}

double DtF18Initializer::munitionFlightTime() const
{
   return myMunitionFlightTime.value();
}

void DtF18Initializer::setInitialPitch(double pitch)
{
   myInitialPitch.setValue(pitch);
}

double DtF18Initializer::initialPitch() const
{
   return myInitialPitch.value();
}

void DtF18Initializer::setInitialRoll(double roll)
{
   myInitialRoll.setValue(roll);
}

double DtF18Initializer::initialRoll() const
{
   return myInitialRoll.value();
}

void DtF18Initializer::setAutoRoll(bool onOff)
{
   myAutoRoll.setValue(onOff);
}

bool DtF18Initializer::autoRoll() const
{
   return myAutoRoll.value();
}

void DtF18Initializer::setEntityNumber(int number)
{
   myEntityNumber.setValue(number);
}

int DtF18Initializer::entityNumber() const
{
   return myEntityNumber.value();
}

void DtF18Initializer::setRefLatitude(double lat)
{
   myRefLatitude.setValue(lat);
}

double DtF18Initializer::refLatitude() const
{
   return myRefLatitude.value();
}

void DtF18Initializer::setRefLongitude(double lon)
{
   myRefLongitude.setValue(lon);
}

double DtF18Initializer::refLongitude() const
{
   return myRefLongitude.value();
}

void DtF18Initializer::setHaveArtParts(bool onOff)
{
   myHaveArtParts.setValue(onOff);
}

bool DtF18Initializer::haveArtParts() const
{
   return myHaveArtParts.value();
}

void DtF18Initializer::setDeltaTime(DtTime time)
{
   myDeltaTime.setValue(time);
}

DtTime DtF18Initializer::deltaTime() const
{
   return myDeltaTime.value();
}

void DtF18Initializer::loadMtlFile( const DtString& fileName )
{
   DtVrlApplicationInitializer::loadMtlFile(fileName);
   setAutoRoll(myMtlAutoRoll);
   setHaveArtParts(myMtlHaveArtParts);
   setInitialPosition(myMtlInitialPosition);
}

#if DtHLA
void DtF18Initializer::setApplicationNumber(int num)
{
   myConfigVarApplicationNumber.setValue(num);
}

int DtF18Initializer::applicationNumber() const
{
   return myConfigVarApplicationNumber.value();
}

void DtF18Initializer::setSiteId(int id)
{
   mySiteId.setValue(id);
}

int DtF18Initializer::siteId() const
{
   return mySiteId.value();
}


#endif