ImageProviderGodotSimulation.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    ArmarXSimulation::components::ImageProviderGodotSimulation
 * @author     Timo Birr
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#pragma once
 
#include <mutex>
#include <string>
#include <vector>
 
#include <Eigen/Geometry>
 
#include <VirtualRobot/Robot.h>
 
#include <RobotAPI/libraries/core/remoterobot/RemoteRobot.h>
 
#include <VisionX/core/CapturingImageProvider.h>
#include <VisionX/interface/components/Calibration.h>
 
#include <arviz_godot/lib/ArVizInteractiveInterface.h>
 
namespace armarx
{
    /**
     * @defgroup Component-ImageProviderGodotSimulation ImageProviderGodotSimulation
     * @ingroup ArmarXSimulation-Components
     *
     * @class ImageProviderGodotSimulation
     * @ingroup Component-ImageProviderGodotSimulation
     * @brief A monocular image provider that renders the simulated scene using arviz_godot.
     *
     * This is a modern replacement for ImageProviderDynamicSimulation (which renders the scene
     * with the outdated Coin3D engine). Instead of rendering locally, it asks a running
     * arviz_godot instance to render the live ArViz scene (e.g. the robot and objects published
     * by the SimulatorToArviz component) from the pose of a configured robot camera node and
     * serves the resulting image as a VisionX image provider.
     *
     * Prerequisites at runtime: ArVizStorage, arviz_godot, the Simulator + SimulatorToArviz (so
     * the scene is present in Godot) and a RobotStateComponent must be running.
     */
    class ImageProviderGodotSimulation :
        virtual public visionx::CapturingImageProvider,
        virtual public visionx::MonocularCalibrationCapturingProviderInterface
    {
    public:
        static std::string
        GetDefaultName()
        {
            return "GodotSimulationImageProvider";
        }
 
        std::string
        getDefaultName() const override
        {
            return "GodotSimulationImageProvider";
        }
 
    protected:
        /// @see visionx::CapturingImageProvider::onInitCapturingImageProvider()
        void onInitCapturingImageProvider() override;
 
        /// @see visionx::CapturingImageProvider::onStartCapturingImageProvider()
        void onStartCapturingImageProvider() override;
 
        /// @see visionx::CapturingImageProvider::onExitCapturingImageProvider()
        void onExitCapturingImageProvider() override;
 
        /// @see visionx::CapturingImageProvider::onStartCapture(float frameRate)
        void onStartCapture(float frameRate) override;
 
        /// @see visionx::CapturingImageProvider::onStopCapture()
        void onStopCapture() override;
 
        bool capture(void** ppImageBuffers) override;
 
        /// @see visionx::MonocularCalibrationCapturingProviderInterface
        visionx::MonocularCalibration
        getCalibration(const Ice::Current& c = Ice::emptyCurrent) override;
 
        armarx::PropertyDefinitionsPtr createPropertyDefinitions() override;
 
    private:
        /// Resolve (or re-resolve) the RobotStateComponent clone and the arviz_godot proxy.
        bool ensureConnected();
 
        // Configuration.
        int renderWidth_ = 640;
        int renderHeight_ = 480;
        float focalLength_ = 600.f;
        float nearClipMeters_ = 0.01f;
        float farClipMeters_ = 100.f;
        std::string cameraNodeName_;
        std::string referenceFrame_;
        std::string arvizGodotName_;
        std::string robotStateComponentName_;
        int renderTimeoutMs_ = 2000;
 
        /// ArViz layers to render ("component" or "component::layer" entries). Empty = whole scene.
        std::vector<std::string> renderLayers_;
 
        /// Rotation that maps the camera node's local frame to the OpenGL camera frame
        /// (camera looks down local -Z, +Y up). Configurable to ease per-robot tuning.
        Eigen::Quaternionf cameraAlignment_ = Eigen::Quaternionf::Identity();
 
        // Runtime.
        arviz_interactive_project::components::arviz_interactive::ArVizInteractiveInterfacePrx
            arvizGodot_;
        SharedRobotInterfacePrx sharedRobot_;
        VirtualRobot::RobotPtr localRobot_;
 
        std::mutex captureMutex_;
    };
} // namespace armarx