types.hpp

Go to the documentation of this file.

#pragma once
 
#include "leia/common/api.h"
#include "leia/common/types.h"
 
#include <string_view>
#include <string>
#include <array>
 
namespace leia {
 
enum FaceDetectorBackend {
    kLeiaFaceDetectorBackendUnknown = 0,
    kLeiaFaceDetectorBackendCPU     = 1 << 0,
    kLeiaFaceDetectorBackendGPU     = 1 << 1,
    kLeiaFaceDetectorBackendDSP     = 1 << 2,
 
    kNumLeiaFaceDetectorBackends = 3,
};
 
enum FaceDetectorInputType {
    kLeiaFaceDetectorInputTypeUnknown = 0,
    kLeiaFaceDetectorInputTypeCPU     = 1 << 0,
    kLeiaFaceDetectorInputTypeGPU     = 1 << 1,
 
    kNumLeiaFaceDetectorInputTypes = 2,
};
 
struct FaceDetectorConfig {
    enum FaceDetectorBackend   backend;
    enum FaceDetectorInputType inputType;
};
 
using Timestamp        = leia_timestamp;
using TimestampSpace   = leia_timestamp_space;
using ImageDesc        = leia_image_desc;
using CameraIntrinsics = leia_camera_intrinsics;
using Orientation      = leia_orientation;
 
LEIA_NODISCARD
LEIA_FORCE_INLINE const char* ToStr(FaceDetectorBackend backend)
{
    switch (backend)
    {
        case kLeiaFaceDetectorBackendCPU:
            return "kLeiaFaceDetectorBackendCPU";
        case kLeiaFaceDetectorBackendGPU:
            return "kLeiaFaceDetectorBackendGPU";
        case kLeiaFaceDetectorBackendDSP:
            return "kLeiaFaceDetectorBackendDSP";
        default:
            return "kLeiaFaceDetectorBackendUnknown";
    }
}
LEIA_NODISCARD
LEIA_FORCE_INLINE const char* ToUiStr(FaceDetectorBackend backend)
{
    switch (backend)
    {
        case kLeiaFaceDetectorBackendCPU:
            return "CPU";
        case kLeiaFaceDetectorBackendGPU:
            return "GPU";
        case kLeiaFaceDetectorBackendDSP:
            return "DSP";
        default:
            return "Unknown";
    }
}
LEIA_NODISCARD
LEIA_FORCE_INLINE const char* ToStr(FaceDetectorInputType inputType)
{
    switch (inputType)
    {
        case kLeiaFaceDetectorInputTypeCPU:
            return "kLeiaFaceDetectorInputTypeCPU";
        case kLeiaFaceDetectorInputTypeGPU:
            return "kLeiaFaceDetectorInputTypeGPU";
        default:
            return "kLeiaFaceDetectorInputTypeUnknown";
    }
}
LEIA_NODISCARD
LEIA_FORCE_INLINE const char* ToUiStr(FaceDetectorInputType inputType)
{
    switch (inputType)
    {
        case kLeiaFaceDetectorInputTypeCPU:
            return "CPU";
        case kLeiaFaceDetectorInputTypeGPU:
            return "GPU";
        default:
            return "Unknown";
    }
}
LEIA_NODISCARD
LEIA_FORCE_INLINE const char* ToUiStr(Orientation orientation)
{
    return leia_orientation_to_ui_str(orientation);
}
 
inline bool FromStr(std::string_view const& str, Orientation* out)
{
    if (str == "Landscape")
    {
        *out = LEIA_ORIENTATION_LANDSCAPE;
    }
    else if (str == "Portrait")
    {
        *out = LEIA_ORIENTATION_PORTRAIT;
    }
    else if (str == "ReverseLandscape")
    {
        *out = LEIA_ORIENTATION_REVERSE_LANDSCAPE;
    }
    else if (str == "ReversePortrait")
    {
        *out = LEIA_ORIENTATION_REVERSE_PORTRAIT;
    }
    else
    {
        return false;
    }
    return true;
}
 
inline constexpr bool IsValid(Orientation orientation)
{
    return orientation >= LEIA_ORIENTATION_LANDSCAPE && orientation <= LEIA_ORIENTATION_REVERSE_PORTRAIT;
}
 
inline constexpr int32_t GetRelativeClockwiseAngle(Orientation from, Orientation to)
{
    if (!IsValid(from) || !IsValid(to))
    {
        return 0;
    }
 
    int32_t numSteps = 0;
    int32_t it       = int32_t(from);
    int32_t end      = int32_t(to);
    while (it != end)
    {
        it = (it + 1) % LEIA_ORIENTATION_COUNT;
        numSteps++;
    }
    return numSteps * 90;
}
 
static_assert(GetRelativeClockwiseAngle(LEIA_ORIENTATION_LANDSCAPE, LEIA_ORIENTATION_LANDSCAPE) == 0);
static_assert(GetRelativeClockwiseAngle(LEIA_ORIENTATION_LANDSCAPE, LEIA_ORIENTATION_PORTRAIT) == 90);
static_assert(GetRelativeClockwiseAngle(LEIA_ORIENTATION_LANDSCAPE, LEIA_ORIENTATION_REVERSE_PORTRAIT) == 270);
static_assert(GetRelativeClockwiseAngle(LEIA_ORIENTATION_REVERSE_LANDSCAPE, LEIA_ORIENTATION_LANDSCAPE) == 180);
 
// Want to keep it trivially copyable, so using this struct instead of std::string.
struct CameraID {
    enum {
        kMaxSize = 16
    };
 
    CameraID()
    {
        std::memset(v, 0, sizeof(v));
    }
    CameraID(int id) : CameraID()
    {
        std::string str = std::to_string(id);
        std::memcpy(v, str.data(), std::min(str.size(), sizeof(v)));
    }
    CameraID(std::string_view const& str) : CameraID()
    {
        std::memcpy(v, str.data(), std::min(str.size(), sizeof(v)));
    }
 
    explicit operator std::string_view() const
    {
        return {v, strnlen(v, sizeof(v))};
    }
    explicit operator bool() const
    {
        return *v != '\0';
    }
    bool operator==(CameraID const& rhs) const
    {
        return std::string_view{*this} == std::string_view{rhs};
    }
 
private:
    char v[kMaxSize];
};
static_assert(std::is_trivially_copyable_v<CameraID>);
 
struct Camera {
    CameraID                      id;
    bool                          frontFacing;
    Orientation                   sensorOrientation = LEIA_ORIENTATION_UNSPECIFIED;
    std::array<float, 3>          translation;
    std::array<float, 3>          rotation;
    struct leia_camera_intrinsics intrinsics;
};
 
struct TrackingCamera {
    CameraID             cameraId;
    Camera*              camera = nullptr;
    int32_t              width;
    int32_t              height;
    int32_t              fps;
    std::array<float, 4> filterParams;
    float                headPoseZLowPassAlpha;
};
 
} // namespace leia