camera.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <bitset>
#include <chrono>
#include <string>
#include <vector>
 
#include <boost/endian/conversion.hpp>
 
#if defined(__has_include) && (__has_include(<xtensor/containers/xarray.hpp>))
#include <xtensor/containers/xarray.hpp>
#else
#include <xtensor/xarray.hpp>
#endif
 
#include <viam/sdk/common/linear_algebra.hpp>
#include <viam/sdk/common/proto_value.hpp>
#include <viam/sdk/common/utils.hpp>
#include <viam/sdk/config/resource.hpp>
#include <viam/sdk/resource/resource_api.hpp>
 
namespace viam {
namespace sdk {
 
class Camera : public Component {
   public:
    struct intrinsic_parameters {
        int width_px;
        int height_px;
        double focal_x_px;
        double focal_y_px;
        double center_x_px;
        double center_y_px;
    };
 
    struct extrinsic_parameters {
        Vector3 translation;
        orientation_vector_degrees orientation;
    };
 
    struct distortion_parameters {
        std::string model;
        std::vector<double> parameters;
    };
 
    using mime_types = std::vector<std::string>;
 
    struct properties {
        bool supports_pcd;
 
        struct intrinsic_parameters intrinsic_parameters;
 
        struct extrinsic_parameters extrinsic_parameters;
 
        struct distortion_parameters distortion_parameters;
 
        Camera::mime_types mime_types;
 
        float frame_rate;
    };
 
    // TODO: update documentation to show how to deserialize a `point_cloud`
    struct point_cloud {
        std::string mime_type;
        std::vector<unsigned char> pc;
    };
 
    const static std::string lazy_suffix;
 
    // TODO: update documentaiton to show how to deserialize a `raw_image`
    struct raw_image {
        std::string mime_type;
        std::vector<unsigned char> bytes;
        std::string source_name;
    };
 
    struct image_collection {
        std::vector<raw_image> images;
        response_metadata metadata;
    };
 
    using depth_map = xt::xarray<uint16_t>;
 
    static std::vector<unsigned char> encode_depth_map(const Camera::depth_map& m);
 
    static Camera::depth_map decode_depth_map(const std::vector<unsigned char>& data);
 
    static std::string normalize_mime_type(const std::string& str);
 
    virtual ProtoStruct do_command(const ProtoStruct& command) = 0;
 
    inline image_collection get_images() {
        return get_images({}, {});
    }
 
    inline image_collection get_images(std::vector<std::string> filter_source_names) {
        return get_images(std::move(filter_source_names), {});
    }
 
    virtual image_collection get_images(std::vector<std::string> filter_source_names,
                                        const ProtoStruct& extra) = 0;
 
    inline point_cloud get_point_cloud(std::string mime_type) {
        return get_point_cloud(std::move(mime_type), {});
    }
 
    virtual point_cloud get_point_cloud(std::string mime_type, const ProtoStruct& extra) = 0;
 
    inline std::vector<GeometryConfig> get_geometries() {
        return get_geometries({});
    }
 
    virtual std::vector<GeometryConfig> get_geometries(const ProtoStruct& extra) = 0;
 
    virtual properties get_properties() = 0;
 
    API api() const override;
 
   protected:
    explicit Camera(std::string name);
};
 
template <>
struct API::traits<Camera> {
    static API api();
};
 
bool operator==(const Camera::raw_image& lhs, const Camera::raw_image& rhs);
bool operator==(const Camera::image_collection& lhs, const Camera::image_collection& rhs);
bool operator==(const Camera::point_cloud& lhs, const Camera::point_cloud& rhs);
bool operator==(const Camera::intrinsic_parameters& lhs, const Camera::intrinsic_parameters& rhs);
bool operator==(const Camera::extrinsic_parameters& lhs, const Camera::extrinsic_parameters& rhs);
bool operator==(const Camera::distortion_parameters& lhs, const Camera::distortion_parameters& rhs);
bool operator==(const Camera::properties& lhs, const Camera::properties& rhs);
 
}  // namespace sdk
}  // namespace viam