exampleGimbalPlugin

Table of Contents

• Overview
• Expected Result
• Example details
• Building the Example
• Running the Example
• Example Source Files
• DtGimbalDriver.h
• DtGimbalDriver.cxx
• DtGimbalSensorOverlay.h
• DtGimbalSensorOverlay.cxx
• DtGimbalCompassOverlaySection.h
• DtGimbalCompassOverlaySection.cxx

Overview

Create a simulated gimbaled camera and attached an observer to it.

Expected Result

Gimbal Plugin Result

Example details

DtGimbalDriver looks for the UAV element created by DtExampleDriver and implements a gimbal attached to that plane at a specified offset. It shows how to use the DtGeoReference class to position and orient the gimbal using the plane's position and orientation; and how to find azimuth and elevation angles to a target in the gimbal's local coordinate system. It attaches the observer named "Observer 1" to the gimbal, and uses the azimuth and elevation angles determined to lock the observer onto the target location.

The example also creates a sensor overlay based on the overlay used with the VR-Forces Sensor Field Of View overlay. It shows how to create and update the display. It also demonstrates the mechanism for changing one of the overlay section creators (in this case, the compass display).

Building the Example

VR-Vantage includes pre-built versions of the example plug-in. To build it yourself, follow the instructions at Building VR-Vantage Examples, Applications, and Plug-ins.

Running the Example

This example is a plug-in. You can run it by running ./bin64/exampleGimbalPlugin_stealth.bat or ./bin64/exampleGimbalPlugin_stealth.sh (on Linux). For more information about running examples, please see Running Applications and Examples.

Example Source Files

• DtGimbalDriver.h
• DtGimbalDriver.cxx
• DtGimbalSensorOverlay.h
• DtGimbalSensorOverlay.cxx
• DtGimbalCompassOverlaySection.h
• DtGimbalCompassOverlaySection.cxx

  ---

DtGimbalDriver.h

/*****************************************************************************
 * Copyright (c) 2024 MAK Technologies, Inc.
 * All rights reserved.
 *****************************************************************************/


#pragma once

#include <vrvCore/DtDriver.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <string>


namespace makVrv
{
   class DtGeoReference;
   class DtSceneObjectAgent;
   class DtSceneObject;
}

class DtGeodeticCoord;
class DtGimbalSensorOverlay;

class DtGimbalDriver : public makVrv::DtDriver
{
public:

   DtGimbalDriver( makVrv::DtAgentManager& am );

   DtGimbalDriver() = delete;


   virtual ~DtGimbalDriver();


   virtual const std::string& className() const;

 protected:
   virtual bool onStart();

   virtual bool onStop();

   virtual bool onTick();

   virtual void attachObserverToEntity(const std::string& observerName, const std::string& entityName );

   virtual void slot_displayEngineAdded( const makVrv::DtDeRecord& igRecord );

   virtual bool initialize();

   virtual void slot_coordinateSystemChanged();

protected:
   makVrv::DtGeoReference* myPlaneGeoRef;
   makVrv::DtGeoReference* myGimbalGeoRef;
   makVrv::DtSceneObjectAgent* myGimbalSceneObjectAgent;
   makVrv::DtSceneObject* myPlaneSceneObject;
   makVrv::DtElementID myGimbalId;
   makVrv::DtSignalConnectionManager mySignalConnections;
   DtGeodeticCoord* myTargetLocation;
   makVrv::DtElementID myPlaneElementId;

   DtGimbalSensorOverlay* myGimbalSensorOverlay;
};

DtGimbalDriver.cxx

/*****************************************************************************
 * Copyright (c) 2024 MAK Technologies, Inc.
 * All rights reserved.
 *****************************************************************************/


#include "DtGimbalDriver.h"
#include "DtGimbalSensorOverlay.h"

#include <vrvCore/DtAgentManager.h>
#include <vrvCore/DtAgentUpdateResolverInterface.h>
#include <vrvCore/DtDataBank.h>
#include <vrvCore/DtDe.h>
#include <vrvCore/DtDeSharedState.h>
#include <vrvCore/DtDeSharedStateSignaler.h>
#include <vrvCore/DtDriverManager.h>
#include <vrvCore/DtElementAttributeManager.h>
#include <vrvCore/DtElementData.h>
#include <vrvCore/DtInputDriver.h>
#include <vrvCore/DtObserver.h>
#include <vrvCore/DtObserverMode.h>
#include <vrvCore/DtScene.h>
#include <vrvCore/DtSceneObject.h>
#include <vrvCore/DtSceneObjectUpdater.h>
#include <vrvCore/DtSceneObjectAgent.hpp>

