RVC.h

// Copyright (c) RVBUST, Inc - All rights reserved.
#pragma once

#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

#include <string>
#include <vector>

// Define EXPORTED for any platform
#if defined _WIN32 || defined __CYGWIN__
#ifdef RVC_WIN_EXPORT
#ifdef __GNUC__
#define RVC_EXPORT __attribute__((dllexport))
#else
#define RVC_EXPORT __declspec(dllexport)  // Note: actually gcc seems to also supports this syntax.
#endif
#else
#ifdef __GNUC__
#define RVC_EXPORT __attribute__((dllimport))
#else
#define RVC_EXPORT __declspec(dllimport)  // Note: actually gcc seems to also supports this syntax.
#endif
#endif
#define RVC_NOT_EXPORT
#else
#if __GNUC__ >= 4
#define RVC_EXPORT __attribute__((visibility("default")))
#define RVC_NOT_EXPORT __attribute__((visibility("hidden")))
#else
#define RVC_EXPORT
#define RVC_NOT_EXPORT
#endif
#endif

namespace RVC {
typedef uint32_t HandleID;
struct RVC_EXPORT Handle {
    Handle() : sid(0), gid(0) {}
    Handle(HandleID sid_, HandleID gid_) : sid(sid_), gid(gid_) {}
    Handle(const Handle &rhs) : sid(rhs.sid), gid(rhs.gid) {}
    Handle &operator=(const Handle &rhs) {
        sid = rhs.sid;
        gid = rhs.gid;
        return *this;
    }
    inline bool operator==(const Handle &rhs) { return sid == rhs.sid && gid == rhs.gid; }
    inline bool operator!=(const Handle &rhs) { return sid != rhs.sid || gid != rhs.gid; }

    HandleID sid;
    HandleID gid;
};

struct RVC_EXPORT Size {
    Size() : width(0), height(0) {}
    Size(int w, int h) : width(w), height(h) {}
    union {
        int32_t width, cols;
    };
    union {
        int32_t height, rows;
    };
};

inline bool operator==(const Size &lhs, const Size &rhs) {
    return lhs.width == rhs.width && lhs.height == rhs.height;
}
inline bool operator!=(const Size &lhs, const Size &rhs) {
    return lhs.width != rhs.width || lhs.height != rhs.height;
}

struct RVC_EXPORT ROI {
    ROI() : x(0), y(0), width(0), height(0) {}
    ROI(int x, int y, int w, int h) : x(x), y(y), width(w), height(h) {}
    int x;
    int y;
    int width;
    int height;
};

struct RVC_EXPORT ROIRange {
    int x_step;
    int y_step;
    int width_step;
    int height_step;
    int width_min;
    int height_min;
    int width_max;
    int height_max;
};

inline bool operator==(const ROI &lhs, const ROI &rhs) {
    return lhs.width == rhs.width && lhs.height == rhs.height && lhs.x == rhs.x && lhs.y == rhs.y;
}

inline bool operator!=(const ROI &lhs, const ROI &rhs) {
    return lhs.width != rhs.width || lhs.height != rhs.height || lhs.x != rhs.x || lhs.y != rhs.y;
}
struct RVC_EXPORT ImageType {
    enum Enum {
        None = 0,
        Mono8 = 1,
        RGB8 = 2,
        BGR8 = 3,
    };
    static const char *ToString(ImageType::Enum type);
    static size_t GetPixelSize(ImageType::Enum type);
};

struct RVC_EXPORT Image {
    static Image Create(ImageType::Enum it, const Size sz, unsigned char *data = nullptr, bool own_data = true);
    static Image CreateFromFile(const char *addr);
    static void Destroy(Image img, bool no_reuse = true);
    Image Clone() const;
    bool IsValid() const;
    Size GetSize() const;
    ImageType::Enum GetType() const;
    unsigned char *GetDataPtr() const;
    const unsigned char *GetDataConstPtr() const;
    bool SaveImage(const char *addr) const;
    Handle m_handle;
};

struct RVC_EXPORT DepthMap {
    static DepthMap Create(const Size sz, double *data = nullptr, bool own_data = true);

