Segment.cpp

Go to the documentation of this file.

#include "Segment.h"
 
#include <algorithm>
#include <cstddef>
#include <cstdlib>
#include <filesystem>
#include <ios>
#include <map>
#include <optional>
#include <set>
#include <sstream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
#include <sys/inotify.h>
#include <sys/types.h>
#include <unistd.h>
 
#include <Eigen/Dense>
#include <Eigen/Geometry>
 
#include <range/v3/algorithm/all_of.hpp>
#include <range/v3/algorithm/contains.hpp>
#include <range/v3/range/conversion.hpp>
#include <range/v3/view/filter.hpp>
#include <range/v3/view/transform.hpp>
 
#include <SimoxUtility/algorithm/get_map_keys_values.h>
#include <SimoxUtility/algorithm/string.h>
#include <SimoxUtility/json.h>
#include <SimoxUtility/math/pose/pose.h>
#include <SimoxUtility/shapes/OrientedBox.h>
#include <VirtualRobot/Nodes/RobotNode.h>
#include <VirtualRobot/RobotNodeSet.h>
#include <VirtualRobot/VirtualRobot.h>
#include <VirtualRobot/XML/RobotIO.h>
 
#include <ArmarXCore/core/PackagePath.h>
#include <ArmarXCore/core/application/properties/PropertyDefinitionContainer.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/ice_conversions/ice_conversions_templates.h> // IWYU pragma: keep
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/services/tasks/TaskUtil.h>
#include <ArmarXCore/core/time/Clock.h>
#include <ArmarXCore/core/time/DateTime.h>
#include <ArmarXCore/core/time/ice_conversions.h> // IWYU pragma: keep
#include <ArmarXCore/core/util/StringHelpers.h>
 
#include "ArmarXGui/libraries/RemoteGui/Client/Widgets.h"
 
#include "RobotAPI/components/ArViz/Client/Client.h"
#include "RobotAPI/libraries/ArmarXObjects/ObjectID.h"
#include "RobotAPI/libraries/ArmarXObjects/ObjectInfo.h"
#include "RobotAPI/libraries/ArmarXObjects/ObjectPose.h"
#include "RobotAPI/libraries/ArmarXObjects/aron_conversions/objpose.h"
#include "RobotAPI/libraries/ArmarXObjects/forward_declarations.h"
#include "RobotAPI/libraries/armem/core/Commit.h"
#include "RobotAPI/libraries/armem/core/MemoryID.h"
#include "RobotAPI/libraries/armem/core/error/ArMemError.h"
#include "RobotAPI/libraries/armem/core/forward_declarations.h"
#include "RobotAPI/libraries/armem/server/segment/SpecializedCoreSegment.h"
#include "RobotAPI/libraries/armem/server/wm/memory_definitions.h"
#include "RobotAPI/libraries/armem_objects/types.h"
#include "RobotAPI/libraries/armem_robot_state/types.h"
#include "RobotAPI/libraries/core/Pose.h"
#include <RobotAPI/interface/objectpose/ObjectPoseProvider.h>
#include <RobotAPI/interface/objectpose/ObjectPoseStorageInterface.h>
#include <RobotAPI/interface/objectpose/object_pose_types.h>
#include <RobotAPI/libraries/ArmarXObjects/ObjectFinder.h>
#include <RobotAPI/libraries/ArmarXObjects/Scene.h>
#include <RobotAPI/libraries/ArmarXObjects/aron/ObjectPose.aron.generated.h>
#include <RobotAPI/libraries/ArmarXObjects/ice_conversions.h>
#include <RobotAPI/libraries/ArmarXObjects/json_conversions.h> // IWYU pragma: keep
#include <RobotAPI/libraries/armem/core/aron_conversions.h>
#include <RobotAPI/libraries/armem/server/MemoryToIceAdapter.h>
#include <RobotAPI/libraries/armem/util/util.h>
#include <RobotAPI/libraries/armem_objects/aron/ObjectClass.aron.generated.h>
#include <RobotAPI/libraries/armem_objects/aron/ObjectInstance.aron.generated.h>
#include <RobotAPI/libraries/armem_objects/aron_conversions.h>
#include <RobotAPI/libraries/armem_objects/client/articulated_object/aron_conversions.h>
#include <RobotAPI/libraries/armem_objects/memory_ids.h>
#include <RobotAPI/libraries/core/FramedPose.h>
 
#include <linux/limits.h>
 
namespace armarx::armem::server::obj::instance
{
 
 
    void
    Segment::Calibration::defineProperties(PropertyDefinitionsPtr defs, const std::string& prefix)
    {
        defs->optional(robotName,
                       prefix + "robotName",
                       "Name of robot whose note can be calibrated.\n"
                       "If not given, the 'fallbackName' is used.");
        defs->optional(robotNode, prefix + "robotNode", "Robot node which can be calibrated.");
        defs->optional(offset, prefix + "offset", "Offset for the node to be calibrated.");
    }
 
    Segment::Segment(armem::server::MemoryToIceAdapter& memoryToIceAdapter) :
        SpecializedCoreSegment(memoryToIceAdapter,
                               objects::instaceSegmentID.coreSegmentName,
                               arondto::ObjectInstance::ToAronType(),
                               64)
    {
        oobbCache.setFetchFn(
            [this](const ObjectID& id) -> std::optional<simox::OrientedBoxf>
            {
                // Try to get OOBB from repository.
                if (std::optional<ObjectInfo> objectInfo = objectFinder.findObject(id))
                {
                    try
                    {
                        objectInfo->setLogError(false); // Don't log missing files
                        return objectInfo->loadOOBB();
                    }
                    catch (const std::ios_base::failure& e)
                    {
                        // Give up - no OOBB information.
                        ARMARX_WARNING << "Could not get OOBB of object " << id << ".\n- "
                                       << e.what();
                        return std::nullopt;
                    }
                }
                else
                {
                    return std::nullopt;
                }
            });
 
        classNameToDatasetCache.setFetchFn(
            [this](const std::string& className)
            {
                std::optional<ObjectInfo> objectInfo = objectFinder.findObject(className);
                return objectInfo ? objectInfo->dataset() : "";
            });
    }
 
    Segment::~Segment()
    {
    }
 
    void
    Segment::defineProperties(armarx::PropertyDefinitionsPtr defs, const std::string& prefix)
    {
        SpecializedCoreSegment::defineProperties(defs, prefix);
 
        defs->optional(
            p.discardSnapshotsWhileAttached,
            prefix + "DiscardSnapshotsWhileAttached",
            "If true, no new snapshots are stored while an object is attached to a robot node.\n"
            "If false, new snapshots are stored, but the attachment is kept in the new snapshots.");
 
        defs->optional(p.separateProviderForAttachedObjects,
                       prefix + "separateProviderForAttachedObjects",
                       "If true, attached objects are stored with a separate provider (see "
                       "`attachedProviderName`).");
 
        defs->optional(p.attachedProviderName,
                       prefix + "attachedProviderName",
                       "If `separateProviderForAttachedObjects` is true, this provider will be "
                       "used for attached objects. Otherwise, attached objects will be stored with "
                       "the same provider as non-attached objects.");
 
        defs->optional(p.automaticallyDetachObjectsOnHandOpening,
                       prefix + "AutomaticallyDetachObjectsOnHandOpening",
                       "If true, the hand state will be monitored and objects will be detached "
                       "automatically when the hand opens.");
 
        defs->optional(p.automaticallyDetachPositionThreshold,
                       prefix + "AutomaticallyDetachPositionThreshold",
                       "See `AutomaticallyDetachObjectsOnHandOpening`. Internal threshold to "
                       "determine whether hand is opened.");
 
        defs->optional(robots.fallbackName,
                       prefix + "robots.FallbackName",
                       "Robot name to use as fallback if the robot name is not specified "
                       "in a provided object pose.");
 
        defs->optional(
            p.sceneSnapshotsPackage,
            prefix + "scene.10_Package",
            "ArmarX package containing the scene snapshots.\n"
            "Scene snapshots are expected to be located in Package/data/Package/Scenes/*.json.");
        defs->optional(p.sceneSnapshotsDirectory,
                       prefix + "scene.11_Directory",
                       "Directory in Package/data/Package/ containing the scene snapshots.");
 
        std::vector<std::string> sceneSnapshotToLoadDescription = {
            "Scene(s) to load on startup.",
            "Specify multiple scenes in a ; separated list.",
            "Each entry must be one of the following:",
            "(1) A scene file in 'Package/scenes/' (with or without '.json' extension), "
            "e.g. 'MyScene', 'MyScene.json'",
            "(2) A path to a scene file relative to 'Package/scenes/' (with or without '.json' "
            "extension), "
            "e.g. 'path/to/MyScene', 'path/to/MyScene.json'",
            "(3) An ArmarX data path to a scene file, e.g. 'Package/scenes/path/to/MyScene.json'",
        };
        defs->optional(p.sceneSnapshotsToLoad,
                       prefix + "scene.12_SnapshotToLoad",
                       simox::alg::join(sceneSnapshotToLoadDescription, " \n"));
 
        defs->optional(p.autoReloadSceneSnapshotsOnFileChange,
                       prefix + "scene.13_autoReloadSceneSnapshotsOnFileChange");
 
        decay.defineProperties(defs, prefix + "decay.");
    }
 
