exampleSymbolFacade1

This example demonstrates how to add symbols to the scene in a PVD application.

The example creates a DtSymbolFacade for creating and modifying symbols and uses a driver for scene setup and management of the created symbols. A toolbar is also created to signal the creation of new symbols. For more information on creating a driver, see exampleDriver .

The DtSymbolFacade class encapsulates the model agents used to display the symbol and provides an interface for communicating with them.

The DtSymbolFacade's constructor creates the model agents the facade will use to display symbols.

      DtSymbolFacade::DtSymbolFacade(
            DtAgentManagerInterface& sceneInterface, DtElementID id )
         : myElementId( id )
         , mySceneObjectAgent( DtSceneObjectAgent::create(sceneInterface) )
         , myProjectedWidgetModelAgent( DtProjectedWidgetModelAgent::create(sceneInterface) )
         , myWidgetLabelAgent( DtWidgetLabelAgent::create(sceneInterface) )
      {
         initialize();
      }

The initialize method then configures the model agents.

      void DtSymbolFacade::initialize()
      {
         // Make sure the agents were fully created.
         if ( ! mySceneObjectAgent ) DtTHROW_NEW( DtCorruptedState, "Unable to create scene object agent." );
         if ( ! myProjectedWidgetModelAgent ) DtTHROW_NEW( DtCorruptedState, "Unable to create projected widget model agent." );
         if ( ! myWidgetLabelAgent ) DtTHROW_NEW( DtCorruptedState, "Unable to create widget label agent." );

         // Initialize the scene object
         mySceneObjectAgent->setModelSet( 5 );  // PVD
         mySceneObjectAgent->setElementID( myElementId );
         mySceneObjectAgent->addModel( myProjectedWidgetModelAgent, DtStateVisualizer::EntityVisualizerType );

         // Initialize the label
         myWidgetLabelAgent->setOverlay( DtOverlayManager::ModelSet_2D_Icons_Overlay );
         myWidgetLabelAgent->setBackgroundImage( "$(DATA_DIR)/images/ArrowCircle.png" );
         myWidgetLabelAgent->setColor( 0.8f, 0.8f, 0.8f, 1.0f );
         myWidgetLabelAgent->setSize( 32, 32 );

         // Add the label to the projected widget model.
         myProjectedWidgetModelAgent->addWidget( myWidgetLabelAgent );
      }

The symbol facade provides accessors for the component model agents and a method for positioning the symbol. The facade also has a method that returns the symbol's element type. This value indicates whether the symbol is an entity, a prop, or a terrain (among other things). For this example we'll consider the symbol to be an entity.

      DtElementEntry::ElementType DtSymbolFacade::elementType()
      {
         return DtElementEntry::Entity;
      }

Symbols are created using a button on the GUI's toolbar. This button (DtAddSymbolItem) picks a random spot on the terrain and tells the driver (DtExampleSymbolDriver) to create a symbol at that location.

      void DtAddSymbolItem::on_triggered()
      {
         // Keep track of how many symbols have been created.
         static int numSymbolsCreated = 0;

         // Give the symbol a unique name.
         DtString symbolName( "Symbol #" );
         symbolName += DtString(numSymbolsCreated);

         // Put the symbol somewhere random on the makland terrain.
         double rand_x = 4000.0*((double)rand())/RAND_MAX;
         double rand_y = 4000.0*((double)rand())/RAND_MAX;
         double rand_z = 4000.0*((double)rand())/RAND_MAX;
         DtVector location( rand_x, rand_y, rand_z );

         // Get the driver and create the symbol
         DtExampleSymbolDriver* symbolDriver = (DtExampleSymbolDriver*)
            myDe.driverManager().findDriver( "DtExampleSymbolDriver" );
         symbolDriver->createSymbol( symbolName.string(), location );
         ++numSymbolsCreated;
      }