    static void Destroy(DepthMap depthmap, bool no_reuse = true);

    bool IsValid();
    Size GetSize();
    double *GetDataPtr();
    const double *GetDataConstPtr();

    bool SaveDepthMap(const char *address, bool is_m = true);

    Handle m_handle;
};

struct RVC_EXPORT ConfidenceMap {
    static ConfidenceMap Create(const Size sz, double *data = nullptr, bool own_data = true);

    static void Destroy(ConfidenceMap confidencemap, bool no_reuse = true);

    bool IsValid();

    Size GetSize();
    double *GetDataPtr();
    const double *GetDataConstPtr();

    Handle m_handle;
};

struct RVC_EXPORT PointMapType {
    enum Enum {
        None = 0,
        PointsOnly = 1,
        PointsNormals = 2,
    };
    static const char *ToString(enum Enum e);
};

struct RVC_EXPORT PointMapUnit {
    enum Enum {
        Meter = 0,
        Millimeter = 1,
    };
    static const char *ToString(Enum e);
};

struct RVC_EXPORT PointMap {
    static PointMap Create(PointMapType::Enum pmt, const Size size, double *data = nullptr, bool owndata = true);
    static PointMap CreateFromFile(const char *fileName, const Size sz, const PointMapUnit::Enum unit);
    static void Destroy(PointMap pm, bool no_reuse = true);
    bool Save(const char *fileName, const PointMapUnit::Enum unit, const bool isBinary,
              const Image &rawImage = Image());
    bool IsValid() const;
    Size GetSize() const;
    double *GetPointDataPtr();
    double *GetNormalDataPtr();
    const double *GetPointDataConstPtr() const;
    const double *GetNormalDataConstPtr() const;

    bool GetPointMapSeperated(double *x, double *y, double *z, const double scale = 1.0);

    /*
     * @brief clone the point data
     * return PointMap
     */

    PointMap Clone() const;
    Handle m_handle;
};

struct RVC_EXPORT CorrespondMap {
    static CorrespondMap Create(const Size sz, double *data = nullptr, bool own_data = true);
    static void Destroy(CorrespondMap correspondMap, bool no_reuse = true);

    bool IsValid();
    Size GetSize();
    double *GetDataPtr();
    const double *GetDataConstPtr();

