MemoryGroupBoxController.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2012-2025, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    RobotStateComponent::
 * @author     Samet Soenmez (uewtt at student dot kit dot edu)
 * @date       2025t
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "MemoryGroupBoxController.h"
 
#include <QLayout>
#include <QGroupBox>
#include <QLabel>
 
#include <ArmarXCore/core/ManagedIceObject.h>
#include <ArmarXCore/core/ice_conversions/ice_conversions_templates.h>
#include <ArmarXCore/core/time/TimeUtil.h>
#include <ArmarXCore/observers/variant/Variant.h>
 
#include <RobotAPI/libraries/armem/core/container_maps.h>
#include <RobotAPI/libraries/armem_gui/view/instance_group/instance/AronDataView.h>
#include <RobotAPI/libraries/armem_gui/util/gui_utils.h>
#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
 
namespace armarx::armem::gui::controller
{
    MemoryGroupBoxController::MemoryGroupBoxController(
        MemoryViewerUIContext& uiContext,
        std::shared_ptr<armem::gui::model::MemoryViewerModel> model)
    {
        _model = std::move(model);
        _statusLabel = uiContext.statusLabel;
        _instanceGroupBoxController = std::make_unique<InstanceGroupBoxController>(
            uiContext,
            _model);
 
        // for prediction widget
        auto entityInfoRetriever = [this](const MemoryID& entityID) -> PredictionWidget::EntityInfo
        {
            client::Reader reader = _model->memoryReaders().at(entityID.memoryName);
            if (!reader.predictionPrx)
            {
                std::stringstream sstream;
                sstream << "Predictions are not available for memory '" << entityID.memoryName
                        << "'.";
                _statusLabel->setText(QString::fromStdString(sstream.str()));
                return {};
            }
 
            std::map<MemoryID, std::vector<PredictionEngine>> predictionEngines;
            client::QueryResult queryResult;
            try
            {
                predictionEngines = reader.getAvailablePredictionEngines();
                queryResult = reader.queryMemoryIDs({entityID}, armem::query::DataMode::NoData);
            }
            catch (const Ice::LocalException& e)
            {
                std::stringstream sstream;
                sstream << "Could not get prediction engines and type from memory: " << e.what();
                _statusLabel->setText(QString::fromStdString(sstream.str()));
                return {nullptr, {}};
            }
 
            aron::type::ObjectPtr entityType;
            if (queryResult.success)
            {
                auto* providerSegment = queryResult.memory.findProviderSegment(entityID);
                if (providerSegment != nullptr)
                {
                    entityType = providerSegment->aronType();
                }
            }
            return PredictionWidget::EntityInfo{
                .type = entityType,
                .engines = armem::accumulateEntriesContainingID(predictionEngines, entityID)};
        };
 
        _memoryGroupBoxView = new armem::gui::view::MemoryGroupBoxView(std::move(entityInfoRetriever));
        armarx::gui::replaceWidget(uiContext.memoryGroupBox, _memoryGroupBoxView, uiContext.memoryGroupBoxParentLayout);
        ARMARX_CHECK_NULL(uiContext.memoryGroupBox);
 
        connect(_memoryGroupBoxView->tree(),
                &armem::gui::MemoryTreeWidget::selectedItemChanged,
                _instanceGroupBoxController.get(),
                &InstanceGroupBoxController::updateInstanceTree);
 
        connect(_memoryGroupBoxView->predictionWidget(),
                &armem::gui::PredictionWidget::makePrediction,
                this,
                &This::onMakePrediction);
 
        connect(_memoryGroupBoxView->commitWidget(),
                &armem::gui::CommitWidget::commit,
                this,
                &This::onCommit);
 
        connect(_memoryGroupBoxView->ltmWidget(),
                &armem::gui::LTMWidget::storeInLTM,
                this,
                &This::onStoreInLTM);
 
        connect(_memoryGroupBoxView->ltmWidget(),
                &armem::gui::LTMWidget::startRecording,
                this,
                &This::onStartLTMRecording);
 
        connect(_memoryGroupBoxView->ltmWidget(),
                &armem::gui::LTMWidget::stopRecording,
                this,
                &This::onStopLTMRecording);
 
        connect(_memoryGroupBoxView->queryWidget(),
                &armem::gui::QueryWidget::activeMemoriesChanged,
                this,
                &This::updateActiveMemories);
 
        connect(_memoryGroupBoxView->queryWidget(),
                &armem::gui::QueryWidget::recursionDepthChanged,
                this,
                &This::updateRecursionDepth);
 
        connect(_memoryGroupBoxView->queryWidget(),
                &armem::gui::QueryWidget::dataModeChanged,
                this,
                &This::updateDataMode);
 
        connect(_memoryGroupBoxView->queryWidget(),
                &armem::gui::QueryWidget::dropRemovedMemoriesChanged,
                this,
                &This::updateDropRemovedMemories);
 
        connect(_memoryGroupBoxView->queryWidget(),
                &armem::gui::QueryWidget::dropDisabledMemoriesChanged,
                this,
                &This::updateDropDisabledMemories);
 
        connect(_memoryGroupBoxView->snapshotSelectorWidget(),
                &armem::gui::SnapshotSelectorWidget::selectorChanged,
                this,
                &This::updateSelector);
 
        updateActiveMemories();
        updateRecursionDepth(_memoryGroupBoxView->queryWidget()->queryLinkRecursionDepth());
        updateDataMode();
        updateDropRemovedMemories();
        updateDropDisabledMemories();
        updateSelector();
    }
 
