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 DtLocalObjectManager;
class DtLocalObject;



class DtVrfCSVScenarioDescriptionImporterExporter : public DtExCSVScenarioDescriptionImporterExporter
{
public:
   DtVrfCSVScenarioDescriptionImporterExporter(DtSimulationServices* s, DtLocalObjectManager* mgr);
   DtVrfCSVScenarioDescriptionImporterExporter(const DtVrfCSVScenarioDescriptionImporterExporter&);

   virtual ~DtVrfCSVScenarioDescriptionImporterExporter() override;

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

   virtual DtScenarioDescriptionImporterExporter* clone() override;

   virtual bool importIntoSimulation(DtSimulationServices*) override;

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

protected:
   virtual bool isExportable(DtSimulationServices* mgr, const DtLocalObject* ref) const;
   virtual bool isExportableEnvironmental(DtSimulationServices* mgr, const DtLocalObject* ref) const;

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

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

   virtual bool complete() const override;

   virtual bool importOrganization(DtSimulationServices*);

   virtual bool importTacticalGraphics(DtSimulationServices*);

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

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

   virtual void createEntity(ObjectInformation*);

   virtual void createTacticalGraphic(ObjectInformation*);

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

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

   std::vector<ObjectInformation*> myOrganizationCreationOrder;

   DtSimulationServices* mySimulationServices;
   DtLocalObjectManager* myObjectManager;
};

Class

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

#include "vrfCSVScenarioDescriptionImporterExporter.h"

#include <vrfcore/simulationServices.h>
#include <vrfcore/createObjectServiceInterface.h>
#include <vrfobjcore/vrfObjectStateRepository.h>
#include <vrfobjcore/localObject.h>
#include <vrfobjcore/vrfLocalObjectCreateInformation.h>
#include <vrfutil/rwVectorIterator.h>
#include <vrfutil/predefinedEntityTypes.h>
#include <vrfobjcore/localObjectManager.h>
#include <vrfutil/objectIdentificationResolver.h>

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


DtVrfCSVScenarioDescriptionImporterExporter::DtVrfCSVScenarioDescriptionImporterExporter(DtSimulationServices* s, DtLocalObjectManager* mgr)
: mySimulationServices(s)
, myObjectManager(mgr)
{
}

DtVrfCSVScenarioDescriptionImporterExporter::DtVrfCSVScenarioDescriptionImporterExporter(const DtVrfCSVScenarioDescriptionImporterExporter& orig)
: mySimulationServices(orig.mySimulationServices)
, myObjectManager(orig.myObjectManager)
{
}

DtVrfCSVScenarioDescriptionImporterExporter::~DtVrfCSVScenarioDescriptionImporterExporter()
{
}

bool DtVrfCSVScenarioDescriptionImporterExporter::loadScenarioDescription(const DtFilename& file,
   const std::map<std::string, std::string>& importData,const DtMsdlHierarchyPropertyMappings& mappings)
{
   if (DtExCSVScenarioDescriptionImporterExporter::loadScenarioDescription(file, importData))
   {
      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(*this);
}

bool DtVrfCSVScenarioDescriptionImporterExporter::prepareOrganizationCreationOrder(DtSimulationServices* 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(DtSimulationServices* 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(DtSimulationServices* 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 (DtUUID::objectIdentificationResolver().hasMarkingText(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)
{
   DtVrfLocalObjectCreateInformation crt;
   DtString objectName = element->name;

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

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

   crt.setObjectType(element->type);
   crt.setObjectName(deconflictName(mySimulationServices, objectName, crt.objectType().kind()));

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

      while (iter != element->children.end())
      {
         uuids.push_back((*iter)->object->uuid());
         ++iter;
      }

      crt.addSubordinates(uuids);
   }

   element->object = myObjectManager->createAndInitVrfObject(crt);
}

void DtVrfCSVScenarioDescriptionImporterExporter::createTacticalGraphic(ObjectInformation* element)
{
   DtVrfLocalObjectCreateInformation crt;
   DtString objectName = element->name.c_str();
   DtEntityType object(element->type);

   crt.setObjectName(deconflictName(mySimulationServices, objectName, object.kind()));
   crt.setForceType((DtForceType)element->force);
   crt.setLabel(crt.objectName());
   crt.setCreateSubObjects(false);   
   crt.setOrganized(true);   
   
   crt.setObjectType(object);
   crt.setClosedFigure((object.kind() == 20) || (object.kind() == 18) || (object.kind() == 19));

   if (crt.objectType().kind() >= 17)
   {
      crt.setFillStyle(0);
   }

   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;
      }
      if (element->type.kind() == 20)
      {
         // Set the closedFigure flag to true for area objects.
         crt.setClosedFigure(true);
      }
      
   }
   crt.setOverlay(element->parent.c_str());

   element->object = myObjectManager->createAndInitVrfObject(crt);
}

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)
   {
      mySimulationServices->removeTickEntry(createObjectsCallback, this);
   }
}