#include <vrvUtil/coordUtils.h>
#include <vrvUtil/DtCoordinateSystem.h>
#include <vrvUtil/DtGeoReference.h>

#include <vlutil/vlUtil.h>

// Use the VR-Vantage namespace.
// All classes in VR-Vantage are in this namespace.
using namespace makVrv;

// Tower Roof Location on GroundDB-II
const double DtTargetLatitude = DtDeg2Rad( -0.00542 );
const double DtTargetLongitude = DtDeg2Rad( -0.00168 );
const double DtTargetAltitude = 25.00;

// Gimbal position on attached-to platform
const double DtGimbalForwardOffset = 2.0;
const double DtGimbalDownOffset = 2.5;
const double DtGimbalRightOffset = 0.;

// Window/channel to control (and draw the sensor overlay on)
const std::string DtWindowName = "Window 1";
const std::string DtChannelName = "Channel 1";

// Platform Entity Name; this is the correct name when using exampleDriverPlugin (when
// 'SIM_IS_SHIP' is not defined).  If using exampleDriver instead, change to "Entity From Facade"
const std::string DtPlatformName = "UAV 1";

// Gimbal Entity Name
const std::string DtGimbalName = "Gimbal";

// Observer attached to the Gimbal entity.  Note that this is the observer currently attached 
// to the window/channel named above (it could be looked up from the window/channel names, 
// but keeping the example simple)
const std::string DtObserverName = "Observer 1";

// String placed in the 'tracking mode' slot of the sensor overlay
const std::string DtSensorOverlayInfoString = "Example Gimbal";


DtGimbalDriver::DtGimbalDriver( DtAgentManager& am )
   : makVrv::DtDriver( am, "DtGimbalDriver" )
   , myPlaneGeoRef(nullptr)
   , myGimbalGeoRef(nullptr)
   , myGimbalSceneObjectAgent(nullptr)
   , myTargetLocation(nullptr)
   , myPlaneSceneObject(nullptr)
   , myGimbalId( 0 )
   , myGimbalSensorOverlay( nullptr )
{
   myTargetLocation = new DtGeodeticCoord( DtTargetLatitude, DtTargetLongitude, DtTargetAltitude,
      myAgentManager.de().sharedState().coordinateSystem().referenceEllipsoid() );

   mySignalConnections += DtDeSharedStateSignaler::instance( myAgentManager.de() )
      .signal_coordinateSystemChanged.connect( boost::bind(
         &DtGimbalDriver::slot_coordinateSystemChanged, this));
}

DtGimbalDriver::~DtGimbalDriver()
{
   DtGimbalDriver::onStop();
   if ( myGimbalSceneObjectAgent )
   {
      reportElementDestroyed( myGimbalId );
   }

   DtDELETE( myPlaneGeoRef );
   DtDELETE( myGimbalGeoRef );
   DtDELETE( myGimbalSceneObjectAgent );
   DtDELETE( myTargetLocation );
}

void DtGimbalDriver::slot_coordinateSystemChanged()
{
   DtDELETE( myTargetLocation );

   myTargetLocation = new DtGeodeticCoord( DtTargetLatitude, DtTargetLongitude, DtTargetAltitude,
     myAgentManager.de().sharedState().coordinateSystem().referenceEllipsoid() );
}

const std::string& DtGimbalDriver::className() const
{
   static std::string name = "DtGimbalDriver";
   return name;
}

