Component.h

Go to the documentation of this file.

/**
 * This file is part of ArmarX.
 *
 * 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    navigation::ArmarXObjects::room_editor
 * @author     Fabian Reister ( fabian dot reister at kit dot edu )
 * @date       2026
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#pragma once
 
#include <atomic>
#include <memory>
#include <mutex>
#include <string>
 
#include <Ice/Current.h>
 
#include <ArmarXCore/core/Component.h>
#include <ArmarXCore/core/application/properties/PropertyDefinitionContainer.h>
#include <ArmarXCore/core/services/tasks/RunningTask.h>
 
#include <ArmarXGui/libraries/ArmarXGuiComponentPlugins/LightweightRemoteGuiComponentPlugin.h>
#include <ArmarXGui/libraries/RemoteGui/Client/Tab.h>
#include <ArmarXGui/libraries/RemoteGui/Client/Widgets.h>
 
#include <RobotAPI/libraries/RobotAPIComponentPlugins/ArVizComponentPlugin.h>
#include <RobotAPI/libraries/armem/client/plugins/ReaderWriterPlugin.h>
 
#include <armarx/navigation/components/room_editor/ComponentInterface.h>
#include <armarx/navigation/components/room_editor/RoomEditor.h>
#include <armarx/navigation/memory/client/rooms/Reader.h>
#include <armarx/navigation/memory/client/rooms/Writer.h>
 
namespace armarx::navigation::components::room_editor
{
 
    /**
     * @defgroup Component-room_editor room_editor
     * @ingroup armarx_navigation-Components
     *
     * An interactive ArViz front-end for the room polygons stored in the navigation memory.
     *
     * Rooms are read from the `Rooms` core segment of the navigation memory and visualized
     * in ArViz. Every polygon vertex is a draggable handle, restricted to the XY plane.
     * Additional handles on the edge midpoints allow cutting an edge, i.e. inserting a new
     * vertex in between two existing ones (either by dragging the handle to the desired
     * position or via its context menu).
     *
     * Every modification is written back into the navigation memory immediately. Once the
     * rooms have the desired shape, they can be dumped back into the `rooms.json` file of
     * the navigation graph (analogously to the location export of the LocationGraphEditor).
     *
     * @class Component
     * @ingroup Component-room_editor
     * @brief Interactive ArViz-based editor for room polygons.
     */
    class Component :
        virtual public armarx::Component,
        virtual public armarx::navigation::components::room_editor::ComponentInterface,
        virtual public armarx::LightweightRemoteGuiComponentPluginUser,
        virtual public armarx::ArVizComponentPluginUser
    {
    public:
        Component();
 
        /// @see armarx::ManagedIceObject::getDefaultName()
        std::string getDefaultName() const override;
 
        /// Get the component's default name.
        static std::string GetDefaultName();
 
        // ComponentInterface
        void reloadFromMemory(const Ice::Current& current) override;
        bool exportToJson(const Ice::Current& current) override;
 
    protected:
        /// @see PropertyUser::createPropertyDefinitions()
        armarx::PropertyDefinitionsPtr createPropertyDefinitions() override;
 
        /// @see armarx::ManagedIceObject::onInitComponent()
        void onInitComponent() override;
 
        /// @see armarx::ManagedIceObject::onConnectComponent()
        void onConnectComponent() override;
 
        /// @see armarx::ManagedIceObject::onDisconnectComponent()
        void onDisconnectComponent() override;
 
        /// @see armarx::ManagedIceObject::onExitComponent()
        void onExitComponent() override;
 
        void createRemoteGuiTab();
 
        /// @see armarx::LightweightRemoteGuiComponentPluginUser::RemoteGui_update()
        void RemoteGui_update() override;
 
    private:
        /// The interaction loop: commits the ArViz layers and handles the user's interactions.
        void run();
 
        /// Reads the rooms from the memory and hands them over to the editor.
        bool reload();
 
        /// Writes a single (modified) room back into the navigation memory.
        void storeRoom(const EditableRoom& room);
 
        /// Triggers the JSON export in the navigation memory.
        bool exportRooms();
 
    private:
        static const std::string defaultName;
 
        /// Properties shown in the Scenario GUI.
        struct Properties
        {
            /// If set, only the rooms of this provider segment (navigation graph) are edited.
            std::string providerSegmentName = "";
 
            /// Rate of the ArViz interaction loop [Hz].
            float updateRate = 20.F;
 
            /// ArViz layer prefix.
            std::string layerPrefix = "RoomEditor";
 
            /// Radius of the vertex handles [mm].
            float vertexHandleRadius = 75.F;
 
            /// Edge length of the edge handles [mm].
            float edgeHandleSize = 90.F;
 
            /// Package the rooms are exported to.
            std::string exportPackageName = "PriorKnowledgeData";
 
            /// Directory (relative to the package's data directory) the rooms are exported to.
            std::string exportDirectory = "navigation-graphs";
        };
 
        Properties properties;
 
        std::unique_ptr<RoomEditor> editor;
 
        RunningTask<Component>::pointer_type task;
 
        std::atomic_bool reloadRequested{false};
 
        /// Number of rooms currently being edited (for the Remote GUI status label).
        std::atomic_int numRooms{0};
 
        /// Guards the export path, which can be changed via the Remote GUI.
        std::mutex exportPathMutex;
 
        /// Tab shown in the Remote GUI.
        struct RemoteGuiTab : armarx::RemoteGui::Client::Tab
        {
            armarx::RemoteGui::Client::Label statusLabel;
            armarx::RemoteGui::Client::Button reloadButton;
 
            armarx::RemoteGui::Client::LineEdit exportPackageName;
            armarx::RemoteGui::Client::LineEdit exportDirectory;
            armarx::RemoteGui::Client::Button exportButton;
            armarx::RemoteGui::Client::Label exportLabel;
        };
 
        RemoteGuiTab tab;
 
        armem::client::plugins::ReaderWriterPlugin<memory::client::rooms::Reader>*
            roomsReaderPlugin = nullptr;
        armem::client::plugins::ReaderWriterPlugin<memory::client::rooms::Writer>*
            roomsWriterPlugin = nullptr;
    };
 
} // namespace armarx::navigation::components::room_editor