    std::vector<std::string>
    Segment::Properties::getSceneSnapshotsToLoad() const
    {
        if (sceneSnapshotsToLoad.empty())
        {
            return {};
        }
        bool trim = true;
        return simox::alg::split(sceneSnapshotsToLoad, ";", trim);
    }
 
    void
    Segment::init()
    {
        SpecializedCoreSegment::init();
 
        const std::vector<std::string> scenes = p.getSceneSnapshotsToLoad();
        for (const std::string& scene : scenes)
        {
            const bool lockMemory = false;
            commitSceneSnapshotFromFilename(scene, lockMemory);
        }
 
        robots.setTag(Logging::tag);
 
        if (p.autoReloadSceneSnapshotsOnFileChange)
        {
 
            int inotifyFd;
 
            // init inotify
            {
 
                inotifyFd = inotify_init();
                if (inotifyFd == -1)
                {
                    ARMARX_WARNING << "inotify_init failed";
                }
            }
 
            std::map<int, std::string> wds;
 
            // set up inotify watchers
            for (const auto& scene : scenes)
            {
                if (std::optional<std::filesystem::path> path = resolveSceneFilepath(scene))
                {
                    auto wd = inotify_add_watch(inotifyFd, path.value().c_str(), IN_MODIFY);
                    if (wd == -1)
                    {
                        ARMARX_WARNING << "inotify_add_watch for scene: " << scene << "` failed.";
                    }
 
                    ARMARX_INFO << "inotify_add_watch for scene: " << scene << "` added.";
                    wds.emplace(wd, scene);
                }
                else
                {
                    ARMARX_WARNING << "Faild to add file watcher for scene: `" << scene << "`.";
                }
            }
 
            ARMARX_INFO << "Set up inotify events.";
 
            fileWatcherTask = new SimpleRunningTask<>(
                [this, inotifyFd, wds]()
                {
                    constexpr std::size_t BUF_LEN = (10 * (sizeof(inotify_event) + NAME_MAX + 1));
                    char buf[BUF_LEN];
 
 
                    for (;;)
                    {
                        ssize_t numRead;
 
                        numRead = read(inotifyFd, buf, BUF_LEN);
                        if (numRead == 0)
                        {
                            ARMARX_WARNING << "read() from inotify fd returned 0!";
                        }
 
                        if (numRead == -1)
                        {
                            ARMARX_VERBOSE << "read";
                        }
 
                        ARMARX_DEBUG << VAROUT(numRead);
 
                        for (char* p = buf; p < buf + numRead;)
                        {
                            auto* event = reinterpret_cast<inotify_event*>(p);
 
                            const auto& scene = wds.at(event->wd);
                            ARMARX_INFO << "File changed: " << VAROUT(scene);
 
                            p += sizeof(struct inotify_event) + event->len;
 
                            const bool lockMemory = true;
                            commitSceneSnapshotFromFilename(scene, lockMemory);
                        }
                    }
                });
 
            fileWatcherTask->start();
        }
    }
 
    void
    Segment::connect(viz::Client arviz)
    {
        (void)arviz;
        // ARMARX_INFO << "ArticulatedObjectVisu";
        // this->visu = std::make_unique<ArticulatedObjectVisu>(arviz, *this);
        // visu->init();
    }
 
    Segment::CommitStats
    Segment::commitObjectPoses(const std::string& providerName,
                               const objpose::data::ProvidedObjectPoseSeq& providedPoses,
                               const Calibration& calibration,
                               std::optional<armem::Time> discardUpdatesUntil)
    {
        CommitStats stats;
 
        // Build new poses.
        objpose::ObjectPoseSeq newObjectPoses;
        stats.numUpdated = 0;
 
        // timestamp used to reduce the rpc calls for robot sync
        Time robotSyncTimestamp = Time::Invalid();
 
        for (const objpose::data::ProvidedObjectPose& provided : providedPoses)
        {
            const Time timestamp = armarx::fromIce<Time>(provided.timestamp);
 
            // Check whether we have an old snapshot for this object.
            std::optional<objpose::ObjectPose> previousPose;
            const wm::Entity* entity =
                findObjectEntity(armarx::fromIce(provided.objectID), providerName);
            if (entity)
            {
                const arondto::ObjectInstance data = getLatestInstanceData(*entity);
 
                previousPose = objpose::ObjectPose();
                fromAron(data, *previousPose);
            }
 
            bool discard = false;
            if (discardUpdatesUntil && timestamp < discardUpdatesUntil.value())
            {
                // Dicard updates temporarily (e.g. due to head movement).
                discard = true;
            }
            else if (previousPose)
            {
                if (p.discardSnapshotsWhileAttached && previousPose->attachment)
                {
                    // Discard update due to active attachemnt.
                    discard = true;
                }
                else if (timestamp == previousPose->timestamp)
                {
                    // Discard update as it is not new.
                    discard = true;
                }
            }
 
            if (discard)
            {
                continue;
            }
 
            // Update the entity.
            stats.numUpdated++;
 
            VirtualRobot::RobotPtr robot = robots.get(provided.robotName, provided.providerName);
            if (not robot)
            {
                ARMARX_INFO << deactivateSpam(1) << "Failed to retrieve robot `"
                            << provided.robotName << "`.";
            }
 
            // robot may be null!
 
            bool synchronized = false;
 
            // Update the robot to obtain correct local -> global transformation
            if (robot and robotSyncTimestamp != timestamp)
            {
                synchronized = robots.reader->synchronizeRobot(*robot, timestamp);
                if (not synchronized)
                {
                    ARMARX_INFO << deactivateSpam(5) << "Failed to synchronize robot to timestamp "
                                << timestamp << " of provided object pose (" << provided.objectID
                                << "). This is " << (Clock::Now() - timestamp).toSecondsDouble()
                                << " seconds in the past.";
                }
 
                robotSyncTimestamp = timestamp;
 
                // Apply calibration offset after synchronizing the robot.
                {
                    if (calibration.offset != 0 and robot->hasRobotNode(calibration.robotNode))
                    {
                        VirtualRobot::RobotNodePtr robotNode =
                            robot->getRobotNode(calibration.robotNode);
 
                        float value = robotNode->getJointValue();
                        float newValue = value + calibration.offset;
 
                        /*
                             * If newValue is out of the joint's limits, then the calibration would be ignored.
                             * In that case, we expand the joint value limits of the local robot model to allow
                             * for the calibrated value.
                             * As this is just for perception (and not for controlling the robot), this should be fine^TM.
                             */
                        VirtualRobot::RobotNode::JointLimits limits = robotNode->getJointLimits();
                        bool limitsChanged = false;
                        if (newValue < limits.low)
                        {
                            limits.low = newValue;
                            limitsChanged = true;
                        }
                        if (newValue > limits.high)
                        {
                            limits.high = newValue;
                            limitsChanged = true;
                        }
                        if (limitsChanged)
                        {
                            robotNode->setJointLimits(limits.low, limits.high);
                        }
 
                        robotNode->setJointValue(newValue);
                    }
                }
            }
            else if (robot and timestamp == robotSyncTimestamp)
            {
                synchronized = true;
            }
 
            if (not synchronized)
            {
                /*
                 * We know nothing about the current robot configuration. So the behaviour of the
                 * following code is the same as if we have no robot model at all.
                 */
                ARMARX_INFO << deactivateSpam(5)
                            << "Robot could not be synchronized; discarding robot";
                robot = nullptr;
            }
 
            objpose::ObjectPose& newPose = newObjectPoses.emplace_back();
            if (provided.objectPoseFrame.empty())
            {
                objpose::data::ProvidedObjectPose copy = provided;
                copy.objectPoseFrame = armarx::GlobalFrame;
                newPose.fromProvidedPose(copy, robot); // robot == nullptr is OK.
            }
            else
            {
                newPose.fromProvidedPose(provided, robot); // robot == nullptr is OK.
            }
 
            if (previousPose && previousPose->attachment)
            {
                // Keep current attachment.
                ARMARX_CHECK(!p.discardSnapshotsWhileAttached);
                newPose.attachment = previousPose->attachment;
            }
 
            if (newPose.objectID.dataset().empty())
            {
                // Try to find the data set.
                const std::string dataset =
                    classNameToDatasetCache.get(newPose.objectID.className());
                if (!dataset.empty())
                {
                    newPose.objectID = {
                        dataset, newPose.objectID.className(), newPose.objectID.instanceName()};
                }
            }
            if (!provided.localOOBB)
            {
                // Try to load oobb from disk.
                newPose.localOOBB = getObjectOOBB(newPose.objectID);
            }
        }
 
        commitObjectPoses(newObjectPoses, providerName);
 
        return stats;
    }
 