bool DtVrfCSVScenarioDescriptionImporterExporter::importTacticalGraphics(DtSimulationServices* 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;
}

//[The importIntoSimulation function]
bool DtVrfCSVScenarioDescriptionImporterExporter::importIntoSimulation(DtSimulationServices* mgr)
{
   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;
   }

   mySimulationServices = mgr;

   myOrganizationCreationOrder.clear();

   importOrganization(mgr);
   importTacticalGraphics(mgr);

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

   return true;
}

bool DtVrfCSVScenarioDescriptionImporterExporter::isExportable(DtSimulationServices* mgr, const DtLocalObject* ref) const
{
   if (ref->isTopLevel() ||
       ref->entityType().matchPattern(DtGlobalWeatherObjectTypes) ||
       ref->entityType().matchPattern(DtGlobalPlanEntityType) ||
       ref->entityType().matchPattern(DtSyncMatrixEntityType)
      )
   {
      return false;
   }

   return (ref->isEntity() || ref->isUnit());
}

bool DtVrfCSVScenarioDescriptionImporterExporter::isExportableEnvironmental(DtSimulationServices* mgr, const DtLocalObject* ref) const
{
   if (ref->isTopLevel() ||
       ref->entityType().matchPattern(DtGlobalWeatherObjectTypes) ||
       ref->entityType().matchPattern(DtGlobalPlanEntityType) ||
       ref->entityType().matchPattern(DtSyncMatrixEntityType)
      )
   {
      return false;
   }

   return (!ref->isEntity() && !ref->isUnit());
}

//[The importIntoSimulation function]

bool DtVrfCSVScenarioDescriptionImporterExporter::exportOrganization(DtSimulationServices* mgr,
   const std::map<std::string, std::string>& exportData, const DtMsdlHierarchyPropertyMappings&)
{
   DtSimObjectMap localObjects(myObjectManager->localObjectMap());
   DtSimObjectMap::const_iterator iter = localObjects.begin();
   DtSimObjectMap::const_iterator end = localObjects.end();

   while (iter != end)
   {
      const DtLocalObject* object = iter->second;

      if (isExportable(mgr, object))
      {
         ObjectInformation* information = new ObjectInformation;

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

         if (object->superior().isValid() && !object->superior()->isTopLevel())
         {
            information->parent = object->superior()->uuid().uuidString();
         }

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

      ++iter;
   }

   return true;
}

bool DtVrfCSVScenarioDescriptionImporterExporter::exportTacticalGraphics(DtSimulationServices* mgr,
   const std::map<std::string, std::string>& exportData, const DtMsdlHierarchyPropertyMappings&)
{
   DtSimObjectMap localObjects(myObjectManager->localObjectMap());
   DtSimObjectMap::const_iterator iter = localObjects.begin();
   DtSimObjectMap::const_iterator end = localObjects.end();

   while (iter != end)
   {
      const DtLocalObject* object = iter->second;

      if (isExportableEnvironmental(mgr, object))
      {
         ObjectInformation* information = new ObjectInformation;

         information->name = object->objectName();
         information->type = object->objectType();
         information->uuid = object->uuid();
         information->force = object->forceType();
         information->parent = object->nextFrameOverlay();

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

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

      ++iter;
   }

   return true;
}

//[The importFromSimulation function]
bool DtVrfCSVScenarioDescriptionImporterExporter::importFromSimulation(DtSimulationServices* mgr,
   const std::map<std::string, std::string>& exportData, const DtMsdlHierarchyPropertyMappings& m)
{
   exportOrganization(mgr, exportData, m);
   exportTacticalGraphics(mgr, exportData, m);

   return true;
}
//[The importFromSimulation function]

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