fsUtil.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2024 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file fsUtil.h
//! \brief Unit conversion utilities for flight simulation cockpit displays
//!
//! This file provides constants and inline functions for common unit conversions
//! used in fixed-wing and rotary-wing GL Studio cockpit projects. Includes
//! conversions between metric and imperial units for altitude, speed, and distance.
 
#pragma once
 
#include <vrePlayerStation/playerStationApp.h>
 
#include <vrvCore/DtDisplayUnitsSettingsManager.h>
 
#include <string>
#include <vector>
#include <iostream>     // std::fixed
#include <iomanip>      // std::setprecision
#include <matrix/vlVector.h>
#include <matrix/topoCoord.h>
 
//! Contains constants and utility functions used in Fixed Wing and Rotary Wing
//! GLS projects.
 
static const float radToDegValue = 57.2958f;
static const float degToRadValue = 1.0f / radToDegValue;
 
static const float metersToFeetValue = 3.28084f;
static const float feetToMetersValue = 1.0f / metersToFeetValue;
 
static const float nauticalMilesToMetersValue = 1852.0f;
static const float metersToNauticalMilesValue = 1.0f / nauticalMilesToMetersValue;
 
static const float metersPerSecondToKnotsValue = 3600.0f / nauticalMilesToMetersValue;
 
//format is "azimuth;range;elevation;markingText;trackId;screenX;screenY;isDesignated"
static const int radarContactElements = 8;
 
inline float radToDeg(float value) { return value * radToDegValue; };
inline float degToRad(float value) { return value * degToRadValue; };
 
inline float metersToFeet(float value) { return value * metersToFeetValue; };
inline float feetToMeters(float value) { return value * feetToMetersValue; };
 
inline float nauticalMilesToMeters(float value) { return value * nauticalMilesToMetersValue; };
inline float metersToNauticalMiles(float value) { return value * metersToNauticalMilesValue; };
 
inline float metersPerSecondToKnots(float value) { return value * metersPerSecondToKnotsValue; };
 
#pragma warning (push)
#pragma warning (disable:4505) //These functions are not used by all modules. Disable this warning.
 
static std::string metersTo10kFeetText(float value)
{
   int altitudeIn10kFeet = metersToFeet(value) / 1000;
   std::stringstream ss;
   ss << altitudeIn10kFeet;
   return ss.str();
}
 
static void split(const std::string& str, char delimeter, std::vector<std::string>& tokens)
{
   std::stringstream ss(str);
   std::string item;
   while (std::getline(ss, item, delimeter))
   {
      tokens.push_back(item);
   }
}
 
static std::string numberToString(double num, int decimalPrecision)
{
   std::stringstream ss;
   ss << std::fixed << std::setprecision(decimalPrecision) << num;
   return ss.str();
}
 
//! Calculate the closing speed of two objects by their position and velocity vectors.
//! C = -((v1-v2)•(p1-p2)/|p1-p2|)
static double closingSpeed(const DtVector& p1, const DtVector& p2, const DtVector32& v1, const DtVector32& v2)
{
   DtVector positionDifference = p1 - p2;
   DtVector velocityDifference = DtVector32To64(v1 - v2);
   return -((velocityDifference).dotProduct(positionDifference)/sqrt(positionDifference.magnitudeSquared()));
}
 
static double headingAngleTo(const DtVector& geocentricObserverPosition, const DtVector& geocentricTargetPosition)
{
   DtGeodeticCoord geodeticObserverPosition;
   geodeticObserverPosition.setGeocentric(geocentricObserverPosition);
 
   DtDcm geocToTopo;
   DtLatLon_to_GeocToTopo(geodeticObserverPosition, geocToTopo);
 
   // Compute vector from observer to target (in geocentric coordinates)
   DtVector observerToTarget = geocentricTargetPosition -
      geocentricObserverPosition;
 
   // Transform to topographic coordinates 
   DtDcmVecMul(geocToTopo, observerToTarget, observerToTarget);
 
   // Compute heading from topographic observer to target vector
   // Heading is measured as positive rotation about topo-centric Z axis
   // constrain to 0->2pi
   double heading = atan2(observerToTarget[DtY], observerToTarget[DtX]);
 
   // Convert to current North units (magnetic or true North).
   makVrv::DtDisplayUnitsConverter converter = makVrv::DtDisplayUnitsSettingsManager::instance(makVre::DtPlayerStationApp::instance()->de()).converter();
   makArchives::DtDisplayUnitsSettingsRecord::NorthUnits northUnits = converter.currentNorthUnit(
      makVrv::DtSharedDisplayUnitsSettings::theApplicationDisplayUnitCollectionName,
      makVrv::DtSharedDisplayUnitsSettings::theHeadingDisplayUnitName);
 
   return DtModPerLo(converter.convertHeadingUnitNativeToDisplay(geocentricObserverPosition, heading, northUnits), 0, 360);
}
 
//! Returns the heading of an entity according to its world position and orientation.
static float entityHeading(const DtVector& worldPosition, const DtTaitBryan& worldOrientnation)
{
   return DtModPerLo(radToDeg(DtGetHeadingFromGeocentric(worldPosition, worldOrientnation)), 0, 360);
}
 
#pragma warning (pop)
 
//! \brief Returns what ever is greater, x or y of type T
template<typename T>
T maximum(T x,T y)
{
   return (x>y ? x:y);
}
 
//! \brief Returns the which ever is lesser, x or y of type T
template<typename T>
T minimum(T x,T y)
{
   return (x<y ? x:y);
}