    void
    Segment::commitObjectPoses(const ObjectPoseSeq& objectPoses, const std::string& providerName)
    {
        Time now = Time::Now();
 
        ARMARX_CHECK_NOT_NULL(segmentPtr);
        const MemoryID coreSegmentID = segmentPtr->id();
 
        Commit commit;
        for (const objpose::ObjectPose& pose : objectPoses)
        {
            EntityUpdate& update = commit.updates.emplace_back();
 
            const MemoryID providerID = coreSegmentID.withProviderSegmentName(
                providerName.empty() ? pose.providerName : providerName);
 
            update.entityID = providerID.withEntityName(pose.objectID.str());
            update.arrivedTime = now;
            update.referencedTime = pose.timestamp;
            update.confidence = pose.confidence;
 
            arondto::ObjectInstance dto;
            toAron(dto, pose);
            // Search for object class.
            if (auto instance = findClassInstance(pose.objectID))
            {
                toAron(dto.classID, instance->id());
            }
            else
            {
                toAron(dto.classID, MemoryID());
            }
            toAron(dto.sourceID, MemoryID());
            update.instancesData.push_back(dto.toAron());
        }
        // Commit non-locking.
        iceMemory.commit(commit);
    }
 
    void
    Segment::runUpdateObjectPoses()
    {
        const auto now = Clock::Now();
 
        ARMARX_VERBOSE << "runUpdateObjectPoses";
        auto objectPosesForProvider = getLatestObjectPosesByProviders();
 
        for (auto& [providerName, objectPoses] : objectPosesForProvider)
        {
            ARMARX_VERBOSE << VAROUT(providerName);
 
            auto attachedObjects =
                ranges::views::filter(objectPoses,
                                      [](const auto& pair)
                                      {
                                          const objpose::ObjectPose& objectPose = pair.second;
                                          return objectPose.attachment.has_value();
                                      }) |
                ranges::to<ObjectPoseMap>();
 
            updateObjectPoses(attachedObjects, now);
 
            std::map<std::string, std::vector<objpose::ObjectPose>> objectPosesByProviderToUpdate;
            {
                for (const auto& [id, objectPose] : attachedObjects)
                {
                    objectPosesByProviderToUpdate[objectPose.providerName].push_back(objectPose);
                }
            }
 
            // store object poses
            {
                const Time now = Time::Now();
                Commit commit;
 
                ARMARX_CHECK_NOT_NULL(segmentPtr);
                const MemoryID coreSegmentID = segmentPtr->id();
 
                for (const auto& [providerName, objectPoses] : objectPosesByProviderToUpdate)
                {
                    // updates originating from this provider
                    std::vector<EntityUpdate> updates;
 
                    for (const objpose::ObjectPose& pose : objectPoses)
                    {
                        ARMARX_INFO << deactivateSpam(10, providerName) << "Updating "
                                    << pose.objectID << " from provider " << providerName;
 
                        EntityUpdate& update = updates.emplace_back();
 
                        const MemoryID providerID = coreSegmentID.withProviderSegmentName(
                            providerName.empty() ? pose.providerName : providerName);
 
                        update.entityID =
                            providerID.withEntityName(pose.objectID.str()).withTimestamp(now);
                        update.arrivedTime = now;
                        update.referencedTime = now;
                        update.sentTime = now;
 
                        update.confidence = pose.confidence;
 
                        arondto::ObjectInstance dto;
                        toAron(dto, pose);
 
                        // update timestamp as the attachment was used to update the pose
                        dto.pose.timestamp = now;
 
                        // Search for object class.
                        if (auto instance = findClassInstance(pose.objectID))
                        {
                            toAron(dto.classID, instance->id());
                        }
                        else
                        {
                            toAron(dto.classID, MemoryID());
                        }
                        toAron(dto.sourceID, MemoryID());
                        update.instancesData.push_back(dto.toAron());
                    }
 
                    if (updates.empty())
                    {
                        ARMARX_VERBOSE << "No object poses to commit for provider " << providerName
                                       << ".";
                        continue;
                    }
 
                    ARMARX_VERBOSE << VAROUT(updates.size())
                                   << " object poses updated due to attachment for provider "
                                   << providerName << ".";
 
 
                    // add the updates from this provider to the commit updates (that will be stored in the memory)
                    commit.updates.insert(commit.updates.end(), updates.begin(), updates.end());
                }
 
                // Commit non-locking.
                iceMemory.commit(commit);
            }
        }
    }
 
    objpose::ObjectPoseMap
    Segment::getObjectPoses(const DateTime& now)
    {
        ObjectPoseMap objectPoses = getLatestObjectPoses();
        updateObjectPoses(objectPoses, now);
        return filterObjectPoses(objectPoses);
    }
 
    objpose::ObjectPoseMap
    Segment::getObjectPosesByProvider(const std::string& providerName, const DateTime& now)
    {
        ARMARX_CHECK_NOT_NULL(segmentPtr);
        ObjectPoseMap objectPoses =
            getLatestObjectPoses(segmentPtr->getProviderSegment(providerName));
        updateObjectPoses(objectPoses, now);
        return filterObjectPoses(objectPoses);
    }
 
    wm::Entity*
    Segment::findObjectEntity(const ObjectID& objectID, const std::string& providerName)
    {
        ARMARX_CHECK_NOT_NULL(segmentPtr);
        armem::MemoryID entityID = armem::MemoryID().withEntityName(objectID.str());
        if (providerName.empty())
        {
            wm::Entity* result = nullptr;
            segmentPtr->forEachProviderSegment(
                [&result, &entityID](wm::ProviderSegment& prov)
                {
                    if (prov.hasEntity(entityID.entityName))
                    {
                        result = &prov.getEntity(entityID);
                        return false;
                    }
                    return true;
                });
            return result;
        }
        else
        {
            entityID.providerSegmentName = providerName;
            if (segmentPtr->hasProviderSegment(providerName))
            {
                wm::ProviderSegment& prov = segmentPtr->getProviderSegment(providerName);
                return prov.hasEntity(entityID.entityName) ? &prov.getEntity(entityID) : nullptr;
            }
            else
            {
                return nullptr;
            }
        }
    }
 