bool DtGimbalDriver::initialize()
{
   DtDe& de = myAgentManager.de();

   // look up the plane from exampleDriver (or exampleDriverPlugin)
   // It has display name <DtPlatformName>
   bool found = false;

   // Iterate through all the elements
   DtElementData& elemData = de.dataBank().elementData();
   DtElementData::ElementEntryMap::const_iterator curIter = elemData.elements().begin();
   DtElementData::ElementEntryMap::const_iterator endIter = elemData.elements().end();
   for( ; curIter != endIter; ++curIter )
   {
      std::string entityName;

      if (elemData.attributeManager().getElementDisplayName(curIter->first, entityName) &&  entityName == DtPlatformName)
      {
         // Found it.  Look up the scene object id used to visualize this element 
         // in the 3D model set.  We can use that scene object to get the position
         // and orientation of the plane
         myPlaneElementId = curIter->first;
         DtElementData::SceneObjectIdList sceneObjectIds;
         elemData.getSceneObjectIds(myPlaneElementId, sceneObjectIds, DtModelSetId::Models3D );

         // getSceneObjectIds() can return multiple scene object ids if multiple model sets
         // are specified.  Since we only asked for the 3D model set scene object, 
         // sceneObjectIds.size() should be 1.
         // It *should* be one, but because ExampleDriverPlugin DtExampleSimEngine::init
         // adds a hatlinefacade to the element there are two scene objects on the element
         if ( sceneObjectIds.size() == 2 )
         {
            DtAgentUpdateResolverInterface* updater = agentManager().findUpdater( sceneObjectIds.front() );
            if(updater)
            {
               myPlaneSceneObject = updater->castObjectTypeFromUpdater<DtSceneObject>("DtSceneObject");
               found = true;
            }
         }
      }
   }

   // If we didn't find it, assume it hasn't been created yet. Return false, and we'll
   // try again next tick
   if (! found )
   {
      return false;
   }

   // We have the plane's scene object.  Now we can create GeoReferences for the 
   // plane and the Gimbal
   myPlaneGeoRef = new DtGeoReference( de.sharedState().coordinateSystem() );
   myGimbalGeoRef = new DtGeoReference( de.sharedState().coordinateSystem() );

   // We create a scene object (and associate it with an element) for the Gimbal so that 
   // our observer can be attached to it.  When an observer is attached to an element in
   // Mimic mode, it effectively uses that element's coordinate system; so attaching to
   // this Gimbal gives us an observer in Gimbal coordinates.  Note that no models are 
   // added to the scene object, so this element will be invisible (but if you had a 3D 
   // gimbal model you could create and add it here
   myGimbalSceneObjectAgent = DtSceneObjectAgent::create( myAgentManager );
   myGimbalSceneObjectAgent->setModelSet( DtModelSetId::Models3D );

   // Set up the element
   myGimbalId = myAgentManager.createNewUniqueId();
   myGimbalSceneObjectAgent->setElementID( myGimbalId );
   reportElementCreated( myGimbalId, 0, DtElementEntry::Entity );

   // Give the element a name that we can use to attach to it
   DtElementAttributeDisplayName* displayName = new DtElementAttributeDisplayName( DtGimbalName );
   reportElementAttribute( myGimbalId, displayName);
   DtElementAttributeDriverType* driverType = new DtElementAttributeDriverType( "Gimbal Driver");
   reportElementAttribute( myGimbalId, driverType );

   // Now set up the sensor overlay

   myGimbalSensorOverlay = new DtGimbalSensorOverlay(de);

   // Sensor View Data - only needs to be set once

   // Used only for getting data, e.g. heading/location of the sensor platform, for most of the sensor view overlay
   // Only needs to be set once
   myGimbalSensorOverlay->fovData().setHostId(myPlaneElementId);

   // Used only for rendering informational text and does not have an impact on the channel or observer
   // Only needs to be set once
   myGimbalSensorOverlay->fovData().setTrackingMode(DtSensorOverlayInfoString);

   // Used for determining how to size certain visuals in the overlay
   // Only needs to be set once
   myGimbalSensorOverlay->fovData().setXHalfAngle(0.33);
   myGimbalSensorOverlay->fovData().setYHalfAngle(0.587);

   // These are for determining the range to use for the elevation tape on the left side of the sensor view overlay
   // Only needs to be set once
   myGimbalSensorOverlay->fovData().setMinimumElevationAngle(-M_PI);
   myGimbalSensorOverlay->fovData().setMaximumElevationAngle(M_PI);

   // Used for determining how to size certain visuals in the overlay and for simulating the sensor's maximum zoom level.
   // Only needs to be set once
   myGimbalSensorOverlay->fovData().setMaximumZoomLevel(200000.0);

   return true;
}

bool DtGimbalDriver::onStart()
{
   return true;
}

bool DtGimbalDriver::onStop()
{
   return true;
}

