Class that will import from or export to a comma delimited file and put information into the scenario

Classes

Header

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


#pragma once

#include "csvScenarioDescriptionImporterExporter.h"


class DtVrfCSVScenarioDescriptionImporterExporter : public DtCSVScenarioDescriptionImporterExporter
{
public:
   DtVrfCSVScenarioDescriptionImporterExporter();

   virtual ~DtVrfCSVScenarioDescriptionImporterExporter();

   virtual bool loadScenarioDescription(const DtFilename& file, const std::map<std::string, std::string>& importData,
      const DtMsdlHierarchyPropertyMappings&);

   virtual DtScenarioDescriptionImporterExporter* clone();

   virtual bool importIntoSimulation(DtSimManager*);

   virtual bool importFromSimulation(DtSimManager*, const std::map<std::string, std::string>& exportData,
      const DtMsdlHierarchyPropertyMappings&);

protected:
   virtual bool exportOrganization(DtSimManager*, const std::map<std::string, std::string>& exportData,
      const DtMsdlHierarchyPropertyMappings&);

   virtual bool exportTacticalGraphics(DtSimManager*, const std::map<std::string, std::string>& exportData,
      const DtMsdlHierarchyPropertyMappings&);

   virtual bool complete() const;

   virtual bool importOrganization(DtSimManager*);

   virtual bool importTacticalGraphics(DtSimManager*);

   virtual bool prepareOrganizationCreationOrder(DtSimManager* mgr, ObjectInformation* element);

   static void createObjectsCallback(void*);
   virtual void processCreateObjects();

   virtual void createEntity(ObjectInformation*);

   virtual void createTacticalGraphic(ObjectInformation*);

   virtual DtString deconflictName(DtSimManager*, const DtString&, int kind);

protected:
   std::vector<ObjectInformation*> myOrganizedHierarchy;

   std::vector<ObjectInformation*> myOrganizationCreationOrder;

   DtSimManager* mySimManager;
};

Class

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


#include "vrfCSVScenarioDescriptionImporterExporter.h"

#include <vrfobjcore/vrfObjectManager.h>
#include <vrfobjcore/organizationManager.h>
#include <vrfobjcore/organizationManagerNode.h>
#include <vrfcore/simManager.h>
#include <vrfobjcore/vrfObjectManager.h>
#include <vrfobjcore/vrfObjectStateRepository.h>
#include <vrfutil/rwVectorIterator.h>
#include <vrfmsgs/ifCreateVrfObject.h>

#include <matrix/vlMath.h>
#include <matrix/geodeticCoord.h>

DtVrfCSVScenarioDescriptionImporterExporter::DtVrfCSVScenarioDescriptionImporterExporter()
{
}

DtVrfCSVScenarioDescriptionImporterExporter::~DtVrfCSVScenarioDescriptionImporterExporter()
{
}

bool DtVrfCSVScenarioDescriptionImporterExporter::loadScenarioDescription(const DtFilename& file,
   const std::map<std::string, std::string>& importData,const DtMsdlHierarchyPropertyMappings& mappings)
{
   if (DtCSVScenarioDescriptionImporterExporter::loadScenarioDescription(file, importData, mappings))
   {
      ObjectMap::iterator iter = myObjectMap.begin();

      while (iter != myObjectMap.end())
      {
         if (!iter->second->parent.length() || (iter->second->type.kind() >= 16))
         {
            myOrganizedHierarchy.push_back(iter->second);
         }

         ++iter;
      }

      return true;
   }

   return false;
}

DtScenarioDescriptionImporterExporter* DtVrfCSVScenarioDescriptionImporterExporter::clone()
{
   return new DtVrfCSVScenarioDescriptionImporterExporter;
}

bool DtVrfCSVScenarioDescriptionImporterExporter::prepareOrganizationCreationOrder(DtSimManager* mgr, ObjectInformation* element)
{
   if (element->children.size())
   {
      std::vector<ObjectInformation*>::iterator iter = element->children.begin();

      while (iter != element->children.end())
      {
         if (!prepareOrganizationCreationOrder(mgr, *iter))
         {
            return false;
         }

         ++iter;
      }

      myOrganizationCreationOrder.push_back(element);
      myOrganizationCreationOrder.push_back(0);

      return true;
   }

   myOrganizationCreationOrder.push_back(element);

   return true;
}

