MechEyeDataType.h

/*******************************************************************************
 *BSD 3-Clause License
 *
 *Copyright (c) 2016-2024, Mech-Mind Robotics
 *All rights reserved.
 *
 *Redistribution and use in source and binary forms, with or without
 *modification, are permitted provided that the following conditions are met:
 *
 *1. Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 *
 *2. Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 *3. Neither the name of the copyright holder nor the names of its
 *   contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 *
 *THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 *SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 *OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ******************************************************************************/
 
#pragma once
#include <string>
#include <vector>
 
namespace mmind {
 
namespace api {
 
struct ErrorStatus
{
    enum ErrorCode {
        MMIND_STATUS_SUCCESS = 0,         
        MMIND_STATUS_INVALID_DEVICE = -1, 
        MMIND_STATUS_DEVICE_OFFLINE =
            -2, 
        MMIND_STATUS_FIRMWARE_NOT_SUPPORTED =
            -3, 
        MMIND_STATUS_PARAMETER_SET_ERROR = -4,          
        MMIND_STATUS_PARAMETER_GET_ERROR = -5,          
        MMIND_STATUS_CAPTURE_NO_FRAME = -6,             
        MMIND_STATUS_INVALID_INPUT_FRAME = -7,          
        MMIND_STATUS_INVALID_INTRINSICS_PARAMETER = -8, 
        MMIND_HANDEYE_CALIBRATION_POSE_INVALID = -9,    
        MMIND_HANDEYE_CALIBRATION_PATTERN_IMAGE_ERROR =
            -10, 
        MMIND_HANDEYE_CALIBRATION_POSES_INSUFFICIENT =
            -11, 
    };
    ErrorStatus() = default;
    ErrorStatus(ErrorCode code, const std::string& message)
        : errorCode(code), errorDescription(message)
    {
    }
 
    bool isOK() const { return errorCode == MMIND_STATUS_SUCCESS; }
 
    ErrorCode errorCode{MMIND_STATUS_SUCCESS};
 
    std::string errorDescription;
};
 
struct MechEyeDeviceInfo
{
    std::string model; 
    std::string id;    
    std::string
        hardwareVersion; 
    std::string firmwareVersion; 
    std::string ipAddress;       
    uint16_t port;               
};
 
struct DeviceTemperature
{
    float cpuTemperature; 
    float projectorModuleTemperature; 
};
 
struct CameraIntri
{
    double distortion[5] = {}; 
    double cameraMatrix[4] = {}; 
};
 
struct Pose
{
    double rotation[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}; 
    double translation[3] = {0, 0, 0}; 
};
 
struct DeviceIntri
{
    CameraIntri
        textureCameraIntri; 
    CameraIntri
        depthCameraIntri; 
 
    Pose depthToTexture; 
};
 
struct DeviceResolution
{
    unsigned colorMapWidth;  
    unsigned colorMapHeight; 
    unsigned depthMapWidth;  
    unsigned depthMapHeight; 
};
 
struct ROI
{
    ROI() = default;
    ROI(int x, int y, int width, int height) : x(x), y(y), width(width), height(height) {}
    unsigned x;      
    unsigned y;      
    unsigned width;  
    unsigned height; 
};
 
struct DepthRange
{
    DepthRange() = default;
    DepthRange(int lower, int upper) : lower(lower), upper(upper) {}
    int lower; 
    int upper; 
};
 
enum class ExposureMode {
    HDR,   
    Timed, 
};
 
enum class CaptureMode {
    Raw,   
    Depth, 
};
 
enum class TriggerSource {
    Software, 
    Encoder,  
};
 
enum class ImageAnalogGain {
    AnalogGain_1_0, 
    AnalogGain_1_3, 
    AnalogGain_1_9, 
    AnalogGain_2_8, 
    AnalogGain_5_5, 
};
 
enum class ImageAnalogGainFor8030 {
    AnalogGain_1_0, 
    AnalogGain_1_3, 
    AnalogGain_2_0, 
    AnalogGain_3_0, 
};
 
enum class ROIMode {
    Mode_1_1,  
    Mode_1_2,  
    Mode_1_4,  
    Mode_1_8,  
    Mode_1_16, 
};
 
enum class EncoderTriggerMode {
    Positive, 
    Negative, 
    Duplex,   
};
 
enum class EncoderMultiplier {
    Multiple_1, 
    Multiple_2, 
    Multiple_4, 
};
 
enum class FilterType {
    None,                      
    Smoothing,                 
    Smoothing_edge_preserving, 
    Median,                    
};
 
enum class MeanFilterWindow {
    Window_Size_0,  
    Window_Size_2,  
    Window_Size_4,  
    Window_Size_8,  
    Window_Size_16, 
    Window_Size_32, 
    Window_Size_64, 
};
 
enum class MedianFilterWindow {
    Window_Size_0, 
    Window_Size_3, 
    Window_Size_5, 
    Window_Size_7, 
    Window_Size_9, 
};
 
enum class ProfileStrategy {
    Standard,  
    Near,      
    Far,       
    Continous, 
    Invalid,   
};
 
} // namespace api
} // namespace mmind