bool DtGimbalDriver::onTick()
{
   if ( myGimbalSceneObjectAgent == nullptr)
   {
      if ( ! initialize() )
      {
         // Everything needed to initialize hasn't been discovered yet.  This is not a failure, it just
         // means we need to wait.
         return true;
      }

      // The plane was found. Attach to it.
      attachObserverToEntity( DtObserverName, DtGimbalName );

      if (myGimbalSensorOverlay != nullptr)
      {
         myGimbalSensorOverlay->initialize(DtObserverName, DtWindowName, DtChannelName);
      }
   }

   // Set up a GeoRef for the plane.  We use this to find the Gimbal position
   // and orientation for the Gimbal scene object (and Gimbal GeoRef)
   DtVector planePosition;
   DtTaitBryan planeOrientation;

   // Drivers are ticked early in the frame.  Entities are dead-reckoned later.
   // So at this point, we only have the position and orientation of where the entity
   // was last frame, not necessarily where it will be this frame.  However, we can
   // directly request that it update NOW rather than when all the other entities 
   // update.
   DtSceneObjectUpdater* updater = myPlaneSceneObject->findUpdater();
   if (updater)
   {
      if (updater->lastUpdateTime() < myAgentManager.de().simulationTime())
      {
         updater->update(myAgentManager.de().simulationTime());
      }
   }

   // Now we can get the entity's position and orientation for this frame.
   myPlaneSceneObject->getPosition( 0, planePosition );
   myPlaneSceneObject->getTopographicOrientation( 0, planeOrientation );
   myPlaneGeoRef->setLocationAndOrientation( DtLocalToGeodetic( planePosition,
      myAgentManager.de().sharedState().coordinateSystem() ), planeOrientation );

   // Find the position and orientation of the gimbal in geodetic coordinates, using
   // the GeoRef placed above;
   DtGeodeticCoord gimbalGeod;
   DtTaitBryan gimbalOri;
   myPlaneGeoRef->topoToGeodetic( 
      DtVector( DtGimbalForwardOffset, DtGimbalRightOffset, DtGimbalDownOffset), 
      DtTaitBryan(0., 0., 0.), 
      gimbalGeod,  gimbalOri );

   // The gimbal's georef is now positioned and oriented with the UAV.  But we want to point the gimbal
   // at the target (without any roll component) so starting with a 'level' gimbal will make that easier.
   gimbalOri = DtTaitBryan(0.0, 0.0, 0.0);

   // Set up the GeoRef for our Gimbal
   myGimbalGeoRef->setLocationAndOrientation( gimbalGeod, gimbalOri );

   // Position our gimbal scene object (this is what the observer is attached to)
   myGimbalSceneObjectAgent->setPosition( 0, DtGeodeticToLocal( gimbalGeod, 
      myAgentManager.de().sharedState().coordinateSystem() ) );

   // Get tower location in gimbal's topocentric system. (We don't need the tower's orientation)
   DtVector targetTopo;
   DtTaitBryan unused( 0., 0., 0. );
   myGimbalGeoRef->geodeticToTopo( *myTargetLocation, unused, targetTopo, unused );

   // find azimuth and elevation angles to our target
   double azimuthAngle = atan2( targetTopo[1], targetTopo[0] );
   double xyPlaneDistance = sqrt( targetTopo[0] * targetTopo[0] + targetTopo[1] * targetTopo[1] );
   double elevationAngle = DtDeg2Rad( 90. ) - atan2( xyPlaneDistance, -targetTopo[2] );

   // Set the gimbal scene object to point at the target
   myGimbalSceneObjectAgent->setTopographicOrientation(0, DtTaitBryan(azimuthAngle, elevationAngle, 0.));

   // Finally, update the sensor overlay
   if (myGimbalSensorOverlay != nullptr)
   {
      myGimbalSensorOverlay->setPlatformTopoOrientation(planeOrientation.psi());
      myGimbalSensorOverlay->setGimbalOrientation(azimuthAngle);
      myGimbalSensorOverlay->update();
   }

   return true;
}

void DtGimbalDriver::attachObserverToEntity(const std::string& observerName, const std::string& entityName )
{
   DtObserver* observer = myAgentManager.de().driverManager().inputDriver().findObserverByName(observerName);

   if ( observer )
   {
      // Start by getting the existing observer state record for this observer.
      // We can modify it and then set it back.  We use the observer record
      // mechanism because it will allow the observer to attach even if the 
      // plane hasn't been created yet (the observer will retry attaching when
      // an observer record is used until the attach succeeds
      makArchives::DtObserverStateRecord observerState;
      observer->getRecord( observerState );

      // Attach to the plane
      std::set<std::string> displayNames;
      displayNames.insert( entityName );
      observerState.setAttachedToDisplayNames( displayNames );

      // We want no offset
      observerState.setObserverOffsetVector( 0., 0., 0. ); 
      observerState.setObserverRotationOffset(0., 0., 0., 1.);

      // Get the observer settings record associated with this observer state record
      // so we can force the attach type to mimic
      makArchives::DtObserverSettingsRecord settingsRec = observerState.observerSettingsRecord();
      settingsRec.setAttachType(makArchives::DtObserverSettingsRecord::AttachTypeMimic);

      // Add the modified settings record back to the observer state record
      observerState.setObserverSettingsRecord( settingsRec );

      // Set a view magnification
      observerState.setViewMagnification( 100. );

      // ... and then add the observer state to the observer
      observer->setFromRecord( observerState );
   }
}