The driver creates the symbol by instantiating a new DtSymbolFacade, creating a unique ID for the symbol, and signaling that the new 'element' (the symbol) has been created. The driver also stores the symbol for later use and provides a default color and size. Once the symbol has been created, the driver associates the symbol's name with its elementId and positions it in the scene.

         // Create symbol.
         DtElementID elementId = myAgentManager.createNewUniqueId();
         DtSymbolFacade* symbol = new DtSymbolFacade( myAgentManager, elementId );
         symbol->widgetLabelAgent().setColor( 0.8f, 0.8f, 0.8f, 1.0f );
         symbol->widgetLabelAgent().setSize( 32, 32 );

         // Store the symbol in the driver's symbol map.
         mySymbolFacades.insert( std::make_pair(elementId,symbol) );

         // Report that the symbol was created and report its name.
         // These commands report to VR-Vantage that a new object has been created
         // and that it should be managed as an object that may be visualized in various ways.
         reportElementCreated( elementId, 0, DtSymbolFacade::elementType() );
         reportElementAttribute( elementId, new DtElementAttributeDisplayName(name) );

         // Position the symbol.
         positionSymbol( symbol, pos );

• DtSymbolDriverToolbar1.h
• DtSymbolDriverToolbar1.cxx
• DtSymbolFacade1.h
• DtSymbolFacade1.cxx
• DtExampleSymbolDriver1.h
• DtExampleSymbolDriver1.cxx
• exampleSymbolFacade1.cxx
• exampleSymbolFacade1.h

[Home] [Top of Page] [exampleSymbolFacade2 >>]

---

DtSymbolDriverToolbar1.h

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


#pragma once

#include <exampleSymbolFacade1.h>

#include <vrvCoreQt/DtToolbar.h>
#include <vrvCoreQt/DtMenuItem.h>

namespace makVrv
{
   class DtDe;
}

namespace makVrv
{

   namespace exampleSymbolFacade1
   {

      class DT_DLL_EXAMPLESYMBOLFACADE1 DtSymbolDriverToolbar
         : public makVrv::DtToolbar
      {
      public:

         DtSymbolDriverToolbar( makVrv::DtDe& );

         virtual ~DtSymbolDriverToolbar();

         virtual QToolBar* createToolbar( makVrv::DtDe&, QWidget* parent );

      };


      class DT_DLL_EXAMPLESYMBOLFACADE1 DtAddSymbolItem : public makVrv::DtMenuItem
      {
      public:

         DtAddSymbolItem( makVrv::DtDe& de );

         virtual ~DtAddSymbolItem();

         virtual QAction* createAction( makVrv::DtDe&, QWidget* parent );

         virtual void on_triggered();

      protected:

         makVrv::DtDe& myDe;

      };

   }
}

DtSymbolDriverToolbar1.cxx

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


#include <DtSymbolDriverToolbar1.h>

#include <DtExampleSymbolDriver1.h>

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

#include <QtWidgets/QToolBar>
#include <QtWidgets/QAction>

#include <matrix/vlVector.h>

#include <time.h>
#include <math.h>

namespace makVrv
{

   namespace exampleSymbolFacade1
   {

      DtSymbolDriverToolbar::DtSymbolDriverToolbar( DtDe& de )
         : DtToolbar( de, "DtSymbolDriverToolbar" )
      {
      }

      DtSymbolDriverToolbar::~DtSymbolDriverToolbar()
      {
      }

      QToolBar* DtSymbolDriverToolbar::createToolbar( DtDe&, QWidget* parent )
      {
         QToolBar* bar = new QToolBar( parent );
         bar->setWindowTitle( QObject::tr("Symbol Driver Toolbar") );
         bar->setObjectName( QObject::tr("Symbol Driver Toolbar") );
         return bar;
      }


      DtAddSymbolItem::DtAddSymbolItem( DtDe& de )
         : DtMenuItem( "DtAddSymbolItem" )
         , myDe( de )
      {
         // Seed the random number generator.
         srand( time(NULL ) );
      }

      DtAddSymbolItem::~DtAddSymbolItem()
      {
      }

