Implement loading from ArmarXObjects in class segment

source/RobotAPI/libraries/armem_objects/server/class/Segment.cpp

@@ -6,6 +6,8 @@
 #include <ArmarXCore/core/Component.h>
 #include <ArmarXCore/core/time/TimeUtil.h>
 
+#include <filesystem>
+
 
 namespace armarx::armem::server::obj::clazz
 {
@@ -13,12 +15,17 @@ namespace armarx::armem::server::obj::clazz
     Segment::Segment(armem::server::MemoryToIceAdapter& memoryToIceAdapter) :
         iceMemory(memoryToIceAdapter)
     {
+        Logging::setTag("ClassSegment");
     }
 
     void Segment::defineProperties(armarx::PropertyDefinitionsPtr defs, const std::string& prefix)
     {
         defs->optional(p.coreSegmentName, prefix + "CoreSegmentName", "Name of the object clazz core segment.");
         defs->optional(p.maxHistorySize, prefix + "MaxHistorySize", "Maximal size of object poses history (-1 for infinite).");
+
+        defs->optional(p.objectsPackage, prefix + "ObjectsPackgage", "Name of the objects package to load from.");
+        defs->optional(p.loadFromObjectsPackage, prefix + "LoadFromObjectsPackage",
+                       "If true, load the objects from the objects package on startup.");
     }
 
     void Segment::init()
@@ -27,6 +34,11 @@ namespace armarx::armem::server::obj::clazz
 
         coreSegment = &iceMemory.memory->addCoreSegment(p.coreSegmentName, arondto::ObjectClass::toInitialAronType());
         coreSegment->setMaxHistorySize(p.maxHistorySize);
+
+        if (p.loadFromObjectsPackage)
+        {
+            loadByObjectFinder(p.objectsPackage);
+        }
     }
 
 
@@ -42,6 +54,91 @@ namespace armarx::armem::server::obj::clazz
         return *coreSegment;
     }
 
+    void Segment::loadByObjectFinder(const std::string& objectsPackage)
+    {
+        loadByObjectFinder(ObjectFinder(objectsPackage));
+    }
+
+    void Segment::loadByObjectFinder(const ObjectFinder& finder)
+    {
+        this->objectFinder = finder;
+        loadByObjectFinder();
+    }
+
+    void Segment::loadByObjectFinder()
+    {
+        const Time now = TimeUtil::GetTime();
+
+        const bool checkPaths = false;
+        std::vector<ObjectInfo> infos = objectFinder.findAllObjects(checkPaths);
+
+        const MemoryID providerID = coreSegment->id().withProviderSegmentName(objectFinder.getPackageName());
+        coreSegment->addProviderSegment(providerID.providerSegmentName);
+
+        ARMARX_INFO << "Loading up to " << infos.size() << " object classes from '"
+                    << objectFinder.getPackageName() << "' ...";
+        Commit commit;
+        for (ObjectInfo& info : infos)
+        {
+            info.setLogError(false);
+
+            EntityUpdate& update = commit.updates.emplace_back();
+            update.entityID = providerID.withEntityName(info.id().str());
+            update.timeArrived = update.timeCreated = update.timeSent = now;
+
+            arondto::ObjectClass objectClass = objectClassFromInfo(info);
+            update.instancesData =
+            {
+                objectClass.toAron()
+            };
+        }
+        ARMARX_INFO << "Loaded " << commit.updates.size() << " object classes from '"
+                    << objectFinder.getPackageName() << "'.";
+        iceMemory.commit(commit);
+    }
+
+    arondto::ObjectClass Segment::objectClassFromInfo(const ObjectInfo& info) const
+    {
+        namespace fs = std::filesystem;
+
+        arondto::ObjectClass data;
+
+        toAron(data.id, info.id());
+
+        if (fs::is_regular_file(info.simoxXML().absolutePath))
+        {
+            toAron(data.simoxXmlPath, info.simoxXML());
+        }
+        if (fs::is_regular_file(info.wavefrontObj().absolutePath))
+        {
+            toAron(data.meshObjPath, info.wavefrontObj());
+        }
+        if (fs::is_regular_file(info.file(".wrl").absolutePath))
+        {
+            toAron(data.meshWrlPath, info.file(".wrl"));
+        }
+
+        if (auto aabb = info.loadAABB())
+        {
+            toAron(data.aabb, aabb.value());
+        }
+        if (auto oobb = info.loadOOBB())
+        {
+            toAron(data.oobb, oobb.value());
+        }
+
+        if (auto recogNames = info.loadRecognizedNames())
+        {
+            data.names.recognizedNames = recogNames.value();
+        }
+        if (auto spokenNames = info.loadSpokenNames())
+        {
+            data.names.spokenNames = spokenNames.value();
+        }
+
+        return data;
+    }
+
 
     void Segment::RemoteGui::setup(const Segment& data)
     {

source/RobotAPI/libraries/armem_objects/server/class/Segment.h

@@ -31,10 +31,18 @@ namespace armarx::armem::server::obj::clazz
         void defineProperties(armarx::PropertyDefinitionsPtr defs, const std::string& prefix = "");
         void init();
 
+        void loadByObjectFinder(const std::string& objectsPackage);
+        void loadByObjectFinder(const ObjectFinder& finder);
+        void loadByObjectFinder();
+
+
         armem::CoreSegment& getCoreSegment();
         const armem::CoreSegment& getCoreSegment() const;
 
 
+        arondto::ObjectClass objectClassFromInfo(const ObjectInfo& info) const;
+
+
     private:
 
         armem::server::MemoryToIceAdapter& iceMemory;
@@ -47,6 +55,9 @@ namespace armarx::armem::server::obj::clazz
         {
             std::string coreSegmentName = "Class";
             long maxHistorySize = -1;
+
+            std::string objectsPackage = ObjectFinder::DefaultObjectsPackageName;
+            bool loadFromObjectsPackage = true;
         };
         Properties p;
 

source/RobotAPI/libraries/armem_objects/server/instance/Segment.cpp

@@ -25,6 +25,8 @@ namespace armarx::armem::server::obj::instance
     Segment::Segment(armem::server::MemoryToIceAdapter& memoryToIceAdapter) :
         iceMemory(memoryToIceAdapter)
     {
+        Logging::setTag("InstanceSegment");
+
         oobbCache.setFetchFn([this](const ObjectID & id) -> std::optional<simox::OrientedBoxf>
         {
             // Try to get OOBB from repository.