void DtGimbalDriver::slot_displayEngineAdded( const DtDeRecord& igRecord )
{
   stop();
   start();
}

DtGimbalSensorOverlay.h

/*****************************************************************************
 * Copyright (c) 2024 MAK Technologies, Inc.
 * All rights reserved.
 *****************************************************************************/


#pragma once

#include <vrvOsg/DtOsgSensorViewOverlay.h>
#include <vrvCore/DtSensorFieldOfViewData.h>

#include <vrvUtil/DtVirtualBaseClass.h>

namespace makVrv
{
   class DtOsgSensorViewCompassOverlaySection;
   class DtObserver;
}

class DtGimbalCompassOverlaySection;

class DtGimbalSensorOverlay
{
 
public:
   DtGimbalSensorOverlay(makVrv::DtDe& de);

   DtGimbalSensorOverlay() = delete;

   virtual ~DtGimbalSensorOverlay();

   virtual void initialize(const std::string& observerName, const std::string& windowName, const std::string& channelName);

   makVrv::DtSensorFieldOfViewData& fovData();

   virtual void update();

   virtual void setPlatformTopoOrientation(double ori);

   virtual void setGimbalOrientation(double ori);

protected:
   makVrv::DtDe& myDe;
   makVrv::DtOsgSensorViewOverlay* mySensorOverlayDrawer;
   makVrv::DtSensorFieldOfViewData myGimbalSensorViewData;
   std::string myObserverName;
   makVrv::DtObserver* myObserver;
   DtGimbalCompassOverlaySection* mySensorViewCompassOverlaySection;

};

DtGimbalSensorOverlay.cxx

/*****************************************************************************
 * Copyright (c) 2024 MAK Technologies, Inc.
 * All rights reserved.
 *****************************************************************************/

#include "DtGimbalSensorOverlay.h"
#include "DtGimbalCompassOverlaySection.h"

#include <vrvOsg/DtOsgSensorViewOverlay.h>
#include <vrvOsg/DtOsgSensorViewPitchOverlaySection.h>
#include <vrvOsg/DtOsgSensorViewReticleOverlaySection.h>
#include <vrvOsg/DtOsgSensorViewPlatformInfoOverlaySection.h>
#include <vrvOsg/DtOsgSensorViewDisplayInfoOverlaySection.h>
#include <vrvOsg/DtOsgSensorViewTargetInfoOverlaySection.h>
#include <vrvOsg/DtOsgSensorViewCrossHairOverlaySection.h>

#include <vrvOsg/DtOsgObserverObject.h>
#include <vrvOsg/DtOsgChannel.h>

#include <vrvCore/DtDe.h>
#include <vrvCore/DtDriverManager.h>
#include <vrvCore/DtInputDriver.h>
#include <vrvCore/DtObserver.h>
#include <vrvCore/DtDisplay.h>
#include <vrvCore/DtWindow.h>
#include <vrvCore/DtWindowManager.h>
#include <vrvCore/DtSensorViewOverlay.h>


#include <vector>


DtGimbalSensorOverlay::DtGimbalSensorOverlay(makVrv::DtDe& de)
   : myGimbalSensorViewData()
   , mySensorOverlayDrawer(nullptr)
   , mySensorViewCompassOverlaySection(nullptr)
   , myObserverName()
   , myObserver(nullptr)
   , myDe(de)
{
   // Register section creators on our own so we can specify our compass overlay creator instead of the default
   makVrv::DtOsgSensorViewOverlaySectionCreators sectionCreators;
   sectionCreators.push_back(new makVrv::DtOsgSensorViewCrossHairOverlaySectionCreator);
   sectionCreators.push_back(new makVrv::DtOsgSensorViewPlatformInfoOverlaySectionCreator);
   sectionCreators.push_back(new makVrv::DtOsgSensorViewTargetInfoOverlaySectionCreator);
   sectionCreators.push_back(new makVrv::DtOsgSensorViewDisplayInfoOverlaySectionCreator);
   sectionCreators.push_back(new makVrv::DtOsgSensorViewPitchOverlaySectionCreator);
   sectionCreators.push_back(new makVrv::DtOsgSensorViewReticleOverlaySectionCreator);
   sectionCreators.push_back(new DtGimbalCompassOverlaySectionCreator);
   makVrv::DtOsgSensorViewOverlayCreator::registerInstance(de, &sectionCreators);
}