    void
    MemoryGroupBoxController::onMakePrediction(const MemoryID& entityID,
                                               const aron::type::ObjectPtr& entityType,
                                               const armarx::DateTime& timestamp,
                                               const std::string& engineID)
    {
 
        std::stringstream errorStream;
        auto showError = [this, &errorStream]()
        { _statusLabel->setText(QString::fromStdString(errorStream.str())); };
 
        if (!entityID.hasEntityName() || entityID.hasGap())
        {
            errorStream << "Could not convert " << entityID << " to valid entity ID.";
            showError();
            return;
        }
        auto readers = _model->memoryReadersCopy();
        if (readers.find(entityID.memoryName) == readers.end())
        {
            errorStream << "Not connected to memory '" << entityID.memoryName
                        << "', cannot make prediction.";
            showError();
            return;
        }
        client::Reader reader = readers.at(entityID.memoryName);
        if (!reader.predictionPrx)
        {
            errorStream << "Predictions are not available for memory '" << entityID.memoryName
                        << "'.";
            showError();
            return;
        }
        PredictionRequest request;
        request.snapshotID = entityID.withTimestamp(timestamp);
        request.predictionSettings.predictionEngineID = engineID;
        PredictionResult result;
        try
        {
            result = reader.predict({request}).at(0);
        }
        catch (const Ice::LocalException& e)
        {
            errorStream << "Could not make prediction request: " << e.what();
            showError();
            return;
        }
 
        if (!result.success)
        {
            errorStream << "Prediction failed: " << result.errorMessage;
            showError();
            return;
        }
 
        auto* view = new AronDataView();
        _instanceGroupBoxController->instanceGroupBoxView()->instanceView()->addDataView(view);
        view->update(result.prediction, entityType);
    }
 
    void
    MemoryGroupBoxController::onCommit()
    {
        TIMING_START(Commit);
        auto now = armem::Time::Now();
 
        const std::string memoryIDStr = _memoryGroupBoxView->commitWidget()->getMemoryID();
        const std::string aronJSONStr = _memoryGroupBoxView->commitWidget()->getAronJSON();
 
        ARMARX_INFO << "Committing to " << memoryIDStr << " the data: " << aronJSONStr;
 
        MemoryID memId(memoryIDStr);
 
        if (!memId.hasEntityName())
        {
            ARMARX_WARNING << "The entered MemoryID '" << memoryIDStr
                           << "' does not contain an entity.";
        }
        else
        {
 
            nlohmann::json json = nlohmann::json::parse(aronJSONStr);
 
            // ToDo: multiple objects
            auto aron =
                aron::data::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(
                    json);
 
            auto writers = _model->memoryWritersCopy();
            if (const auto& it = writers.find(memId.memoryName); it == writers.end())
            {
                ARMARX_WARNING << "No memory with name '" << memId.memoryName
                               << "' available for commit.";
            }
            else
            {
                armem::Commit comm;
                auto& entityUpdate = comm.add();
                entityUpdate.entityID = memId;
                entityUpdate.confidence = 1.0;
                entityUpdate.instancesData = {aron};
                entityUpdate.referencedTime = now;
                it->second.commit(comm);
            }
        }
 
        TIMING_END_STREAM(Commit, ARMARX_VERBOSE);
    }
 