    Handle m_handle;
};

RVC_EXPORT int GetLastError();

RVC_EXPORT const char *GetVersion();

RVC_EXPORT const char *GetLastErrorMessage();

enum CameraID {
    CameraID_NONE = 0,
    CameraID_0 = 1 << 0,
    CameraID_1 = 1 << 1,
    CameraID_2 = 1 << 2,
    CameraID_3 = 1 << 3,
    CameraID_Left = CameraID_0,
    CameraID_Right = CameraID_1,
    CameraID_Both = CameraID_Left | CameraID_Right,
    CameraID_Extra = CameraID_2
};

enum PortType {
    PortType_NONE = 0,
    PortType_USB = 1,
    PortType_GIGE = 2,
};

enum NetworkType {
    NetworkType_DHCP = 0,
    NetworkType_STATIC = 1,
};

enum ProjectorColor {
    ProjectorColor_None = 0,
    ProjectorColor_Red = 1,
    ProjectorColor_Green = 2,
    ProjectorColor_Blue = 4,
    ProjectorColor_White = 8,
    ProjectorColor_ALL = ProjectorColor_Red | ProjectorColor_Green | ProjectorColor_Blue | ProjectorColor_White,
};

enum ProtectiveCoverStatus {
    ProtectiveCoverStatus_Unknown = 0,
    ProtectiveCoverStatus_Closed = 1,
    ProtectiveCoverStatus_Closing = 2,
    ProtectiveCoverStatus_Open = 3,
    ProtectiveCoverStatus_Opening = 4,
};

enum BalanceSelector {
    BalanceSelector_None = 0,
    BalanceSelector_Red,
    BalanceSelector_Green,
    BalanceSelector_Blue,
};

enum NetworkDevice {
    NetworkDevice_LightMachine = 0,
    NetworkDevice_LeftCamera = 1,
    NetworkDevice_RightCamera = 2,
    NetworkDevice_ExtraCamera = 3,
};

enum NetworkDeviceStatus_ {
    NetworkDeviceStatus_OK,
    NetworkDeviceStatus_Not_Reachable,
    NetworkDeviceStatus_In_Use,
    NetworkDeviceStatus_Conflict,
};

enum CaptureMode {
    CaptureMode_Fast = 1 << 0,
    CaptureMode_Normal = 1 << 1,
    CaptureMode_Ultra = 1 << 2,
    CaptureMode_Robust = 1 << 3,  // [deprecated] CaptureMode_Robust is deprecated! Use scan_times instead.
    CaptureMode_AntiInterReflection = 1 << 4,
    CaptureMode_SwingLineScan = 1 << 5,
    CaptureMode_FixedLineScan = 1 << 6,
    CaptureMode_LineArrayShift = 1 << 7,
    CaptureMode_All = CaptureMode_Fast | CaptureMode_Normal | CaptureMode_Ultra | CaptureMode_Robust |
                      CaptureMode_AntiInterReflection | CaptureMode_SwingLineScan | CaptureMode_FixedLineScan |
                      CaptureMode_LineArrayShift,
};

struct RVC_EXPORT DeviceInfo {
    char name[32];
    char sn[32];
    char factroydate[32];
    char port[32];
    enum PortType type;
    enum CameraID cameraid;
    int boardmodel;
    bool support_x2;
    enum ProjectorColor support_color;
    int workingdist_near_mm;
    int workingdist_far_mm;
    char firmware_version[128];
    enum CaptureMode support_capture_mode;
    bool support_x1;
    bool support_protective_cover;
    bool support_extra;
};

struct RVC_EXPORT Device {
    static void Destroy(Device d);
    bool IsValid() const;
    void Print() const;
    bool GetDeviceInfo(DeviceInfo *pinfo);
    int SetNetworkConfig(enum NetworkDevice d, NetworkType type, const char *ip, const char *netMask,
                         const char *gateway);
    int GetNetworkConfig(enum NetworkDevice d, NetworkType *type, char *ip, char *netMask, char *gateway, int *status);
    bool UpgradeFirmware(const char *device_firmware_path, const char *config_data_path);
    bool IsFirmwareMatch(void);
    Handle m_handle;
};

struct RVC_EXPORT SystemListDeviceType {
    enum Enum {
        None = 0,
        USB = 1 << 0,
        GigE = 1 << 1,
        All = USB | GigE,
    };
    static const char *ToString(const SystemListDeviceType::Enum e);
};

RVC_EXPORT bool SystemInit();
RVC_EXPORT bool SystemIsInited();
RVC_EXPORT void SystemShutdown();


RVC_EXPORT int SystemListDevices(Device *pdevices, size_t size, size_t *actual_size,
                                 SystemListDeviceType::Enum opt = SystemListDeviceType::All);

RVC_EXPORT Device SystemFindDevice(const char *serialNumber);

RVC_EXPORT void SystemSetLoggerName(const char *loggerName);



enum CameraTempSelector {
    CameraTempSelector_Camera,
    CameraTempSelector_CoreBoard,
    CameraTempSelector_FpgaCore,
    CameraTempSelector_Framegrabberboard,
    CameraTempSelector_Sensor,
    CameraTempSelector_SensorBoard,
};

enum SmoothnessLevel { SmoothnessLevel_Off, SmoothnessLevel_Weak, SmoothnessLevel_Normal, SmoothnessLevel_Strong };

// UserPtr
typedef void *UserPtr;

struct RVC_EXPORT X1 {
    struct CaptureOptions {
        CaptureOptions() {
            calc_normal = false;
            transform_to_camera = true;
            use_auto_noise_removal = true;
            noise_removal_distance = 0;
            noise_removal_point_number = 40;
            light_contrast_threshold = 3;
            phase_filter_range = 0;
            projector_brightness = 240;
            exposure_time_2d = 11;
            exposure_time_3d = 11;
            gain_2d = 0.f;
            gain_3d = 0.f;
            hdr_exposure_times = 0;
            hdr_exposuretime_content[0] = 11;
            hdr_exposuretime_content[1] = 20;
            hdr_exposuretime_content[2] = 50;
            hdr_gain_3d[0] = 0;
            hdr_gain_3d[1] = 0;
            hdr_gain_3d[2] = 0;

            hdr_scan_times[0] = 1;
            hdr_scan_times[1] = 1;
            hdr_scan_times[2] = 1;

            hdr_projector_brightness[0] = 240;
            hdr_projector_brightness[1] = 240;
            hdr_projector_brightness[2] = 240;
            calc_normal_radius = 5;
            gamma_2d = 1.f;
            gamma_3d = 1.f;
            use_projector_capturing_2d_image = true;
            smoothness = SmoothnessLevel_Off;
            downsample_distance = 0.0;
            capture_mode = CaptureMode_Normal;
            confidence_threshold = 0;
            roi = RVC::ROI();
            truncate_z_min = -9999.f;
            truncate_z_max = 9999.f;
            bilateral_filter_kernal_size = 0;
            bilateral_filter_depth_sigma = 0;
            bilateral_filter_space_sigma = 0;
            scan_times = 1;
            use_auto_bilateral_filter = true;
            reflection_filter_threshold = 0;
            smooth_sigma = 1.75;
            enable_2d_in_capture = true;
        }
        bool calc_normal;
        bool transform_to_camera;
        [[deprecated]] int filter_range;
        bool use_auto_noise_removal;
        double noise_removal_distance;
        int noise_removal_point_number;
        int light_contrast_threshold;
        int phase_filter_range;
        int exposure_time_2d;
        int exposure_time_3d;
        int projector_brightness;
        float gain_2d;
        float gain_3d;
        int hdr_exposure_times;
        int hdr_exposuretime_content[3];
        float hdr_gain_3d[3];