DtGimbalSensorOverlay::~DtGimbalSensorOverlay()
{
   delete mySensorOverlayDrawer;
   mySensorOverlayDrawer = nullptr;
}

makVrv::DtSensorFieldOfViewData& DtGimbalSensorOverlay::fovData()
{
   return myGimbalSensorViewData;
}

void DtGimbalSensorOverlay::initialize(const std::string& observerName, const std::string& windowName, const std::string& channelName)
{
   myObserverName = observerName;
   myObserver = myDe.driverManager().inputDriver().findObserverByName(myObserverName);
   mySensorOverlayDrawer = dynamic_cast<makVrv::DtOsgSensorViewOverlay*>(makVrv::DtSensorViewOverlayCreator::instance(myDe).create(myDe));
   if (mySensorOverlayDrawer)
   {
      mySensorOverlayDrawer->initialize(windowName, channelName);

      // Once the drawer is created and initialized we can look up / cache a pointer to the DtOsgSensorViewCompassOverlaySection
      // which we will use to update the azimuth scale
      mySensorViewCompassOverlaySection = dynamic_cast<DtGimbalCompassOverlaySection*>(
         mySensorOverlayDrawer->findOverlaySection(makVrv::DtOsgSensorViewCompassOverlaySection::SectionName));

      if (mySensorViewCompassOverlaySection == nullptr)
      {
         DtWarn << "DtGimbalSensorOverlay::initialize: failed to find DtGimbalCompassOverlaySection" << std::endl;
      }
   }
}

void DtGimbalSensorOverlay::setPlatformTopoOrientation(double ori)
{
   mySensorViewCompassOverlaySection->setPlatformTopoOrientation(ori);
}

void DtGimbalSensorOverlay::setGimbalOrientation(double ori)
{
   mySensorViewCompassOverlaySection->setGimbalOrientation(ori);
}

void DtGimbalSensorOverlay::update()
{
   myGimbalSensorViewData.setZoomLevel(myObserver->viewMagnification());
   mySensorOverlayDrawer->update(myObserverName, myGimbalSensorViewData);
}

DtGimbalCompassOverlaySection.h

DtGimbalCompassOverlaySection.cxx

/*****************************************************************************
 * Copyright (c) 2024 MAK Technologies, Inc.
 * All rights reserved.
 *****************************************************************************/


#include "DtGimbalCompassOverlaySection.h"


#include <vrvCore/DtDe.h>
#include <vrvCore/DtSensorViewOverlay.h>

#include <matrix/vlMath.h>

DtGimbalCompassOverlaySection::DtGimbalCompassOverlaySection(makVrv::DtDe& de) 
   : DtOsgSensorViewCompassOverlaySection(de)
   , myPlatformOrientation(0.0)
   , myGimbalOrientation(0.0)
{
}

DtGimbalCompassOverlaySection::~DtGimbalCompassOverlaySection()
{
   //Intentional nop
}

void DtGimbalCompassOverlaySection::update(const makVrv::DtOsgObserverObject&, const makVrv::DtSensorFieldOfViewData&) 
{
   updateNorthIndicator(myGimbalOrientation);

   updateEntityHeading(myPlatformOrientation);

   double azimuthScale = DtRad2Deg(myGimbalOrientation) - DtRad2Deg(myPlatformOrientation);
   if (azimuthScale < -180.0)
   {
      azimuthScale += 360.0;
   }
   updateAzimuthScale(azimuthScale);
}

void DtGimbalCompassOverlaySection::setPlatformTopoOrientation(double ori)
{
   myPlatformOrientation = ori;
}

void DtGimbalCompassOverlaySection::setGimbalOrientation(double ori)
{
   myGimbalOrientation = ori;
}

makVrv::DtOsgSensorViewCompassOverlaySection* DtGimbalCompassOverlaySectionCreator::create(makVrv::DtDe& de)
{
   return new DtGimbalCompassOverlaySection(de);
}

makVrv::DtOsgSensorViewOverlaySectionCreator* DtGimbalCompassOverlaySectionCreator::clone() const
{
   return new DtGimbalCompassOverlaySectionCreator;
}

[<< Examples] [Home] [Top of Page]