SceneEditor.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    RobotAPI::ArmarXObjects::SceneEditor
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#pragma once
 
#include <filesystem>
#include <map>
#include <mutex>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
#include <Eigen/Core>
#include <Eigen/Geometry>
 
#include <SimoxUtility/shapes/AxisAlignedBoundingBox.h>
 
#include <ArmarXCore/core/Component.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/components/ArViz/Client/Client.h>
#include <RobotAPI/components/ArViz/Client/Elements.h>
#include <RobotAPI/components/ArViz/Client/Interaction.h>
#include <RobotAPI/libraries/ArmarXObjects/ObjectFinder.h>
#include <RobotAPI/libraries/ArmarXObjects/Scene.h>
#include <RobotAPI/libraries/RobotAPIComponentPlugins/ArVizComponentPlugin.h>
 
namespace armarx
{
    class SceneEditorPropertyDefinitions : public ComponentPropertyDefinitions
    {
    public:
        SceneEditorPropertyDefinitions(std::string prefix);
    };
 
    /**
     * @defgroup Component-SceneEditor SceneEditor
     * @ingroup RobotAPI-Components
     *
     * An interactive editor for ArmarX object scenes.
     *
     * Objects from the standard ArmarX object database (found via
     * `armarx::ObjectFinder`) can be spawned, dragged in ArViz, and saved as
     * a scene JSON file (`armarx::objects::Scene` format).
     *
     * Objects are locked to a ground plane: they can only be translated in
     * x/y and rotated continuously in yaw. The ground plane is defined by a
     * scene object designated as ground (its bounding box top) or by a
     * manually set height. Objects can be flipped by 90° around each axis
     * via the RemoteGui or the context menu in ArViz. Setting coordinates
     * manually in the RemoteGui overrides the ground locking. Moves whose
     * collision meshes would intersect another object are rejected.
     */
    class SceneEditor :
        virtual public Component,
        virtual public ArVizComponentPluginUser,
        virtual public LightweightRemoteGuiComponentPluginUser
    {
    public:
        std::string getDefaultName() const override;
 
    protected:
        PropertyDefinitionsPtr createPropertyDefinitions() override;
 
        void onInitComponent() override;
        void onConnectComponent() override;
        void onDisconnectComponent() override;
        void onExitComponent() override;
 
        void RemoteGui_update() override;
        void remoteGuiUpdate();
 
    private:
        /// One object instance in the edited scene.
        struct Entry
        {
            objects::SceneObject data;
            /// If true, the pose was set manually and the entry is not locked to the ground.
            bool manualPose = false;
            /// Instance name of the ground object this entry is grounded to
            /// ("" = the default ground plane). Assigned when the entry is
            /// created or locked; changing the global ground selection later
            /// does not affect it.
            std::string groundRef;
        };
 
        struct RemoteGuiTab : RemoteGui::Client::Tab
        {
            RemoteGui::Client::ComboBox dataset;
            RemoteGui::Client::ComboBox objectClass;
            RemoteGui::Client::Button addObject;
 
            RemoteGui::Client::ComboBox groundObject;
            RemoteGui::Client::FloatSpinBox groundZ;
 
            RemoteGui::Client::Label selectedInfo;
            RemoteGui::Client::CheckBox isStatic;
            RemoteGui::Client::LineEdit instanceName;
            RemoteGui::Client::Button renameObject;
            RemoteGui::Client::FloatSpinBox posX;
            RemoteGui::Client::FloatSpinBox posY;
            RemoteGui::Client::FloatSpinBox posZ;
            RemoteGui::Client::FloatSpinBox yaw;
            RemoteGui::Client::CheckBox liveApply;
            RemoteGui::Client::Button applyPose;
            RemoteGui::Client::Button lockToGround;
            RemoteGui::Client::Button flipX;
            RemoteGui::Client::Button flipY;
            RemoteGui::Client::Button flipZ;
            RemoteGui::Client::Button deleteObject;
 
            RemoteGui::Client::ComboBox alignTarget;
            RemoteGui::Client::CheckBox alignOutside;
            RemoteGui::Client::Button frontXZ;
            RemoteGui::Client::Button backXZ;
            RemoteGui::Client::Button frontYZ;
            RemoteGui::Client::Button backYZ;
 
            RemoteGui::Client::LineEdit sceneFile;
            RemoteGui::Client::Button saveScene;
            RemoteGui::Client::Button loadScene;
            RemoteGui::Client::Button clearScene;
            RemoteGui::Client::Label status;
        };
 
        /// (Re)creates the RemoteGui tab. Combo box options (datasets,
        /// objects of the current dataset, scene instances for the ground
        /// and align reference selection) are baked into the tab, so it is
        /// rebuilt when they change.
        void createRemoteGuiTab();
 
        /// ArViz visualization and interaction loop.
        void run();
 
        // All methods below must be called with mutex_ held.
 
        Entry* findEntry(const std::string& instanceName);
        Entry& addObject(const std::string& classId);
        /// Renames the entry and updates all references to it (ground
        /// references, caches, selection). The new name is also used when
        /// the scene is saved.
        void renameEntry(Entry& entry, const std::string& newName);
        void deleteEntry(const std::string& instanceName);
        void flipEntry(Entry& entry, const Eigen::Vector3f& axis);
        void handleInteraction(const viz::InteractionFeedback& interaction);
        void applyPendingTransform(const std::string& instanceName);
        bool applyManualPose(Entry& entry, const Eigen::Vector3f& position, float yawDeg);
        void selectEntry(const std::string& instanceName);
        void setGroundZ(float groundZ);
        /// Aligns the selected object's bounding box face with the same face
        /// of the align tab's reference object: `axis` 0 aligns yz-planes
        /// (x direction), `axis` 1 aligns xz-planes (y direction); `minSide`
        /// selects the front (min) face, otherwise the back (max) face.
        void alignToPlane(int axis, bool minSide, const std::string& planeName);
 
        /// Height of the ground referenced by `ref`: the top of that
        /// object's bounding box, or the default ground plane height for "".
        float groundHeightOf(const std::string& ref);
        float groundHeightFor(const Entry& entry);
        /// Re-seats all locked entries grounded to `ref` onto their ground.
        void reseatEntriesGroundedTo(const std::string& ref);
        /// Call after an entry's pose changed: re-seats entries grounded to
        /// it and refreshes the ground height display if needed.
        void afterEntryPoseChanged(const Entry& entry);
 
        /// Returns the z coordinate for `entry`'s position such that the
        /// lowest point of its bounding box (at `candidatePose`, which
        /// determines the orientation) touches the ground plane. Falls back
        /// to placing the origin on the ground if there is no bounding box.
        float groundSnappedZ(const Entry& entry, const Eigen::Matrix4f& candidatePose);
 
        /// The object's local-frame AABB (from the object database's
        /// aabb.json, like e.g. armem_objects uses), cached per class.
        const std::optional<simox::AxisAlignedBoundingBox>& localAabbOf(const Entry& entry);
 
        /// The global axis-aligned bounding box of `entry` at `pose`: the
        /// corners of the local AABB transformed into the world frame.
        std::optional<simox::AxisAlignedBoundingBox> globalAabb(const Entry& entry,
                                                                const Eigen::Matrix4f& pose);
 
        /// Returns the instance name of the first entry whose collision mesh
        /// intersects `entry` at `candidatePose`, or "" if there is none.
        std::string collidesWith(const Entry& entry, const Eigen::Matrix4f& candidatePose);
        /// Checks whether moving `entry` to `candidatePose` is allowed and
        /// sets a status message if not. Moves of already-colliding entries
        /// are always allowed so that collisions can be resolved.
        bool isMoveAllowed(Entry& entry, const Eigen::Matrix4f& candidatePose);
        VirtualRobot::ObstaclePtr collisionModelOf(const Entry& entry);
 
        void saveScene(const std::string& fileArg);
        void loadScene(const std::string& fileArg);
        /// Resolves the (absolute) path of a scene `.json` file. `name` may be
        /// absolute (used verbatim) or relative; relative names are placed
        /// directly into SceneStorageDirectory (if set) or the ScenesPackage's
        /// scenes directory, and resolved to an absolute path.
        std::filesystem::path resolveScenePath(std::string name) const;
        /// Path of the grounding-info file accompanying `scenePath`: the same
        /// path with the last "scenes" directory component replaced by
        /// "groundings" (same file name), or a "<name>.groundings.json"
        /// sibling if the scene path has no "scenes" component.
        std::filesystem::path groundingPathFor(const std::filesystem::path& scenePath) const;
        std::string makeUniqueInstanceName(const std::string& classId);
 
        void rebuildSceneLayer();
        void rebuildGroundLayer();
 
        static float yawOf(const Eigen::Quaternionf& q);
        static Eigen::Matrix4f poseOf(const objects::SceneObject& obj);
 
    private:
        RemoteGuiTab tab_;
        RunningTask<SceneEditor>::pointer_type task_;
 
        std::mutex mutex_;
 
        std::vector<Entry> entries_;
        std::unordered_map<std::string, Eigen::Matrix4f> pendingTransforms_;
        std::map<std::string, VirtualRobot::ObstaclePtr> collisionModels_;
        std::map<std::string, std::optional<simox::AxisAlignedBoundingBox>> localAabbs_;
        std::string selected_;
 
        viz::Layer sceneLayer_;
        viz::Layer groundLayer_;
        bool sceneLayerDirty_ = true;
        bool groundLayerDirty_ = true;
        bool syncGui_ = false;
        bool tabRebuildNeeded_ = false;
        bool guiInitialized_ = false;
        std::string status_;
 
        /// Height of the default ground plane.
        float groundZ_ = 0.0f;
 
        std::map<std::string, std::vector<std::string>> objectsByDataset_;
        std::string currentDataset_;
 
        std::string objectsPackage_;
        std::string scenesPackage_;
        /// Base directory for scene storage. If empty, the ScenesPackage's
        /// data directory is used.
        std::string sceneStorageDirectory_;
        std::string initialSceneFile_;
        std::string initialGroundClass_;
        int nextId_ = 1;
 
        ObjectFinder objectFinder_;
    };
} // namespace armarx