        int hdr_scan_times[3];

        int hdr_projector_brightness[3];
        unsigned int calc_normal_radius;
        float gamma_2d;
        float gamma_3d;
        bool use_projector_capturing_2d_image;
        [[deprecated(
            "smoothness has been deprecated in CPU version,use smooth_sigma instead")]] SmoothnessLevel smoothness;

        double downsample_distance;

        CaptureMode capture_mode;

        double confidence_threshold;

        RVC::ROI roi;

        double truncate_z_min;

        double truncate_z_max;

        [[deprecated("Use smooth_sigma instead")]] int bilateral_filter_kernal_size;

        [[deprecated("Use smooth_sigma instead")]] double bilateral_filter_depth_sigma;

        [[deprecated("Use smooth_sigma instead")]] double bilateral_filter_space_sigma;

        int scan_times;

        [[deprecated("Use smooth_sigma instead")]] bool use_auto_bilateral_filter;

        int reflection_filter_threshold;

        double smooth_sigma;

        bool enable_2d_in_capture;
    };
    struct CustomTransformOptions {
        enum CoordinateSelect {
            CoordinateSelect_Disabled,
            CoordinateSelect_Camera,
            CoordinateSelect_CaliBoard,
        };

        CustomTransformOptions()
            : coordinate_select(CoordinateSelect_Disabled), transform{1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1} {}

        CoordinateSelect coordinate_select;

        double transform[16];
    };

    struct CollectionCallBackInfo {
        Image image;
    };

    struct CalculationCallBackInfo {
        Image image;
        PointMap pointmap;
        DepthMap depthmap;
        ConfidenceMap confidencemap;
    };