bool DtVrfCSVScenarioDescriptionImporterExporter::importOrganization(DtSimManager* mgr)
{
   std::vector<ObjectInformation*>::iterator iter = myOrganizedHierarchy.begin();
   int consecutiveCreate = 0;

   while (iter != myOrganizedHierarchy.end())
   {
      if (!(*iter)->children.size())
      {
         if ((*iter)->type.kind() < 16)
         {
            myOrganizationCreationOrder.push_back(*iter);

            if (++consecutiveCreate == 20)
            {
               consecutiveCreate = 0;
               myOrganizationCreationOrder.push_back(0);
            }
         }
      }
      else
      {
         consecutiveCreate = 0;

         if (!prepareOrganizationCreationOrder(mgr, *iter))
         {
            return false;
         }
      }

      ++iter;
   }

   return true;
}

void DtVrfCSVScenarioDescriptionImporterExporter::createObjectsCallback(void* usr)
{
   static_cast<DtVrfCSVScenarioDescriptionImporterExporter*>(usr)->processCreateObjects();
}

DtString DtVrfCSVScenarioDescriptionImporterExporter::deconflictName(DtSimManager* mgr, const DtString& name, int kind)
{
   int count = 1;
   DtString baseName = name;
   DtString newName = name;

   if ((kind < 11) && (name.length() > 11))
   {
      baseName = DtString(name.c_str(), 11);
      newName = baseName;
   }

   while (mgr->vrfObjectManager()->lookupObjectByName(newName))
   {
      int maxLength = 31;

      if ((kind < 11) && (name.length() > 9))
      {
         maxLength = 12;

         baseName = DtString(name.c_str(), 9);
      }

      newName = DtString(count++) + "_"  + baseName;

      if (newName.length() >= maxLength)
      {
         newName = DtString(newName, maxLength - 1);
      }
   }

   return newName;
}

void DtVrfCSVScenarioDescriptionImporterExporter::createEntity(ObjectInformation* element)
{
   DtIfCreateVrfObject crt;
   DtString objectName = element->name;

   crt.setForceType((DtForceType)element->force);

   crt.setPosition(element->points[0]);
   crt.setCreateSubObjects(false);   
   crt.setAddToOrganization(true);   

   crt.setObjectType(DtObjectType((element->type.kind() == 11 ? 3 : 1), element->type));
   crt.setObjectName(deconflictName(mySimManager, objectName, crt.objectType().kind()));

   element->object = mySimManager->vrfObjectManager()->createAndInitVrfObject(&crt);

   element->object->tick();

   if (element->children.size())
   {
      std::vector<ObjectInformation*>::iterator iter = element->children.begin();
      DtList names;

      while (iter != element->children.end())
      {
         names.add((void*)&(*iter)->object->objectName());
         ++iter;
      }

      mySimManager->vrfObjectManager()->addSubordinatesToAggregate(element->object, &names, DtDisaggregated);
   }
}

void DtVrfCSVScenarioDescriptionImporterExporter::createTacticalGraphic(ObjectInformation* element)
{
   DtIfCreateVrfObject crt;
   DtString objectName = element->name.c_str();
   DtObjectType object(1, element->type);

   crt.setObjectName(deconflictName(mySimManager, objectName, object.kind()));
   crt.setForceType((DtForceType)element->force);
   crt.setObjectLabel(crt.objectName());
   crt.setCreateSubObjects(false);   
   crt.setAddToOrganization(true);   
   
   crt.setObjectType(object);

   if (element->points.size() == 1)
   {
      crt.setPosition(element->points[0]);
   }
   else
   {
      std::vector<DtVector>::const_iterator iter = element->points.begin();

      while (iter != element->points.end())
      {
         crt.addVertex(*iter);
         ++iter;
      }
   }

   element->object = mySimManager->vrfObjectManager()->createAndInitVrfObject(&crt);

   if (element->object)
   {
      element->object->setOverlayParent(element->parent.c_str());
   }
}

void DtVrfCSVScenarioDescriptionImporterExporter::processCreateObjects()
{
   int numCreated = 0;

   while (numCreated < myOrganizationCreationOrder.size())
   {
      ObjectInformation* element = myOrganizationCreationOrder[numCreated++];

      if (element->type.kind() >= 16)
      {
         createTacticalGraphic(element);
      }
      else
      {
         createEntity(element);
      }

      if (numCreated == myOrganizationCreationOrder.size())
      {
         break;
      }
      else if (myOrganizationCreationOrder[numCreated] == 0)
      {
         numCreated++;
         break;
      }
   }

   if (numCreated == (myOrganizationCreationOrder.size() - 1))
   {
      myOrganizationCreationOrder.clear();
   }
   else
   {
      myOrganizationCreationOrder.erase(myOrganizationCreationOrder.begin(), myOrganizationCreationOrder.begin() + numCreated);
   }

   if (myOrganizationCreationOrder.size() == 0)
   {
      mySimManager->removeTickEntry(createObjectsCallback, this);
   }
}