    void
    Segment::updateObjectPoses(ObjectPoseMap& objectPoses, const DateTime& now)
    {
        bool agentSynchronized = false;
 
        for (auto& [id, objectPose] : objectPoses)
        {
            std::string robotName = objectPose.robotName;
 
            // if the object is attached, use the agent name from the attachment
            if (objectPose.attachment)
            {
                robotName = objectPose.attachment->agentName;
            }
 
            VirtualRobot::RobotPtr robot = robots.get(robotName, objectPose.providerName);
            updateObjectPose(objectPose, now, robot, agentSynchronized);
        }
    }
 
    void
    Segment::updateObjectPoses(ObjectPoseMap& objectPoses,
                               const DateTime& now,
                               VirtualRobot::RobotPtr agent,
                               bool& agentSynchronized) const
    {
        for (auto& [id, objectPose] : objectPoses)
        {
            updateObjectPose(objectPose, now, agent, agentSynchronized);
        }
    }
 
    void
    Segment::updateObjectPose(ObjectPose& objectPose,
                              const DateTime& now,
                              VirtualRobot::RobotPtr agent,
                              bool& agentSynchronized) const
    {
        updateAttachement(objectPose, agent, agentSynchronized);
 
        if (decay.enabled)
        {
            decay.updateConfidence(objectPose, now);
        }
    }
 
    Segment::ObjectPoseMap
    Segment::filterObjectPoses(const ObjectPoseMap& objectPoses) const
    {
        ObjectPoseMap result;
        for (const auto& [id, objectPose] : objectPoses)
        {
            if (!(decay.enabled && objectPose.confidence < decay.removeObjectsBelowConfidence))
            {
                result[id] = objectPose;
            }
        }
        return result;
    }
 
    void
    collectNamesRecursively(const VirtualRobot::RobotNodePtr& node, std::set<std::string>& names)
    {
        const auto children = node->getChildren<VirtualRobot::RobotNode>();
 
        for (const auto& child : children)
        {
            names.insert(child->getName());
            collectNamesRecursively(child, names);
        }
    }
 
    void
    Segment::updateAttachement(ObjectPose& objectPose,
                               VirtualRobot::RobotPtr agent,
                               bool& synchronized) const
    {
        if (not objectPose.attachment.has_value())
        {
            // No attachment, nothing to do.
            return;
        }
        ARMARX_CHECK(objectPose.attachment);
 
        if (not agent)
        {
            // Without a robot model, we cannot update the object pose.
            return;
        }
        ARMARX_CHECK_NOT_NULL(agent);
 
        if (not synchronized) // Synchronize only once.
        {
            ARMARX_CHECK_NOT_NULL(robots.reader);
 
            const armarx::DateTime timestamp = armarx::Clock::Now();
 
            synchronized = robots.reader->synchronizeRobot(*agent, timestamp);
 
            if (not synchronized)
            {
                ARMARX_WARNING << "Failed to synchronize robot " << QUOTED(agent->getName())
                               << " to timestamp " << timestamp;
                return;
            }
        }
 
        if (p.automaticallyDetachObjectsOnHandOpening)
        {
 
            const std::string SideIdentifierLeft = "Left";
            const std::string SideIdentifierRight = "Right";
 
            // Helpers
            const auto getHand = [this, SideIdentifierLeft, SideIdentifierRight](
                                     const std::string& nodeName,
                                     const VirtualRobot::Robot& robot) -> std::optional<std::string>
            {
                const auto getNodesForSide =
                    [](const std::string& nodeSetName,
                       const VirtualRobot::Robot& robot) -> std::set<std::string>
                {
                    const auto nodeSet = robot.getRobotNodeSet(nodeSetName);
                    ARMARX_CHECK(nodeSet)
                        << "Node set " << QUOTED(nodeSet) << " not found in robot";
 
                    const auto rootNode = nodeSet->getKinematicRoot();
                    ARMARX_CHECK(rootNode) << "Node set " << QUOTED(nodeSet) << " has no root node";
 
                    std::set<std::string> names;
                    collectNamesRecursively(rootNode, names);
 
                    return names;
                };
 
                const std::set<std::string> leftArmNodeNames = getNodesForSide("LeftArm", robot);
                const std::set<std::string> rightArmNodeNames = getNodesForSide("RightArm", robot);
 
                ARMARX_DEBUG << "Left arm nodes: " << leftArmNodeNames.size();
                ARMARX_DEBUG << "Right arm nodes: " << rightArmNodeNames.size();
 
 
                const auto matchToSide =
                    [&leftArmNodeNames,
                     &rightArmNodeNames,
                     this,
                     SideIdentifierLeft,
                     SideIdentifierRight](const std::string& nodeName) -> std::optional<std::string>
                {
                    if (ranges::contains(leftArmNodeNames, nodeName))
                    {
                        return SideIdentifierLeft;
                    }
                    if (ranges::contains(rightArmNodeNames, nodeName))
                    {
                        return SideIdentifierRight;
                    }
 
                    ARMARX_VERBOSE << "Could not match frame " + QUOTED(nodeName)
                                   << " to left or right arm";
                    return std::nullopt;
                };
 
                return matchToSide(nodeName);
            };
 
            const auto getOpenHandJointValues =
                [](const std::string& hand,
                   const VirtualRobot::Robot& robot) -> std::map<std::string, float>
            {
                // Determine end-effector name for shape retrieval. By convention, it is "Hand_{R/L}_EEF" at the moment.
                std::stringstream eefSS;
                eefSS << "Hand_" << hand.front() << "_EEF";
                const std::string endEffectorName = eefSS.str();
 
                const auto endEffector = robot.getEndEffector(endEffectorName);
                ARMARX_CHECK_NOT_NULL(endEffector);
 
                const auto openShape = endEffector->getPreshape("Open");
                ARMARX_CHECK_NOT_NULL(openShape)
                    << "Shape " << QUOTED("Open") << " not found for end-effector "
                    << QUOTED(endEffectorName);
 
                return openShape->getRobotNodeJointValueMap();
            };
 
            // Check which hand the object is attached to (if any)
            const std::optional<std::string> hand =
                getHand(objectPose.attachment->frameName, *agent);
 
 
            const auto isHandOpen =
                [&getOpenHandJointValues, &agent, this](const std::string& hand) -> bool
            {
                // Obtain the robot joint values including finger values
                const std::map<std::string, float> currentJointValues = agent->getJointValues();
 
                // Determine the involved joints for the `Open` hand shape. Those will be compared to the current joint values.
                const std::map<std::string, float> openHandJointValues =
                    getOpenHandJointValues(hand, *agent);
                const std::vector<std::string> involvedHandJointNames =
                    simox::get_keys(openHandJointValues);
 
                // Compute the difference between the open hand shape and the current state
 
                const auto positionDifference =
                    [&](const std::string& nodeName) noexcept(false) -> float
                {
                    ARMARX_CHECK(currentJointValues.count(nodeName) > 0) << nodeName;
                    const float currentVal = currentJointValues.at(nodeName);
 
                    ARMARX_CHECK(openHandJointValues.count(nodeName) > 0) << nodeName;
                    const float openVal = openHandJointValues.at(nodeName);
 
                    return std::abs(openVal - currentVal);
                };
 
                const std::vector<float> positionDifferences =
                    involvedHandJointNames | ranges::views::transform(positionDifference) |
                    ranges::to_vector;
 
                const bool isHandOpen =
                    ranges::all_of(positionDifferences,
                                   [automaticallyDetachPositionThreshold =
                                        p.automaticallyDetachPositionThreshold](const float diff)
                                   { return diff < automaticallyDetachPositionThreshold; });
 
                return isHandOpen;
            };
 
            if (hand.has_value())
            {
                if (isHandOpen(hand.value()))
                {
                    ARMARX_INFO << "Detected that hand " << QUOTED(hand.value())
                                << " is now open. Invalidating attachment for "
                                << QUOTED(objectPose.objectID);
 
                    // Invalidate attachment
                    objectPose.attachment.reset();
                    return;
                }
            }
            else
            {
                ARMARX_VERBOSE << "The node " << QUOTED(objectPose.attachment->frameName)
                               << " could not be linked to a hand.";
 
                // We check if all hands are open. If so, we also detach the object.
                if (isHandOpen(SideIdentifierLeft) and isHandOpen(SideIdentifierRight))
                {
                    ARMARX_INFO << "As both hands are open, the object "
                                << QUOTED(objectPose.objectID) << " will be detached.";
                    // Invalidate attachment
                    objectPose.attachment.reset();
                    return;
                }
            }
        }
 
        objectPose.updateAttached(agent);
    }
 