      QAction* DtAddSymbolItem::createAction( DtDe&, QWidget* parent )
      {
         QAction* act = new QAction( parent );
         act->setText( DtMenuItem::tr("&Add new symbol...") );
         act->setToolTip( DtMenuItem::tr("Create a new symbol...") );
         act->setIcon( QIcon(QObject::tr("../data/Icons/UtilityAdd.svg")) );
         return act;
      }

      void DtAddSymbolItem::on_triggered()
      {
         // Keep track of how many symbols have been created.
         static int numSymbolsCreated = 0;

         // Give the symbol a unique name.
         DtString symbolName( "Symbol #" );
         symbolName += DtString(numSymbolsCreated);

         // Put the symbol somewhere random on the makland terrain.
         double rand_x = 4000.0*((double)rand())/RAND_MAX;
         double rand_y = 4000.0*((double)rand())/RAND_MAX;
         double rand_z = 4000.0*((double)rand())/RAND_MAX;
         DtVector location( rand_x, rand_y, rand_z );

         // Get the driver and create the symbol
         DtExampleSymbolDriver* symbolDriver = (DtExampleSymbolDriver*)
            myDe.driverManager().findDriver( "DtExampleSymbolDriver" );
         symbolDriver->createSymbol( symbolName.string(), location );
         ++numSymbolsCreated;
      }

   }
}

DtSymbolFacade1.h

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


#pragma once

#include <exampleSymbolFacade1.h>

#include <vrvCore/DtElementEntry.h>
#include <vrvCore/DtUniqueID.h>

#include <boost/signal.hpp>

#include <matrix/vlVector.h>

namespace makVrv
{
   class DtSceneObjectAgent;
   class DtWidgetLabelAgent;
   class DtAgentManagerInterface;
   class DtProjectedWidgetModelAgent;
}

namespace makVrv
{

   namespace exampleSymbolFacade1
   {

      class DT_DLL_EXAMPLESYMBOLFACADE1 DtSymbolFacade
      {
      public:

         DtSymbolFacade( makVrv::DtAgentManagerInterface& sceneInterface,
            makVrv::DtElementID id );

         virtual ~DtSymbolFacade();



         virtual makVrv::DtElementID elementId() const;

         virtual makVrv::DtWidgetLabelAgent& widgetLabelAgent();

         virtual void setPosition( const DtVector& pos );



         static makVrv::DtElementEntry::ElementType elementType();

      protected:

         // Sets up the sceneobject and widget agents for displaying the symbol.
         // Non-virtual (Called from CTOR).
         void initialize();

      protected:

         makVrv::DtElementID myElementId;

         makVrv::DtSceneObjectAgent* mySceneObjectAgent;
         makVrv::DtProjectedWidgetModelAgent* myProjectedWidgetModelAgent;
         makVrv::DtWidgetLabelAgent* myWidgetLabelAgent;

      };

   }
}

DtSymbolFacade1.cxx

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


#include <DtSymbolFacade1.h>

#include <vrvCore/DtProjectedWidgetModelAgent.hpp>
#include <vrvCore/DtObserverModeManager.h>
#include <vrvCore/DtWidgetLabelAgent.hpp>
#include <vrvCore/DtSceneObjectAgent.hpp>

#include <vrvCore/DtStateVisualizer.h>
#include <vrvCore/DtOverlayManager.h>
#include <vrvCore/DtWidgetSignaler.h>
#include <vrvCore/DtSceneObject.h>

#include <vlutil/vlUtil.h>

namespace makVrv
{

   namespace exampleSymbolFacade1
   {

      DtSymbolFacade::DtSymbolFacade(
            DtAgentManagerInterface& sceneInterface, DtElementID id )
         : myElementId( id )
         , mySceneObjectAgent( DtSceneObjectAgent::create(sceneInterface) )
         , myProjectedWidgetModelAgent( DtProjectedWidgetModelAgent::create(sceneInterface) )
         , myWidgetLabelAgent( DtWidgetLabelAgent::create(sceneInterface) )
      {
         initialize();
      }