    typedef void (*CollectionCallBackPtr)(X1::CollectionCallBackInfo, X1::CaptureOptions, UserPtr);
    typedef void (*CalculationCallBackPtr)(X1::CalculationCallBackInfo, X1::CaptureOptions, UserPtr);

    static X1 Create(const Device &d, enum CameraID camid = CameraID_Left);
    static void Destroy(X1 &x);
    bool IsValid();
    bool Open();
    void Close();
    bool IsOpen();
    bool IsPhysicallyConnected();
    bool OpenProtectiveCover();
    bool OpenProtectiveCoverAsync();
    bool CloseProtectiveCover();
    bool CloseProtectiveCoverAsync();
    bool ResetProtectiveCover();

    bool GetProtectiveCoverStatus(ProtectiveCoverStatus &status);
    bool SetCollectionCallBack(X1::CollectionCallBackPtr cb, UserPtr ctx);

    bool SetCalculationCallBack(X1::CalculationCallBackPtr cb, UserPtr ctx);

    bool Capture(const CaptureOptions &opts);
    bool Capture();
    bool Capture2D(const CaptureOptions &opts);
    bool Capture2D();
    bool SetBandwidth(float percent);

    bool GetBandwidth(float &percent);

    bool SetCustomTransformation(const CustomTransformOptions &opts);
    bool GetCustomTransformation(CustomTransformOptions &opts);
    bool SaveEncodedImagesData(const char *addr);

    Image GetImage();
    DepthMap GetDepthMap();
    PointMap GetPointMap();
    ConfidenceMap GetConfidenceMap();
    bool GetExtrinsicMatrix(float *matrix);
    bool GetIntrinsicParameters(float *instrinsic_matrix, float *distortion);
    bool GetProjectorTemperature(float &temperature);
    [[deprecated]] bool GetCameraTemperature(CameraTempSelector seletor, float &temperature);
    bool SetBalanceRatio(BalanceSelector selector, float value);
    bool GetBalanceRatio(BalanceSelector selector, float *value);

    bool GetBalanceRange(BalanceSelector selector, float *min_value, float *max_value);

    bool AutoWhiteBalance(int wb_times = 10, const CaptureOptions &opts = CaptureOptions(),
                          const RVC::ROI &roi = RVC::ROI());

    bool GetExposureTimeRange(int *min_value, int *max_value);

    bool GetGainRange(float *min_value, float *max_value);

    bool GetGammaRange(float *min_value, float *max_value);

    bool SaveCaptureOptionParameters(const X1::CaptureOptions &opts);

    bool LoadCaptureOptionParameters(X1::CaptureOptions &opts);

    bool GetAutoCaptureSetting(CaptureOptions &opts, const ROI &roi = ROI());

    bool GetAutoHdrCaptureSetting(CaptureOptions &opts, const ROI &roi);

    bool GetAutoNoiseRemovalSetting(CaptureOptions &opts);

    bool LoadSettingFromFile(const char *filename);

    bool SaveSettingToFile(const char *filename);

    bool CheckRoi(ROI roi);

    ROI AutoAdjustRoi(ROI roi = ROI());

    bool GetRoiRange(ROIRange &range);

    bool GetCameraResolution(Size &resolution);