    objpose::ObjectPoseMap
    Segment::getLatestObjectPoses() const
    {
        ARMARX_CHECK_NOT_NULL(segmentPtr);
        return getLatestObjectPoses(*segmentPtr);
    }
 
    std::map<std::string, objpose::ObjectPoseMap>
    Segment::getLatestObjectPosesByProviders()
    {
        ARMARX_CHECK_NOT_NULL(segmentPtr);
        return getLatestObjectPosesByProviders(*segmentPtr);
    }
 
    objpose::ObjectPoseMap
    Segment::getLatestObjectPoses(const wm::CoreSegment& coreSeg)
    {
        ObjectPoseMap result;
        getLatestObjectPoses(coreSeg, result);
        return result;
    }
 
    objpose::ObjectPoseMap
    Segment::getLatestObjectPoses(const wm::ProviderSegment& provSeg)
    {
        ObjectPoseMap result;
        getLatestObjectPoses(provSeg, result);
        return result;
    }
 
    std::map<std::string, objpose::ObjectPoseMap>
    Segment::getLatestObjectPosesByProviders(const wm::CoreSegment& coreSeg)
    {
        std::map<std::string, ObjectPoseMap> result;
        getLatestObjectPosesByProviders(coreSeg, result);
        return result;
    }
 
    objpose::ObjectPose
    Segment::getLatestObjectPose(const wm::Entity& entity)
    {
        ObjectPose result;
        getLatestObjectPose(entity, result);
        return result;
    }
 
    void
    Segment::getLatestObjectPoses(const wm::CoreSegment& coreSeg, ObjectPoseMap& out)
    {
        coreSeg.forEachProviderSegment([&out](const wm::ProviderSegment& provSegment)
                                       { getLatestObjectPoses(provSegment, out); });
    }
 
    void
    Segment::getLatestObjectPosesByProviders(const wm::CoreSegment& coreSeg,
                                             std::map<std::string, ObjectPoseMap>& out)
    {
        coreSeg.forEachProviderSegment(
            [&out](const wm::ProviderSegment& provSegment)
            {
                // out[..]: create in place
                getLatestObjectPoses(provSegment, out[provSegment.name()]);
            });
    }
 
    void
    Segment::getLatestObjectPoses(const wm::ProviderSegment& provSegment, ObjectPoseMap& out)
    {
        provSegment.forEachEntity(
            [&out](const wm::Entity& entity)
            {
                if (!entity.empty())
                {
                    ObjectPose pose = getLatestObjectPose(entity);
                    // Try to insert. Fails and returns false if an entry already exists.
                    const auto [it, success] = out.insert({pose.objectID, pose});
                    if (!success)
                    {
                        // An entry with that ID already exists. We keep the newest.
                        if (it->second.timestamp < pose.timestamp)
                        {
                            it->second = pose;
                        }
                    }
                }
            });
    }
 
    void
    Segment::getLatestObjectPose(const wm::Entity& entity, ObjectPose& out)
    {
        entity.getLatestSnapshot().forEachInstance(
            [&out](const wm::EntityInstance& instance)
            {
                arondto::ObjectInstance dto;
                dto.fromAron(instance.data());
 
                fromAron(dto, out);
            });
    }
 
    arondto::ObjectInstance
    Segment::getLatestInstanceData(const wm::Entity& entity)
    {
        ARMARX_CHECK_GREATER_EQUAL(entity.size(), 1);
        const wm::EntitySnapshot& snapshot = entity.getLatestSnapshot();
 
        ARMARX_CHECK_EQUAL(snapshot.size(), 1);
        const wm::EntityInstance& instance = snapshot.getInstance(0);
 
        arondto::ObjectInstance data;
        data.fromAron(instance.data());
 
        return data;
    }
 
    ::armarx::armem::articulated_object::ArticulatedObjects
    Segment::getArticulatedObjects()
    {
        objpose::ObjectPoseMap objectPoses = getObjectPoses(Time::Now());
 
        ARMARX_INFO << "Found " << objectPoses.size() << " object poses";
 
        ::armarx::armem::articulated_object::ArticulatedObjects objects;
        for (const auto& [objectId, objectPose] : objectPoses)
        {
            armem::articulated_object::ArticulatedObject articulatedObject;
            articulatedObject.config.jointMap = objectPose.objectJointValues;
            articulatedObject.config.globalPose = objectPose.objectPoseGlobal;
            articulatedObject.config.timestamp = objectPose.timestamp;
            articulatedObject.instance = objectPose.objectID.instanceName();
            articulatedObject.timestamp = objectPose.timestamp;
 
            ARMARX_INFO << "Object id is " << objectId.str();
            ARMARX_INFO << "Object id for objectPose is " << objectPose.objectID.str();
 
            // Search for object class.
            if (auto classInstance = findClassInstance(objectPose.objectID))
            {
                arondto::ObjectClass dto;
 
                try
                {
                    dto.fromAron(classInstance->data());
                    robot_state::description::RobotDescription description;
 
                    fromAron(dto, description);
                    articulatedObject.description = description;
                }
                catch (...)
                {
                    ARMARX_WARNING << "Conversion failed!";
                    continue;
                }
            }
            else
            {
                ARMARX_WARNING << "Class instance not found!";
                continue;
            }
 
            if (not articulatedObject.config.jointMap.empty())
            {
                objects.push_back(articulatedObject);
            }
        }
 
        return objects;
    }
 
    std::map<DateTime, objpose::ObjectPose>
    Segment::getObjectPosesInRange(const wm::Entity& entity,
                                   const DateTime& start,
                                   const DateTime& end)
    {
        std::map<DateTime, objpose::ObjectPose> result;
 
        entity.forEachSnapshotInTimeRange(
            start,
            end,
            [&result](const wm::EntitySnapshot& snapshot)
            {
                snapshot.forEachInstance(
                    [&result, &snapshot](const wm::EntityInstance& instance)
                    {
                        arondto::ObjectInstance dto;
                        dto.fromAron(instance.data());
 
                        ObjectPose pose;
                        fromAron(dto, pose);
 
                        result.emplace(snapshot.time(), pose);
                    });
            });
 
        return result;
    }
 
    std::optional<simox::OrientedBoxf>
    Segment::getObjectOOBB(const ObjectID& id)
    {
        return oobbCache.get(id);
    }
 
    objpose::ProviderInfo
    Segment::getProviderInfo(const std::string& providerName)
    {
        try
        {
            return providers.at(providerName);
        }
        catch (const std::out_of_range&)
        {
            std::stringstream ss;
            ss << "No provider with name '" << providerName << "' available.\n";
            ss << "Available are:\n";
            for (const auto& [name, _] : providers)
            {
                ss << "- '" << name << "'\n";
            }
            throw std::out_of_range(ss.str());
        }
    }
 