      DtSymbolFacade::~DtSymbolFacade()
      {
         // Remove the widget label agent from the PWMA and delete it.
         myProjectedWidgetModelAgent->removeWidget( myWidgetLabelAgent );
         DtDELETE( myWidgetLabelAgent );

         // Remove the PWMA from the scene object and delete it.
         mySceneObjectAgent->removeModel( myProjectedWidgetModelAgent );
         DtDELETE( myProjectedWidgetModelAgent );

         // Delete the scene object now that everything's been removed from it.
         DtDELETE( mySceneObjectAgent );
      }

      void DtSymbolFacade::initialize()
      {
         // Make sure the agents were fully created.
         if ( ! mySceneObjectAgent ) DtTHROW_NEW( DtCorruptedState, "Unable to create scene object agent." );
         if ( ! myProjectedWidgetModelAgent ) DtTHROW_NEW( DtCorruptedState, "Unable to create projected widget model agent." );
         if ( ! myWidgetLabelAgent ) DtTHROW_NEW( DtCorruptedState, "Unable to create widget label agent." );

         // Initialize the scene object
         mySceneObjectAgent->setModelSet( 5 );  // PVD
         mySceneObjectAgent->setElementID( myElementId );
         mySceneObjectAgent->addModel( myProjectedWidgetModelAgent, DtStateVisualizer::EntityVisualizerType );

         // Initialize the label
         myWidgetLabelAgent->setOverlay( DtOverlayManager::ModelSet_2D_Icons_Overlay );
         myWidgetLabelAgent->setBackgroundImage( "$(DATA_DIR)/images/ArrowCircle.png" );
         myWidgetLabelAgent->setColor( 0.8f, 0.8f, 0.8f, 1.0f );
         myWidgetLabelAgent->setSize( 32, 32 );

         // Add the label to the projected widget model.
         myProjectedWidgetModelAgent->addWidget( myWidgetLabelAgent );
      }

      DtUniqueID DtSymbolFacade::elementId() const
      {
         return myElementId;
      }

      DtWidgetLabelAgent& DtSymbolFacade::widgetLabelAgent()
      {
         return *myWidgetLabelAgent;
      }

      void DtSymbolFacade::setPosition( const DtVector& pos )
      {
         mySceneObjectAgent->setPosition( 0, pos );
      }

      // This is a static method that can be used to query what type of element
      // DtSymbolFacades are. The returned value indicates whether the symbol
      // is an entity, a prop, or a terrain (among other things).
      // For this example we'll consider the symbol to be an entity.
      DtElementEntry::ElementType DtSymbolFacade::elementType()
      {
         return DtElementEntry::Entity;
      }

   }
}

DtExampleSymbolDriver1.h

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


#pragma once

#include <exampleSymbolFacade1.h>

#include <vrvCore/DtDriver.h>

#include <vrvCore/DtSelectionManager.h>

#include <boost/unordered_set.hpp>

#include <matrix/vlVector.h>

namespace makVrv
{

   namespace exampleSymbolFacade1
   {

      class DtSymbolFacade;

      class DT_DLL_EXAMPLESYMBOLFACADE1 DtExampleSymbolDriver
         : public makVrv::DtDriver
      {
      public:

         DtExampleSymbolDriver( makVrv::DtAgentManager& am );

         virtual ~DtExampleSymbolDriver();



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

         virtual bool onStart();

         virtual bool onStop();

         virtual bool onTick();




         virtual DtSymbolFacade* createSymbol( const std::string& name,
            const DtVector& pos );

         virtual DtSymbolFacade* findSymbol( makVrv::DtElementID id );


      protected:

         virtual void positionSymbol( DtSymbolFacade* symbol, const DtVector& pos );

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

      protected:

         typedef boost::unordered_map<makVrv::DtElementID,DtSymbolFacade*> SymbolFacadeMap;

         SymbolFacadeMap mySymbolFacades;

      };

   }
}

DtExampleSymbolDriver1.cxx

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


#include <DtExampleSymbolDriver1.h>

