framesystem.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <vector>
 
#include <viam/sdk/common/pose.hpp>
#include <viam/sdk/common/proto_convert.hpp>
#include <viam/sdk/common/proto_value.hpp>
#include <viam/sdk/common/world_state.hpp>
#include <viam/sdk/resource/resource_api.hpp>
#include <viam/sdk/services/service.hpp>
 
namespace viam {
 
namespace robot {
namespace v1 {
 
class FrameSystemConfig;
 
}  // namespace v1
}  // namespace robot
 
namespace sdk {
 
 
class FrameSystem : public Service {
   public:
    struct frame_system_config {
        WorldState::transform frame;
        ProtoStruct kinematics;
        friend bool operator==(const frame_system_config& lhs, const frame_system_config& rhs);
    };
 
    static const std::string kPublicName;
 
    static Name public_name();
 
    inline std::vector<frame_system_config> get_frame_system_config() {
        return get_frame_system_config({});
    }
 
    virtual std::vector<frame_system_config> get_frame_system_config(
        const std::vector<WorldState::transform>& additional_transforms) = 0;
 
    inline pose_in_frame get_pose(const std::string& component_name) {
        return get_pose(component_name, "world", {}, {});
    }
 
    inline pose_in_frame get_pose(
        const std::string& component_name,
        const std::string& destination_frame,
        const std::vector<WorldState::transform>& supplemental_transforms) {
        return get_pose(component_name, destination_frame, supplemental_transforms, {});
    }
 
    virtual pose_in_frame get_pose(
        const std::string& component_name,
        const std::string& destination_frame,
        const std::vector<WorldState::transform>& supplemental_transforms,
        const ProtoStruct& extra) = 0;
 
    inline pose_in_frame transform_pose(const pose_in_frame& query,
                                        const std::string& destination) {
        return transform_pose(query, destination, {});
    }
 
    virtual pose_in_frame transform_pose(
        const pose_in_frame& query,
        const std::string& destination,
        const std::vector<WorldState::transform>& additional_transforms) = 0;
 
    virtual std::vector<unsigned char> transform_pcd(const std::vector<unsigned char>& pcd,
                                                     const std::string& source,
                                                     const std::string& destination) = 0;
 
    API api() const override;
 
   protected:
    explicit FrameSystem(std::string name);
 
    explicit FrameSystem(const ResourceConfig& cfg);
};
 
template <>
struct API::traits<FrameSystem> {
    static API api();
};
 
namespace proto_convert_details {
 
template <>
struct from_proto_impl<robot::v1::FrameSystemConfig> {
    FrameSystem::frame_system_config operator()(const robot::v1::FrameSystemConfig*) const;
};
 
}  // namespace proto_convert_details
 
}  // namespace sdk
}  // namespace viam