    objpose::AttachObjectToRobotNodeOutput
    Segment::attachObjectToRobotNode(const objpose::AttachObjectToRobotNodeInput& input)
    {
        const armem::Time now = armem::Time::Now();
 
        objpose::AttachObjectToRobotNodeOutput output;
        output.success = false; // We are not successful until proven otherwise.
 
        ObjectID objectID = armarx::fromIce(input.objectID);
 
        VirtualRobot::RobotPtr agent = robots.get(input.agentName);
        if (not agent)
        {
            std::stringstream ss;
            ss << "Tried to attach object " << objectID << " to unknown agent '" << input.agentName
               << "'."
               << "\n(You can leave the agent name empty if there is only one agent.)\n"
               << "\nKnown agents: ";
            for (const auto& [name, robot] : robots.loaded)
            {
                ss << "\n- '" << name << "'";
            }
            ARMARX_WARNING << ss.str();
            return output;
        }
        ARMARX_CHECK_NOT_NULL(agent);
 
        if (!agent->hasRobotNode(input.frameName))
        {
            ARMARX_WARNING << "Tried to attach object " << objectID << " to unknown node '"
                           << input.frameName << "' of agent '" << agent->getName() << "'.";
            return output;
        }
        std::string frameName = input.frameName;
 
 
        // Find object pose (provider name can be empty).
        wm::Entity* objectEntity = this->findObjectEntity(objectID, input.providerName);
        if (!objectEntity || objectEntity->empty())
        {
            ARMARX_WARNING << "Tried to attach object " << objectID << " to node '" << frameName
                           << "' of agent '" << agent->getName()
                           << "', but object is currently not provided.";
            return output;
        }
        arondto::ObjectInstance data = getLatestInstanceData(*objectEntity);
 
        objpose::ObjectAttachmentInfo info;
        info.agentName = agent->getName();
        info.frameName = frameName;
 
        if (input.poseInFrame)
        {
            ARMARX_INFO << "Attachment pose provided.";
            info.poseInFrame = PosePtr::dynamicCast(input.poseInFrame)->toEigen();
        }
        else
        {
            ARMARX_CHECK_NOT_NULL(robots.reader);
 
            const auto timestamp = armarx::Clock::Now();
            ARMARX_CHECK(robots.reader->synchronizeRobot(*agent, timestamp));
 
            armarx::FramedPose framed(
                data.pose.objectPoseGlobal, armarx::GlobalFrame, agent->getName());
            if (frameName == armarx::GlobalFrame)
            {
                info.poseInFrame = framed.toGlobalEigen(agent);
            }
            else
            {
                framed.changeFrame(agent, info.frameName);
                info.poseInFrame = framed.toEigen();
            }
        }
 
        // Store attachment in new entity snapshot.
        {
            armem::Commit commit;
            armem::EntityUpdate& update = commit.add();
            update.entityID = objectEntity->id();
 
            if (p.separateProviderForAttachedObjects)
            {
                update.entityID.providerSegmentName = p.attachedProviderName;
                data.pose.providerName = p.attachedProviderName;
                data.pose.confidence = 1;
            }
 
            update.referencedTime = now;
            {
                arondto::ObjectInstance updated = data;
                toAron(updated.pose.attachment, info);
                updated.pose.attachmentValid = true;
                update.instancesData = {updated.toAron()};
            }
            iceMemory.commit(commit);
        }
 
        ARMARX_INFO << "Attached object " << objectID << " by provider '" << data.pose.providerName
                    << "' "
                    << "to node '" << info.frameName << "' of agent '" << info.agentName << "'.\n"
                    << "Object pose in frame: \n"
                    << info.poseInFrame;
 
        output.success = true;
        output.attachment = new objpose::data::ObjectAttachmentInfo();
        output.attachment->frameName = info.frameName;
        output.attachment->agentName = info.agentName;
        output.attachment->poseInFrame = new Pose(info.poseInFrame);
 
        return output;
    }
 
    objpose::DetachObjectFromRobotNodeOutput
    Segment::detachObjectFromRobotNode(const objpose::DetachObjectFromRobotNodeInput& input)
    {
        const armem::Time now = armem::Time::Now();
 
        ObjectID objectID = armarx::fromIce(input.objectID);
        std::string providerName = input.providerName;
 
        if (p.separateProviderForAttachedObjects)
        {
            providerName = p.attachedProviderName;
        };
 
        std::optional<objpose::arondto::ObjectAttachmentInfo> attachment;
        {
            // Remove from latest pose (if it was cached).
            // Find object pose (provider name can be empty).
            wm::Entity* entity = this->findObjectEntity(objectID, input.providerName);
            if (entity)
            {
                const arondto::ObjectInstance data = getLatestInstanceData(*entity);
                if (data.pose.attachmentValid)
                {
                    attachment = data.pose.attachment;
 
                    // Store non-attached pose in new snapshot.
                    storeDetachedSnapshot(
                        *entity, data, now, input.commitAttachedPose, input.forgetObject);
                }
                if (providerName.empty())
                {
                    providerName = data.pose.providerName;
                }
            }
        }
 
        objpose::DetachObjectFromRobotNodeOutput output;
        output.wasAttached = bool(attachment);
        if (attachment)
        {
            ARMARX_INFO << "Detached object " << objectID << " by provider '" << providerName
                        << "' from robot node '" << attachment->frameName << "' of agent '"
                        << attachment->agentName << "'.";
        }
        else
        {
            ARMARX_INFO << "Tried to detach object " << objectID << " by provider '" << providerName
                        << "' "
                        << "from robot node, but it was not attached.";
        }
 
        return output;
    }
 
    objpose::DetachAllObjectsFromRobotNodesOutput
    Segment::detachAllObjectsFromRobotNodes(
        const objpose::DetachAllObjectsFromRobotNodesInput& input)
    {
        ARMARX_CHECK_NOT_NULL(segmentPtr);
 
        const armem::Time now = armem::Time::Now();
 
        objpose::DetachAllObjectsFromRobotNodesOutput output;
        output.numDetached = 0;
        segmentPtr->forEachEntity(
            [this, now, &input, &output](wm::Entity& entity)
            {
                const arondto::ObjectInstance data = this->getLatestInstanceData(entity);
                if (data.pose.attachmentValid)
                {
                    ++output.numDetached;
                    // Store non-attached pose in new snapshot.
                    this->storeDetachedSnapshot(
                        entity, data, now, input.commitAttachedPose, input.forgetObject);
                }
            });
 
        ARMARX_INFO << "Detached all objects (" << output.numDetached << ") from robot nodes.";
 
        return output;
    }
 
    void
    Segment::storeDetachedSnapshot(wm::Entity& entity,
                                   const arondto::ObjectInstance& data,
                                   Time now,
                                   const bool commitAttachedPose,
                                   const bool forgetObject)
    {
        armem::Commit commit;
        armem::EntityUpdate& update = commit.add();
        update.entityID = entity.id();
        update.referencedTime = now;
        {
            arondto::ObjectInstance updated;
            if (commitAttachedPose and data.pose.attachmentValid)
            {
                ObjectPose objectPose;
                fromAron(data, objectPose);
 
                VirtualRobot::RobotPtr robot =
                    robots.get(objectPose.robotName, objectPose.providerName);
                bool agentSynchronized = false;
                updateAttachement(objectPose, robot, agentSynchronized);
 
                objectPose.attachment = std::nullopt;
                toAron(updated, objectPose);
            }
            else if (forgetObject)
            {
                ARMARX_INFO << "Forgetting object";
 
                updated = data;
 
                updated.pose.attachmentValid = false;
                toAron(updated.pose.attachment, objpose::ObjectAttachmentInfo{});
 
                updated.pose.confidence = 0;
            }
            else
            {
                updated = data;
                updated.pose.attachmentValid = false;
                toAron(updated.pose.attachment, objpose::ObjectAttachmentInfo{});
            }
 
            update.instancesData = {updated.toAron()};
        }
        iceMemory.commit(commit);
    }
 