    void
    MemoryGroupBoxController::onStoreInLTM()
    {
        TIMING_START(MemoryStore);
 
        auto enabledMemories = _memoryGroupBoxView->ltmWidget()->getEnabledLTMMemories();
        auto memoryReaders = _model->memoryReadersCopy();
        for (auto& [name, reader] : memoryReaders)
        {
            // skip if memory should not be queried
            if (std::find(enabledMemories.begin(), enabledMemories.end(), name) ==
                enabledMemories.end())
            {
                continue;
            }
 
            // Query memory
            auto q_res = reader.query(_model->queryInput());
            if (q_res.success)
            {
                server::dto::DirectlyStoreInput input;
                input.memory = q_res.toIce().memory;
                reader.directlyStore(input);
            }
            else
            {
                std::string status = "Query of memory " + name + " was unsuccessful.";
                _statusLabel->setText(QString::fromStdString(status));
            }
        }
 
        TIMING_END_STREAM(MemoryStore, ARMARX_VERBOSE);
    }
 
    void
    MemoryGroupBoxController::onStartLTMRecording()
    {
        TIMING_START(MemoryStartRecording);
 
        auto enabledMemories = _memoryGroupBoxView->ltmWidget()->getEnabledLTMMemories();
        auto memoryReaders = _model->memoryReadersCopy();
        for (auto& [name, reader] : memoryReaders)
        {
            // skip if memory should not be queried
            if (std::find(enabledMemories.begin(), enabledMemories.end(), name) ==
                enabledMemories.end())
            {
                continue;
            }
            reader.startRecording();
        }
 
        TIMING_END_STREAM(MemoryStartRecording, ARMARX_VERBOSE);
    }
 
    void
    MemoryGroupBoxController::onStopLTMRecording()
    {
        TIMING_START(MemoryStopRecording);
 
        auto enabledMemories = _memoryGroupBoxView->ltmWidget()->getEnabledLTMMemories();
        auto memoryReaders = _model->memoryReadersCopy();
        for (auto& [name, reader] : memoryReaders)
        {
            // skip if memory should not be queried
            if (std::find(enabledMemories.begin(), enabledMemories.end(), name) ==
                enabledMemories.end())
            {
                continue;
            }
            reader.stopRecording();
        }
 
        TIMING_END_STREAM(MemoryStopRecording, ARMARX_VERBOSE);
    }
 
    void
    MemoryGroupBoxController::updateMemoryTree()
    {
        // TODO: atm after deselecting every memory, memory tree isnt updating
        std::map<std::string, const armem::wm::Memory*> memoriesToUpdate;
 
        auto checkboxStates = _model->activeMemoryStates();
        auto memoryData = _model->memoryDataCopy();
        for (auto& [name, data] : memoryData)
        {
            if (checkboxStates[name] == armem::gui::ActiveMemoryState::FoundAndChecked)
            {
                ARMARX_DEBUG << deactivateSpam(10) << "updating memory tree for " << name;
                memoriesToUpdate[name] = &data;
            }
        }
 
        TIMING_START(GuiUpdateMemoryTree)
 
        _memoryGroupBoxView->tree()->update(memoriesToUpdate);
 
        TIMING_END_STREAM(GuiUpdateMemoryTree, ARMARX_VERBOSE)
 
        if (_model->debugObserver())
        {
            try
            {
                _model->debugObserver()->setDebugDatafield(
                    Logging::tag.tagName,
                    "GUI Update [ms]",
                    new Variant(GuiUpdateMemoryTree.toMilliSecondsDouble()));
            }
            catch (const Ice::Exception&)
            {
                // Ignore ...
            }
        }
    }
 
    void
    MemoryGroupBoxController::updateActiveMemories()
    {
        _model->setActiveMemoryStates(_memoryGroupBoxView->queryWidget()->getAvailableMemoryStates());
    }
 
    void
    MemoryGroupBoxController::updateRecursionDepth(int value)
    {
        _model->setRecursionDepth(value);
    }
 
    void
    MemoryGroupBoxController::updateDataMode()
    {
        _model->setDataMode(_memoryGroupBoxView->queryWidget()->dataMode());
    }
 
    void
    MemoryGroupBoxController::updateDropRemovedMemories()
    {
        _model->setDropRemovedMemories(_memoryGroupBoxView->queryWidget()->dropRemovedMemories());
    }
 
    void
    MemoryGroupBoxController::updateDropDisabledMemories()
    {
        _model->setDropDisabledMemories(_memoryGroupBoxView->queryWidget()->dropDisabledMemories());
    }
 
    void
    MemoryGroupBoxController::updateSelector()
    {
        _model->setSelector(_memoryGroupBoxView->snapshotSelectorWidget()->selector());
    }
 
    armem::gui::view::MemoryGroupBoxView*
    MemoryGroupBoxController::memoryGroupBoxView() const
    {
        return _memoryGroupBoxView;
    }
 
    InstanceGroupBoxController* 
    MemoryGroupBoxController::instanceGroupBoxController() const
    {
        return _instanceGroupBoxController.get();
    }
    
}