    Handle m_handle;
};


struct RVC_EXPORT X2 {
    struct CaptureOptions {
        CaptureOptions() {
            transform_to_camera = CameraID_Left;
            projector_brightness = 240;
            calc_normal = false;
            calc_normal_radius = 5;
            use_auto_noise_removal = true;
            noise_removal_distance = 0;
            noise_removal_point_number = 40;
            light_contrast_threshold = 3;
            edge_noise_reduction_threshold = 2;
            exposure_time_2d = 11;
            exposure_time_3d = 11;
            gain_2d = 0.f;
            gain_3d = 0.f;
            hdr_exposure_times = 0;
            hdr_exposuretime_content[0] = 11;
            hdr_exposuretime_content[1] = 20;
            hdr_exposuretime_content[2] = 50;
            hdr_gain_3d[0] = 0;
            hdr_gain_3d[1] = 0;
            hdr_gain_3d[2] = 0;

            hdr_scan_times[0] = 1;
            hdr_scan_times[1] = 1;
            hdr_scan_times[2] = 1;

            hdr_projector_brightness[0] = 240;
            hdr_projector_brightness[1] = 240;
            hdr_projector_brightness[2] = 240;
            gamma_2d = 1.f;
            gamma_3d = 1.f;
            projector_color = ProjectorColor_Blue;
            use_projector_capturing_2d_image = true;
            smoothness = SmoothnessLevel_Off;
            downsample_distance = 0.0;
            capture_mode = CaptureMode_Normal;
            confidence_threshold = 0;
            scan_times = 1;

            bilateral_filter_kernal_size = 0;
            bilateral_filter_depth_sigma = 0;
            bilateral_filter_space_sigma = 0;

            line_scanner_scan_time_ms = 1000;
            line_scanner_exposure_time_us = 300;
            line_scanner_min_distance = 0;
            line_scanner_max_distance = 0;

            correspond2d = false;
            line_scanner_laser_position = 65536 / 2;
            use_auto_bilateral_filter = true;
            reflection_filter_threshold = 0;
            smooth_sigma = 1.75;

            roi = RVC::ROI();
            enable_2d_in_capture = true;
            pointcloud_completion = false;
            line_scanner_brightness_threshold = 5;
        }
        CameraID transform_to_camera;
        int projector_brightness;
        bool calc_normal;

        unsigned int calc_normal_radius;

        int light_contrast_threshold;
        [[deprecated]] int edge_noise_reduction_threshold;
        int exposure_time_2d;
        int exposure_time_3d;
        float gain_2d;
        float gain_3d;
        int hdr_exposure_times;
        int hdr_exposuretime_content[3];
        float hdr_gain_3d[3];
        int hdr_projector_brightness[3];
        float gamma_2d;
        float gamma_3d;
        ProjectorColor projector_color;
        bool use_projector_capturing_2d_image;

        [[deprecated(
            "smoothness has been deprecated in CPU version,use smooth_sigma instead")]] SmoothnessLevel smoothness;
        bool use_auto_noise_removal;
        double noise_removal_distance;
        int noise_removal_point_number;

        double downsample_distance;

        CaptureMode capture_mode;

        double confidence_threshold;
        int scan_times;
        int hdr_scan_times[3];

        [[deprecated("Use smooth_sigma instead")]] int bilateral_filter_kernal_size;

        [[deprecated("Use smooth_sigma instead")]] double bilateral_filter_depth_sigma;

        [[deprecated("Use smooth_sigma instead")]] double bilateral_filter_space_sigma;

        int line_scanner_scan_time_ms;
        int line_scanner_exposure_time_us;
        int line_scanner_min_distance;
        int line_scanner_max_distance;

        bool correspond2d;

        uint16_t line_scanner_laser_position;

        [[deprecated("Use smooth_sigma instead")]] bool use_auto_bilateral_filter;

        int reflection_filter_threshold;

        double smooth_sigma;

        RVC::ROI roi;

        bool enable_2d_in_capture;

        bool pointcloud_completion;

        int line_scanner_brightness_threshold;
    };
    struct CustomTransformOptions {
        enum CoordinateSelect {
            CoordinateSelect_Disabled,
            CoordinateSelect_CameraLeft,
            CoordinateSelect_CameraRight,
            CoordinateSelect_CaliBoard,
            CoordinateSelect_CameraExtra,
        };

        CustomTransformOptions()
            : coordinate_select(CoordinateSelect_Disabled), transform{1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1} {}

        CoordinateSelect coordinate_select;

        double transform[16];
    };

    struct CollectionCallBackInfo {
        Image image[2];
    };

