SetCustomGazeTarget.cpp

Go to the documentation of this file.

#include "SetCustomGazeTarget.h"
 
#include <memory>
#include <string>
 
#include <Eigen/Core>
#include <Eigen/Geometry>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/time/Duration.h>
 
#include <RobotAPI/libraries/core/FramedPose.h>
#include <RobotAPI/libraries/skills/core/Skill.h>
#include <RobotAPI/libraries/skills/core/SkillDescription.h>
#include <RobotAPI/libraries/skills/core/SkillID.h>
#include <RobotAPI/libraries/skills/core/SkillStatusUpdate.h>
 
#include <armarx/view_selection/gaze_targets/AttentionType.h>
#include <armarx/view_selection/gaze_targets/GazeTarget.h>
#include <armarx/view_selection/gaze_targets/TargetPriority.h>
#include <armarx/view_selection/skills/commit_and_wait.h>
#include <armarx/view_selection/skills/constants.h>
 
namespace armarx::view_selection::skills
{
 
    SetCustomGazeTarget::SetCustomGazeTarget(const Context& services) :
        Base(DefaultSkillDescription()), srv_(services)
    {
        ;
    }
 
    void
    SetCustomGazeTarget::connect(const Context& srv)
    {
        srv_.emplace(srv);
    }
 
    ::armarx::skills::Skill::InitResult
    SetCustomGazeTarget::init(const Base::SpecializedInitInput& in)
    {
        gazeTarget.emplace(); // populate optional
        std::string frame = in.parameters.frame;
        std::string agent = in.parameters.agent;
        FramedPosition targetPos{
            Eigen::Vector3f{in.parameters.x, in.parameters.y, in.parameters.z}, frame, agent};
        gaze_targets::TargetPriority priority{gaze_targets::AttentionType::TaskDriven,
                                              in.parameters.priority};
        armarx::core::time::Duration duration =
            armarx::core::time::Duration::MilliSeconds(in.parameters.duration_ms);
        gaze_targets::GazeTarget target{
            in.parameters.gazeTargetName, targetPos, priority, duration, false};
        gazeTarget.emplace(target);
 
        //fromAron(in.params.target, gazeTarget.value());
 
        return ::armarx::skills::Skill::InitResult{
            .status = ::armarx::skills::TerminatedSkillStatus::Succeeded};
    }
 
    ::armarx::skills::Skill::MainResult
    SetCustomGazeTarget::main(const Base::SpecializedMainInput& in)
    {
        ARMARX_CHECK(gazeTarget.has_value());
 
        return commitAndMaybeWait(srv_->viewSelectionClient,
                                  gazeTarget.value(),
                                  in.parameters.waitUntilFinished,
                                  in.parameters.waitTimeout_ms,
                                  [this]() { return shouldSkillTerminate(); });
    }
 
    void
    SetCustomGazeTarget::onStopRequested()
    {
        if (gazeTarget.has_value())
        {
            srv_->viewSelectionClient.commitGazeTarget(gazeTarget.value());
        }
    }
 
    armarx::skills::SkillDescription
    SetCustomGazeTarget::DefaultSkillDescription()
    {
        ParamType defaultParameters;
        defaultParameters.frame = "root";
        defaultParameters.agent = "Armar7";
        defaultParameters.gazeTargetName = "SetCustomGazeTarget";
        defaultParameters.priority = 1;
        defaultParameters.duration_ms = 1000;
        defaultParameters.x = 0;
        defaultParameters.y = 1500;
        defaultParameters.z = 1500;
        // waitUntilFinished must be "false" for legacy reasons.  The parameter has been
        // retrospectively introduced and this makes it backwards-compatible.
        defaultParameters.waitUntilFinished = false;
        // The aron default for the timeout is "wait forever"; the root profile supplies a sane
        // bound so a caller that does not think about it still gets one.
        defaultParameters.waitTimeout_ms = 10000;
        return armarx::skills::SkillDescription{
            .skillId =
                armarx::skills::SkillID{.skillName = constants::skill_names::SetCustomGazeTarget},
            .description = "Set a gaze target by coordinate, agent and frame. Supported frames "
                           "include the Global frame and the robot root frames. With "
                           "waitUntilFinished, the skill blocks until the robot's gaze is fixed on "
                           "the target and fails if it never gets there.",
            .rootProfileDefaults = defaultParameters.toAron(),
            // Generous: the caller's waitTimeout_ms is the real bound, this is only a backstop
            // (navigation's blocking NavigateTo uses an hour for the same reason).
            .timeout = armarx::core::time::Duration::Hours(1),
            .parametersType = Params::ToAronType(),
        };
    }
 
 
} // namespace armarx::view_selection::skills