bool DtVrfCSVScenarioDescriptionImporterExporter::importTacticalGraphics(DtSimManager* mgr)
{
   std::vector<ObjectInformation*>::iterator iter = myOrganizedHierarchy.begin();
   int createdCount = 0;

   while (iter != myOrganizedHierarchy.end())
   {
      if ((*iter)->type.kind() >= 16)
      {
         myOrganizationCreationOrder.push_back(*iter);

         if (++createdCount == 10)
         {
            createdCount = 0;
            myOrganizationCreationOrder.push_back(0);
         }
      }

      ++iter;
   }

   return true;
}

bool DtVrfCSVScenarioDescriptionImporterExporter::importIntoSimulation(DtSimManager* mgr)
{
   mySimManager = mgr;

   myOrganizationCreationOrder.clear();

   importOrganization(mgr);
   importTacticalGraphics(mgr);

   if (myOrganizationCreationOrder.size())
   {
      mgr->addTickEntry(createObjectsCallback, this);
   }

   return true;
}

bool DtVrfCSVScenarioDescriptionImporterExporter::exportOrganization(DtSimManager* mgr,
   const std::map<std::string, std::string>& exportData, const DtMsdlHierarchyPropertyMappings&)
{
   const DtOrganizationManager* orgMgr = mgr->vrfObjectManager()->organizationManager();

   DtListItem* item = orgMgr->nodes().list()->first();

   while (item)
   {
      DtOrganizationManagerNode* node = static_cast<DtOrganizationManagerNode*>(item->data());
      DtVrfObject* object = mgr->vrfObjectManager()->lookupVrfObject(node->objectId());

      if (object && !DtOrganizationManager::isTopLevelEntity(object->objectType()))
      {
         DtEntityIdentifier id = orgMgr->superior(object->objectIdentifier());

         ObjectInformation* information = new ObjectInformation;

         information->name = object->objectName();
         information->type = object->objectType();
         information->force = object->vrfState()->forceType();

         if (id != DtEntityIdentifier())
         {
            DtVrfObject* parent = mgr->vrfObjectManager()->lookupVrfObject(id);

            if (parent && !DtOrganizationManager::isTopLevelEntity(parent->objectType()))
            {
               information->parent = parent->objectName();
            }
         }

         information->points.push_back(object->vrfState()->worldPosition());
         myObjectMap[information->name] = information;
      }

      item = item->next();
   }

   return true;
}

bool DtVrfCSVScenarioDescriptionImporterExporter::exportTacticalGraphics(DtSimManager* mgr,
   const std::map<std::string, std::string>& exportData, const DtMsdlHierarchyPropertyMappings&)
{
   DtSimObjectIterator iter = mgr->vrfObjectManager()->vrfIterator();
   const DtVrfObject* object = iter.first();

   while (object)
   {
      if ((object->objectType().kind() >= 16) && (object->objectType().kind() <= 20))
      {
         ObjectInformation* information = new ObjectInformation;

         information->name = object->objectName();
         information->type = object->objectType();
         information->force = object->vrfState()->forceType();
         information->parent = object->overlayParent();

         DtRwVectorIterator iterator = object->vrfState()->worldVertexIterator();
         DtRwVector* vecPtr = NULL;

         for(vecPtr = iterator.first(); vecPtr; vecPtr = iterator.next())
         {
            DtVector* vec = dynamic_cast<DtVector*>(vecPtr);
            information->points.push_back(*vec);
         }
         
         myObjectMap[information->name] = information;
      }

      object = iter.next();
   }

   return true;
}

bool DtVrfCSVScenarioDescriptionImporterExporter::importFromSimulation(DtSimManager* mgr,
   const std::map<std::string, std::string>& exportData, const DtMsdlHierarchyPropertyMappings& m)
{
   exportOrganization(mgr, exportData, m);
   exportTacticalGraphics(mgr, exportData, m);

   return true;
}

bool DtVrfCSVScenarioDescriptionImporterExporter::complete() const
{
   return (myOrganizationCreationOrder.size() == 0);
}