    std::optional<wm::EntityInstance>
    Segment::findClassInstance(const ObjectID& objectID) const
    {
        const ObjectID classID = {objectID.dataset(), objectID.className()};
        try
        {
            std::optional<wm::EntityInstance> result;
            // The Class core segment can be mutated concurrently (e.g. by
            // entity truncation or new commits). forEachProviderSegment
            // iterates the underlying std::map, so we must hold the core
            // segment's read lock for the duration of the traversal AND
            // while we read the snapshot/instance from the found provider
            // segment, otherwise we risk iterator invalidation or reading
            // half-destructed entries (use-after-free / data race).
            const wm::CoreSegment& classCoreSeg =
                iceMemory.workingMemory->getCoreSegment("Class");
            classCoreSeg.doLocked(
                [&classCoreSeg, &classID, &result]()
                {
                    classCoreSeg.forEachProviderSegment(
                        [&classID, &result](const wm::ProviderSegment& provSeg)
                        {
                            if (provSeg.hasEntity(classID.str()))
                            {
                                result = provSeg.getEntity(classID.str())
                                             .getLatestSnapshot()
                                             .getInstance(0);
                                return false;
                            }
                            return true;
                        });
                });
 
            if (not result.has_value())
            {
                ARMARX_WARNING << deactivateSpam(120) << "No provider segment for classID "
                               << classID.str() << " found";
            }
            return result;
        }
        catch (const armem::error::ArMemError& e)
        {
            // Some segment or entity did not exist.
            ARMARX_WARNING << e.what();
            return std::nullopt;
        }
    }
 
    void
    Segment::storeScene(const std::string& filename, const armarx::objects::Scene& scene)
    {
        if (const std::optional<std::filesystem::path> path = resolveSceneFilepath(filename))
        {
            ARMARX_INFO << "Storing scene snapshot at: \n" << path.value();
            try
            {
                simox::json::write(path.value(), scene, 2);
            }
            catch (const simox::json::error::JsonError& e)
            {
                ARMARX_WARNING << "Storing scene snapshot failed: \n" << e.what();
            }
        }
    }
 
    std::optional<armarx::objects::Scene>
    Segment::loadScene(const std::string& filename)
    {
        if (const std::optional<std::filesystem::path> path = resolveSceneFilepath(filename))
        {
            return loadScene(path.value());
        }
        else
        {
            return std::nullopt;
        }
    }
 
    std::optional<armarx::objects::Scene>
    Segment::loadScene(const std::filesystem::path& path)
    {
        try
        {
            ARMARX_CHECK(std::filesystem::exists(path)) << path;
            return simox::json::read<armarx::objects::Scene>(path);
        }
        catch (const simox::json::error::JsonError& e)
        {
            ARMARX_WARNING << "Loading scene snapshot failed: \n" << e.what();
            return std::nullopt;
        }
    }
 
    const std::string Segment::timestampPlaceholder = "%TIMESTAMP";
 
    std::optional<std::filesystem::path>
    Segment::resolveSceneFilepath(const std::string& _filename)
    {
        std::stringstream log;
        std::filesystem::path filepath = _filename;
 
        filepath = simox::alg::replace_all(
            filepath, timestampPlaceholder, Time::Now().toString("%Y-%m-%d_%H-%M-%S"));
        if (not simox::alg::ends_with(filepath, ".json"))
        {
            filepath += ".json";
        }
 
        if (filepath.is_absolute())
        {
            return filepath;
        }
 
 
        if (filepath.has_parent_path())
        {
            // Maybe this is a package path? We don't know yet and only accept it if the package exists.
 
            // Interpret the first component as package name.
            const std::string packageName = *filepath.begin();
 
            const PackagePath pp(packageName, std::filesystem::relative(filepath, packageName));
 
 
            try
            {
                // This might throw an armarx::PackageNotFoundException if the package does not exist.
                const std::filesystem::path systemPath = pp.toSystemPath();
 
                if (std::filesystem::exists(pp.toSystemPath()))
                {
                    return systemPath;
                }
 
                ARMARX_VERBOSE << "Interpreted '" << packageName
                               << "' as ArmarX package name. Relative path is '"
                               << pp.serialize().path
                               << "'. But the file does not exist at system path '" << systemPath
                               << "'.";
            }
            catch (const armarx::PackageNotFoundException& e)
            {
                ARMARX_VERBOSE << "Could not interpret '" << packageName
                               << "' as ArmarX package name. Relative path is '"
                               << pp.serialize().path << "'.";
            }
        }
 
        // Fallback: we use the provided properties.
 
        // Only a filename => Interprete it as relative to 'Package/scenes/'.
        const PackagePath pp(p.sceneSnapshotsPackage, p.sceneSnapshotsDirectory / filepath);
 
        try
        {
            // This might throw an armarx::PackageNotFoundException if the package does not exist.
            const std::filesystem::path systemPath = pp.toSystemPath();
 
            if (std::filesystem::exists(pp.toSystemPath()))
            {
                return systemPath;
            }
 
            ARMARX_VERBOSE << "Interpreted '" << p.sceneSnapshotsPackage
                           << "' as ArmarX package name. Relative path is '" << pp.serialize().path
                           << "'. But the file does not exist at system path '" << systemPath
                           << "'.";
        }
        catch (const armarx::PackageNotFoundException& e)
        {
            ARMARX_VERBOSE << "Could not interpret '" << p.sceneSnapshotsPackage
                           << "' as ArmarX package name. Relative path is '" << pp.serialize().path
                           << "'.";
        }
 
        return std::nullopt;
    }
 
    armarx::objects::Scene
    Segment::getSceneSnapshot() const
    {
        using armarx::objects::SceneObject;
 
        // We only store the latest version of each objectID.
 
        struct StampedSceneObject
        {
            SceneObject object;
            Time timestamp;
        };
 
        std::map<ObjectID, StampedSceneObject> objects;
        segmentPtr->forEachEntity(
            [&objects](wm::Entity& entity)
            {
                const wm::EntityInstance* entityInstance = entity.findLatestInstance();
                if (entityInstance)
                {
                    std::optional<arondto::ObjectInstance> objectInstance =
                        tryCast<arondto::ObjectInstance>(*entityInstance);
                    if (objectInstance)
                    {
                        const ObjectID objectID =
                            ObjectID::FromString(objectInstance->classID.entityName);
 
                        auto it = objects.find(objectID);
                        if (it == objects.end() or
                            objectInstance->pose.timestamp > it->second.timestamp)
                        {
                            StampedSceneObject& stamped = objects[objectID];
                            stamped.timestamp = objectInstance->pose.timestamp;
 
                            SceneObject& object = stamped.object;
                            object.className = objectID.getClassID().str();
                            object.instanceName = objectID.instanceName();
                            object.collection = "";
 
                            object.position =
                                simox::math::position(objectInstance->pose.objectPoseGlobal);
                            object.orientation =
                                simox::math::orientation(objectInstance->pose.objectPoseGlobal);
 
                            object.isStatic = objectInstance->pose.isStatic;
                            object.jointValues = objectInstance->pose.objectJointValues;
                        }
                    }
                }
            });
 
        armarx::objects::Scene scene;
        for (const auto& [id, stamped] : objects)
        {
            scene.objects.emplace_back(std::move(stamped.object));
        }
        return scene;
    }
 
    void
    Segment::commitSceneSnapshot(const armarx::objects::Scene& scene, const std::string& sceneName)
    {
        const Time now = Time::Now();
        std::map<ObjectID, int> idCounters;
 
        objpose::ObjectPoseSeq objectPoses;
 
        for (const auto& object : scene.objects)
        {
            if (simox::alg::starts_with(object.className, "#"))
            {
                // marked to be ignored
                continue;
            }
 
            const ObjectID classID = object.getClassID(objectFinder);
 
            objpose::ObjectPose& pose = objectPoses.emplace_back();
 
            pose.providerName = sceneName;
            pose.objectType = objpose::ObjectType::KnownObject;
            // If not specified, assume loaded objects are static.
            pose.isStatic = object.isStatic.has_value() ? object.isStatic.value() : true;
            pose.objectID = classID.withInstanceName(object.instanceName.empty()
                                                         ? std::to_string(idCounters[classID]++)
                                                         : object.instanceName);
 
            pose.objectPoseGlobal = simox::math::pose(object.position, object.orientation);
            pose.objectPoseRobot = pose.objectPoseGlobal;
            pose.objectPoseOriginal = pose.objectPoseGlobal;
            pose.objectPoseOriginalFrame = armarx::GlobalFrame;
 
            pose.objectJointValues = object.jointValues;
 
            pose.robotConfig = {};
            pose.robotPose = Eigen::Matrix4f::Identity();
            pose.robotName = "";
 
            pose.confidence = 1.0;
            pose.localOOBB = getObjectOOBB(classID);
            pose.timestamp = now;
        }
 
        commitObjectPoses(objectPoses);
    }
 