    struct CalculationCallBackInfo {
        Image image[2];
        PointMap pointmap;
        DepthMap depthmap;
        ConfidenceMap confidencemap;
    };

    typedef void (*CollectionCallBackPtr)(X2::CollectionCallBackInfo, X2::CaptureOptions, UserPtr);
    typedef void (*CalculationCallBackPtr)(X2::CalculationCallBackInfo, X2::CaptureOptions, UserPtr);

    static X2 Create(const Device &d);
    static void Destroy(X2 &x);

    bool IsValid();
    bool Open();
    void Close();
    bool IsOpen();
    bool IsPhysicallyConnected();
    bool OpenProtectiveCover();
    bool OpenProtectiveCoverAsync();
    bool CloseProtectiveCover();
    bool CloseProtectiveCoverAsync();
    bool ResetProtectiveCover();
    bool GetProtectiveCoverStatus(ProtectiveCoverStatus &status);
    bool SetCollectionCallBack(X2::CollectionCallBackPtr cb, UserPtr ctx);
    bool SetCalculationCallBack(X2::CalculationCallBackPtr cb, UserPtr ctx);

    bool Capture(const CaptureOptions &opts);
    bool Capture();

    bool StartFixedLineScan(const CaptureOptions &opts);

    bool StartFixedLineScan();

    [[deprecated("Use bool GetFixedLineScanPointMap(PointMap &point_map) instead")]] PointMap
    GetFixedLineScanPointMap();

    bool GetFixedLineScanPointMap(PointMap &point_map);

    bool StopFixedLineScan();

    bool Capture2D(const CameraID cid, const CaptureOptions &opts);
    bool Capture2D(const CameraID cid);
    bool SetBandwidth(float percent);

    bool GetBandwidth(float &percent);

    bool SetCustomTransformation(const CustomTransformOptions &opts);

    bool GetCustomTransformation(CustomTransformOptions &opts);

    PointMap GetPointMap();
    Image GetImage(const CameraID cid);

    DepthMap GetDepthMap();

    ConfidenceMap GetConfidenceMap();
    CorrespondMap GetCorrespondMap();

    bool GetExtrinsicMatrix(const CameraID cid, float *matrix);

    bool GetIntrinsicParameters(const CameraID cid, float *instrinsicMatrix, float *distortion);
    bool GetProjectorTemperature(float &temperature);
    [[deprecated]] bool GetCameraTemperature(const CameraID cid, CameraTempSelector seletor, float &temperature);
    bool AutoWhiteBalance(int wb_times = 10, const CaptureOptions &opts = CaptureOptions(),
                          const RVC::ROI &roi = RVC::ROI());
    bool GetExposureTimeRange(int *min_value, int *max_value);
    bool GetGainRange(float *min_value, float *max_value);
    bool GetGammaRange(float *min_value, float *max_value);
    bool SaveEncodedImagesData(const char *addr);

    bool SaveCaptureOptionParameters(const X2::CaptureOptions &opts);

    bool LoadCaptureOptionParameters(X2::CaptureOptions &opts);

    bool GetAutoCaptureSetting(CaptureOptions &opts, const ROI &roi = ROI());

    bool GetAutoHdrCaptureSetting(CaptureOptions &opts, const ROI &roi);

    bool GetAutoNoiseRemovalSetting(CaptureOptions &opts);

    bool LoadSettingFromFile(const char *filename);

    bool SaveSettingToFile(const char *filename);

    bool CheckRoi(ROI roi);

    ROI AutoAdjustRoi(ROI roi = ROI());

    bool GetRoiRange(ROIRange &range);

    bool GetCameraResolution(Size &resolution);