#include <vrvCore/DtDe.h>
#include <vrvCore/DtScene.h>
#include <vrvCore/DtAgentManager.h>
#include <vrvCore/DtDeSharedState.h>
#include <vrvCore/DtSelectionManager.h>
#include <vrvCore/DtElementAttributes.h>

#include <vrvCore/DtWidgetAgent.hpp>
#include <vrvCore/DtWidgetLabelAgent.hpp>
#include <vrvCore/DtSceneObjectAgent.hpp>
#include <vrvCore/DtProjectedWidgetModelAgent.hpp>

#include <vrvUtil/DtCoordinateConverter.h>
#include <vrvUtil/DtCoordinateSystem.h>

#include <matrix/vlVector.h>

#include <DtSymbolFacade1.h>

namespace makVrv
{

   namespace exampleSymbolFacade1
   {

      DtExampleSymbolDriver::DtExampleSymbolDriver( DtAgentManager& am )
         : makVrv::DtDriver( am, "DtExampleSymbolDriver" )
      {
      }

      DtExampleSymbolDriver::~DtExampleSymbolDriver()
      {
         DtExampleSymbolDriver::onStop();
      }

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

      bool DtExampleSymbolDriver::onStart()
      {
         // Load the Makland programatically.
         DtScene& sceneDriver = myAgentManager.de().scene();
         std::string maklandPath = myAgentManager.de().dePathConfiguration().userPath();
         maklandPath += "/terrains/Makland.mtf";
         sceneDriver.loadTerrain( maklandPath );
         return true;
      }

      bool DtExampleSymbolDriver::onStop()
      {
         // Delete all created facades.
         SymbolFacadeMap::iterator i = mySymbolFacades.begin();
         SymbolFacadeMap::iterator e = mySymbolFacades.end();
         for ( ; i != e; ++i )
         {
            delete i->second;
         }

         // Clear the list of facades.
         mySymbolFacades.clear();
         return true;
      }

      bool DtExampleSymbolDriver::onTick()
      {
         return true;
      }

      DtSymbolFacade* DtExampleSymbolDriver::createSymbol(
         const std::string& name, const DtVector& pos )
      {
         // Create symbol.
         DtElementID elementId = myAgentManager.createNewUniqueId();
         DtSymbolFacade* symbol = new DtSymbolFacade( myAgentManager, elementId );
         symbol->widgetLabelAgent().setColor( 0.8f, 0.8f, 0.8f, 1.0f );
         symbol->widgetLabelAgent().setSize( 32, 32 );

         // Store the symbol in the driver's symbol map.
         mySymbolFacades.insert( std::make_pair(elementId,symbol) );

         // Report that the symbol was created and report its name.
         // These commands report to VR-Vantage that a new object has been created
         // and that it should be managed as an object that may be visualized in various ways.
         reportElementCreated( elementId, 0, DtSymbolFacade::elementType() );
         reportElementAttribute( elementId, new DtElementAttributeDisplayName(name) );

         // Position the symbol.
         positionSymbol( symbol, pos );
         return symbol;
      }

      DtSymbolFacade* DtExampleSymbolDriver::findSymbol( DtElementID symbolId )
      {
         SymbolFacadeMap::iterator itr = mySymbolFacades.find( symbolId );
         if ( itr != mySymbolFacades.end() )
            return itr->second;
         return NULL;
      }

      void DtExampleSymbolDriver::positionSymbol(
         DtSymbolFacade* symbol, const DtVector& pos )
      {
         // Initialize the coordinate converter with the position.
         DtCoordinateConverter* coordConverter =
            myAgentManager.de().sharedState().coordinateSystem().converter();
         coordConverter->setupTopoFrame( pos );

         // Convert the position (from ENU) to our local database (CIG) coordinate system.
         DtVector position;
         coordConverter->enuToCig_coordTrans( pos, position );
         symbol->setPosition( position );
      }

      void DtExampleSymbolDriver::slot_displayEngineAdded( const DtDeRecord& igRecord )
      {
         // When a new display engine is connected to our driver, the driver
         // must be re-started in order to ensure the terrain and all symbols
         // are properly loaded on all connected De's.
         stop();
         start();
      }

   }
}