    void
    Segment::commitSceneSnapshotFromFilename(const std::string& filename, bool lockMemory)
    {
        std::stringstream ss;
        ss << "Loading scene '" << filename << "' ...";
        if (std::optional<std::filesystem::path> path = resolveSceneFilepath(filename))
        {
            ARMARX_INFO << ss.str() << "\nfrom " << path.value();
 
            if (const auto snapshot = loadScene(path.value()))
            {
                auto makeSceneName = [](const std::filesystem::path& path)
                {
                    std::filesystem::path filename = path.filename();
                    filename.replace_extension(); // Removes extension
                    return filename.string();
                };
                std::string sceneName = makeSceneName(path.value());
 
                // The check seems useless?
                if (lockMemory)
                {
                    segmentPtr->doLocked([this, &snapshot, &sceneName]()
                                         { commitSceneSnapshot(snapshot.value(), sceneName); });
                }
                else
                {
                    commitSceneSnapshot(snapshot.value(), sceneName);
                }
            }
        }
        else
        {
            ARMARX_INFO << ss.str() << " failed: Could not resolve scene name or path.";
        }
    }
 
    void
    Segment::RemoteGui::setup(const Segment& data)
    {
        using namespace armarx::RemoteGui::Client;
 
        maxHistorySize.setValue(std::max(1, int(data.properties.maxHistorySize)));
        maxHistorySize.setRange(1, 1e6);
        infiniteHistory.setValue(data.properties.maxHistorySize == -1);
        discardSnapshotsWhileAttached.setValue(data.p.discardSnapshotsWhileAttached);
 
        const std::string storeLoadPath = [&data]()
        {
            const std::vector<std::string> scenes = data.p.getSceneSnapshotsToLoad();
            if (scenes.empty())
            {
                std::string storeLoadFilename = "Scene_" + timestampPlaceholder;
                return data.p.sceneSnapshotsPackage + "/" + data.p.sceneSnapshotsToLoad;
            }
            else
            {
                return scenes.front();
            }
        }();
 
        storeLoadLine.setValue(storeLoadPath);
        loadButton.setLabel("Load Scene");
        storeButton.setLabel("Store Scene");
 
        HBoxLayout storeLoadLineLayout({storeLoadLine, Label(".json")});
        HBoxLayout storeLoadButtonsLayout({loadButton, storeButton});
 
        detachAllObjectsButton.setLabel("Detach All Objects");
        detachAllObjectsCommitAttachedPoseCheckBox.setValue(true);
        HBoxLayout detachAllObjectsCommitAttachedPoseLayout(
            {Label("Commit Attached Pose"), detachAllObjectsCommitAttachedPoseCheckBox});
 
 
        GridLayout grid;
        int row = 0;
 
        grid.add(storeLoadLineLayout, {row, 0}, {1, 2});
        row++;
        grid.add(storeLoadButtonsLayout, {row, 0}, {1, 2});
        row++;
 
        grid.add(Label("Max History Size"), {row, 0}).add(maxHistorySize, {row, 1});
        row++;
        grid.add(Label("Infinite History Size"), {row, 0}).add(infiniteHistory, {row, 1});
        row++;
        grid.add(Label("Discard Snapshots while Attached"), {row, 0})
            .add(discardSnapshotsWhileAttached, {row, 1});
        row++;
 
        grid.add(detachAllObjectsButton, {row, 0})
            .add(detachAllObjectsCommitAttachedPoseLayout, {row, 1});
 
        group.setLabel("Data");
        group.addChild(grid);
    }
 
    void
    Segment::RemoteGui::update(Segment& segment)
    {
        if (loadButton.wasClicked())
        {
            bool lockMemory = true;
            segment.commitSceneSnapshotFromFilename(storeLoadLine.getValue(), lockMemory);
        }
 
        if (storeButton.wasClicked())
        {
            armarx::objects::Scene scene;
            segment.doLocked([&scene, &segment]() { scene = segment.getSceneSnapshot(); });
            segment.storeScene(storeLoadLine.getValue(), scene);
        }
 
        if (infiniteHistory.hasValueChanged() || maxHistorySize.hasValueChanged() ||
            discardSnapshotsWhileAttached.hasValueChanged())
        {
            segment.doLocked(
                [this, &segment]()
                {
                    if (infiniteHistory.hasValueChanged() || maxHistorySize.hasValueChanged())
                    {
                        segment.properties.maxHistorySize =
                            infiniteHistory.getValue() ? -1 : maxHistorySize.getValue();
                        if (segment.segmentPtr)
                        {
                            segment.segmentPtr->setMaxHistorySize(
                                long(segment.properties.maxHistorySize));
                        }
                    }
 
                    segment.p.discardSnapshotsWhileAttached =
                        discardSnapshotsWhileAttached.getValue();
                });
        }
 
        if (detachAllObjectsButton.wasClicked())
        {
            objpose::DetachAllObjectsFromRobotNodesInput input;
            input.commitAttachedPose = detachAllObjectsCommitAttachedPoseCheckBox.getValue();
 
            objpose::DetachAllObjectsFromRobotNodesOutput output = segment.doLocked(
                [&segment, &input]() { return segment.detachAllObjectsFromRobotNodes(input); });
            (void)output;
        }
    }
 
    VirtualRobot::RobotPtr
    Segment::RobotsCache::get(const std::string& _robotName, const std::string& providerName)
    {
        std::string robotName = _robotName;
 
        if (robotName.empty())
        {
            auto antiSpam = deactivateSpam(10 * 60); // 10 minutes.
 
            std::stringstream ss;
            if (providerName.empty())
            {
                ss << "The provided object pose";
            }
            else
            {
                ss << "The object pose provided by '" << providerName << "'";
            }
            ss << " does not specify a robot name";
 
            if (fallbackName.empty())
            {
                ss << ", and no fallback robot name was configured (e.g. via the properties).\n"
                   << "For these object poses, the object instance segment is not able "
                   << "to provide transformed object poses (global and in robot root frame).";
                ARMARX_INFO << antiSpam << ss.str();
 
                return nullptr;
            }
            else
            {
                ss << ". The object instance segment is falling back to '" << fallbackName << "'.";
                ARMARX_INFO << antiSpam << ss.str();
 
                robotName = fallbackName;
            }
        }
        ARMARX_CHECK_NOT_EMPTY(robotName);
 
        // Lookup in cache.
        if (auto it = loaded.find(robotName); it != loaded.end())
        {
            ARMARX_CHECK_NOT_NULL(it->second);
            return it->second;
        }
        else
        {
            // Try to fetch the robot.
            ARMARX_CHECK_NOT_NULL(reader);
            VirtualRobot::RobotPtr robot = reader->getRobot(
                robotName, Clock::Now(), VirtualRobot::RobotIO::RobotDescription::eStructure);
 
            if (robot)
            {
                bool synchronized = reader->synchronizeRobot(*robot, Clock::Now());
                if (not synchronized)
                {
                    ARMARX_INFO << "The robot '" << robotName << "' could be loaded, but not"
                                << " synchronized successfully (e.g., the global localization "
                                   "could be missing). "
                                << "Make sure to synchronize it before use if necessary.";
                }
                // Store robot if valid.
                loaded.emplace(robotName, robot);
            }
            return robot; // valid or nullptr
        }
    }
 
} // namespace armarx::armem::server::obj::instance