    Handle m_handle;
};

// You can use these to better get and set.
namespace utils {
struct Point3D {
    Point3D(double x = 0.0, double y = 0.0, double z = 0.0) : x(x), y(y), z(z) {}
    double x;
    double y;
    double z;
};

// Helper class upon RVC::PointMap to ease data-access
struct PointMap {
    PointMap(RVC::PointMap pm) : pm(pm) {}
    Point3D At(int rows, int cols) {
        Point3D p;
        auto sz = pm.GetSize();
        if (!pm.IsValid()) {
            printf("RVC::Utils: Invalid");
            assert(false);
        } else if (rows >= sz.rows || cols >= sz.cols) {
            printf("RVC::Utils: Invalid rows and cols(%d, %d), size(%d, %d)", rows, cols, sz.rows, sz.cols);
            assert(false);
        } else {
            double *data = pm.GetPointDataPtr() + 3 * (rows * sz.cols + cols);
            p.x = *data++;
            p.y = *data++;
            p.z = *data++;
        }
        return p;
    }
    void Set(int rows, int cols, const Point3D p) {
        auto sz = pm.GetSize();
        if (!pm.IsValid()) {
            printf("RVC::Utils: Invalid");
            assert(false);
        } else if (rows >= sz.rows || cols >= sz.cols) {
            printf("RVC::Utils: Invalid rows and cols(%d, %d), size(%d, %d)", rows, cols, sz.rows, sz.cols);
            assert(false);
        } else {
            double *data = pm.GetPointDataPtr() + 3 * (rows * sz.cols + cols);
            *data++ = p.x;
            *data++ = p.y;
            *data++ = p.z;
        }
    }

    RVC::Size GetSize() { return pm.GetSize(); }

    RVC::PointMap pm;
};

template <typename T, typename H>
T _At(H handle, int rows, int cols) {
    T v = 0;
    RVC::Size sz = handle.GetSize();
    if (!handle.IsValid()) {
        printf("RVC::Utils: Invalid");
        assert(false);
        return v;
    } else if (rows >= sz.rows || cols >= sz.cols) {
        printf("RVC::Utils: Invalid rows and cols(%d, %d), size(%d, %d)", rows, cols, sz.rows, sz.cols);
        assert(false);
        return v;
    } else {
        return *(handle.GetDataConstPtr() + rows * sz.cols + cols);
    }
}

template <typename T, typename H>
void _Set(H handle, int rows, int cols, const T v) {
    RVC::Size sz = handle.GetSize();
    if (!handle.IsValid()) {
        printf("RVC::Utils: Invalid");
        assert(false);
    } else if (rows >= sz.rows || cols >= sz.cols) {
        printf("RVC::Utils: Invalid rows and cols(%d, %d), size(%d, %d)", rows, cols, sz.rows, sz.cols);
        assert(false);
    } else {
        *(handle.GetDataPtr() + rows * sz.cols + cols) = v;
    }
}

// Helper class upon RVC::Image to ease data-access
struct Image {
    Image(RVC::Image img) : img(img) {}
    unsigned char At(int rows, int cols) { return _At<unsigned char>(img, rows, cols); }
    void Set(int rows, int cols, const unsigned char v) { _Set(img, rows, cols, v); }
    RVC::Size GetSize() { return img.GetSize(); }

    RVC::Image img;
};

// Helper class upon RVC::ConfidenceMap to ease data-access
struct ConfidenceMap {
    ConfidenceMap(RVC::ConfidenceMap cm) : cm(cm) {}
    double At(int rows, int cols) { return _At<double>(cm, rows, cols); }
    void Set(int rows, int cols, const double v) { _Set(cm, rows, cols, v); }
    RVC::Size GetSize() { return cm.GetSize(); }

    RVC::ConfidenceMap cm;
};

// Helper class upon RVC::DepthMap to ease data-access
struct DepthMap {
    DepthMap(RVC::DepthMap dm) : dm(dm) {}
    double At(int rows, int cols) { return _At<double>(dm, rows, cols); }
    void Set(int rows, int cols, const double v) { _Set(dm, rows, cols, v); }
    RVC::Size GetSize() { return dm.GetSize(); }

    RVC::DepthMap dm;
};
}  // namespace utils
}  // namespace RVC