exampleSymbolFacade1.cxx

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


#include <exampleSymbolFacade1.h>

#include <vrvCoreQt/DtQtToolbarAssembler.h>
#include <vrvCoreQt/vrvCoreQt.h>
#include <vrvCoreQt/DtQtDeMainWindow.h>

#include <vrvCore/DtVrvApplication.h>
#include <vrvCore/DtDriverManager.h>
#include <vrvCore/DtToolbarPath.h>
#include <vrvCore/DtDe.h>
#include <vrvCore/DtDeMainWindow.h>

#include <DtExampleSymbolDriver1.h>
#include <DtSymbolDriverToolbar1.h>

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

using namespace makVrv::exampleSymbolFacade1;

bool initDeModule( DtDe* de )
{
   // Setup the plug-in.
   init( *de );
   return true;
}

void init( DtDe& de )
{
   // Ensure that init only gets called once
   // (not strictly necessary here, but this is good practice in general)
   DT_DE_INIT_ONCE( de );

   // Make sure that the vrvCoreQt and vrvOsgEarthQt module are init'ed.
   vrvCoreQt::init(de);

   // Don't show the startup dialog for selecting a terrain.
   DtDeMainWindow& mw = DtDeMainWindowProvider::instance(de).igMainWindow();
   DtQtDeMainWindow& mainWindow = dynamic_cast<DtQtDeMainWindow&>(mw);
   mainWindow.hideStartupDialog();

   //Add example menu and example page item.
   DtVrvApplication* igApp = DtVrvApplication::findFromDe(de);
   if ( igApp )
   {
      // Register the toolbar and MenuItems so they can be created where they're placed.
      DtQtToolbarAssembler::instance(de).registerToolbar( new DtSymbolDriverToolbar(de) );
      DtQtMenuAssembler::instance(de).registerMenu( new DtAddSymbolItem(de) );

      // Add the button to the toolbar.
      igApp->masterModeToolbarConfiguration().addToolbarPath(
         DtToolbarPath::toolbar("DtSymbolDriverToolbar").item("DtAddSymbolItem") );
   }

   // We only want to create the driver if we are running in master mode.
   if ( de.isInMasterMode() )
   {
      // The accessory must be created after the DE's initialization is
      // finished, to make sure all the objects it uses exist.
      de.signal_postInitialize.connect( boost::bind(
         &installDriver, boost::ref(de) ) );
   }
}

void installDriver( DtDe& de )
{
   // Create DtExampleDriver.
   DtExampleSymbolDriver* driver = new DtExampleSymbolDriver( de.agentManager() );

   // The driver is now owned by the display engine. Do not delete it.
   de.driverManager().addDriver( driver );

   // Start the driver, creating the agent.
   de.driverManager().startDriver( driver );
}

exampleSymbolFacade1.h

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


#pragma once

// Plugin export macro.
#ifdef _WIN32
#  ifdef EXAMPLESYMBOLFACADE1_EXPORTS
#     define DT_DLL_EXAMPLESYMBOLFACADE1 __declspec ( dllexport )
#  else
#     define DT_DLL_EXAMPLESYMBOLFACADE1 __declspec ( dllimport )
#  endif
#else
#  define DT_DLL_EXAMPLESYMBOLFACADE1
#endif

// Declare & export the plugin initialization function (bool initDeModule(DtDe* de))
#define DT_DE_PLUGIN_EXPORT_MACRO DT_DLL_EXAMPLESYMBOLFACADE1
#include <vrvCore/exportPlugin.h>

// Plugin initialization methods.
DT_DLL_EXAMPLESYMBOLFACADE1 bool initDeModule( makVrv::DtDe* de );
DT_DLL_EXAMPLESYMBOLFACADE1 void init( makVrv::DtDe& de );
DT_DLL_EXAMPLESYMBOLFACADE1 void installDriver( makVrv::DtDe& de );