deviceparameters.h

/*******************************************************************************
 * Copyright (c) 2024 Allied Vision Technologies GmbH
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *******************************************************************************/
 
#ifndef VISIONTRANSFER_DEVICEPARAMETERS_H
#define VISIONTRANSFER_DEVICEPARAMETERS_H
 
#include "visiontransfer/common.h"
#include "visiontransfer/types.h"
#include "visiontransfer/deviceinfo.h"
#include "visiontransfer/parameterinfo.h"
#if VISIONTRANSFER_CPLUSPLUS_VERSION >= 201103L
#include "visiontransfer/parameter.h"
#include "visiontransfer/parameterset.h"
#include <functional>
#include <set>
#endif
 
#include <map>
 
namespace visiontransfer {
 
class VT_EXPORT DeviceParameters {
 
private:
    // We follow the pimpl idiom
    class Pimpl;
    Pimpl* pimpl;
 
public:
    DeviceParameters(const DeviceInfo& device);
 
    DeviceParameters(const char* address, const char* service = "7683");
 
    ~DeviceParameters();
 
    bool isConnected() const;
 
    // Processing settings
 
    enum OperationMode {
        PASS_THROUGH = 0,
 
        RECTIFY = 1,
 
        STEREO_MATCHING = 2
    };
 
    OperationMode getOperationMode() {
        return static_cast<OperationMode>(readIntParameter("operation_mode"));
    }
 
    void setOperationMode(OperationMode mode) {
        writeIntParameter("operation_mode", static_cast<int>(mode));
    }
 
    int getDisparityOffset() {
        return readIntParameter("disparity_offset");
    }
 
    void setDisparityOffset(int offset) {
        writeIntParameter("disparity_offset", offset);
    }
 
    // Algorithmic settings
 
    int getStereoMatchingP1Edge() {
        return readIntParameter("sgm_p1_edge");
    }
 
    void setStereoMatchingP1Edge(int p1) {
        writeIntParameter("sgm_p1_edge", p1);
    }
 
    int getStereoMatchingP1NoEdge() {
        return readIntParameter("sgm_p1_no_edge");
    }
 
    void setStereoMatchingP1NoEdge(int p1) {
        writeIntParameter("sgm_p1_no_edge", p1);
    }
 
    int getStereoMatchingP2Edge() {
        return readIntParameter("sgm_p2_edge");
    }
 
    void setStereoMatchingP2Edge(int p2) {
        writeIntParameter("sgm_p2_edge", p2);
    }
 
    int getStereoMatchingP2NoEdge() {
        return readIntParameter("sgm_p2_no_edge");
    }
 
    void setStereoMatchingP2NoEdge(int p2) {
        writeIntParameter("sgm_p2_no_edge", p2);
    }
 
    int getStereoMatchingEdgeSensitivity() {
        return readIntParameter("sgm_edge_sensitivity");
    }
 
    void setStereoMatchingEdgeSensitivity(int sensitivity) {
        writeIntParameter("sgm_edge_sensitivity", sensitivity);
    }
 
    bool getMaskBorderPixelsEnabled() {
        return readBoolParameter("mask_border_pixels_enabled");
    }
 
    void setMaskBorderPixelsEnabled(bool enabled) {
        writeBoolParameter("mask_border_pixels_enabled", enabled);
    }
 
    bool getConsistencyCheckEnabled() {
        return readBoolParameter("consistency_check_enabled");
    }
 
    void setConsistencyCheckEnabled(bool enabled) {
        writeBoolParameter("consistency_check_enabled", enabled);
    }
 
    int getConsistencyCheckSensitivity() {
        return readIntParameter("consistency_check_sensitivity");
    }
 
    void setConsistencyCheckSensitivity(int sensitivity) {
        writeIntParameter("consistency_check_sensitivity", sensitivity);
    }
 
    bool getUniquenessCheckEnabled() {
        return readBoolParameter("uniqueness_check_enabled");
    }
 
    void setUniquenessCheckEnabled(bool enabled) {
        writeBoolParameter("uniqueness_check_enabled", enabled);
    }
 
    int getUniquenessCheckSensitivity() {
        return readIntParameter("uniqueness_check_sensitivity");
    }
 
    void setUniquenessCheckSensitivity(int sensitivity) {
        writeIntParameter("uniqueness_check_sensitivity", sensitivity);
    }
 
    bool getTextureFilterEnabled() {
        return readBoolParameter("texture_filter_enabled");
    }
 
    void setTextureFilterEnabled(bool enabled) {
        writeBoolParameter("texture_filter_enabled", enabled);
    }
 
    int getTextureFilterSensitivity() {
        return readIntParameter("texture_filter_sensitivity");
    }
 
    void setTextureFilterSensitivity(int sensitivity) {
        writeIntParameter("texture_filter_sensitivity", sensitivity);
    }
 
    bool getGapInterpolationEnabled() {
        return readBoolParameter("gap_interpolation_enabled");
    }
 
    void setGapInterpolationEnabled(bool enabled) {
        writeBoolParameter("gap_interpolation_enabled", enabled);
    }
 
    bool getNoiseReductionEnabled() {
        return readBoolParameter("noise_reduction_enabled");
    }
 
    void setNoiseReductionEnabled(bool enabled) {
        writeBoolParameter("noise_reduction_enabled", enabled);
    }
 
    int getSpeckleFilterIterations() {
        return readIntParameter("speckle_filter_iterations");
    }
 
    void setSpeckleFilterIterations(int iter) {
        writeIntParameter("speckle_filter_iterations", iter);
    }
 
    // Exposure and gain settings
 
    enum AutoMode {
        AUTO_EXPOSURE_AND_GAIN = 0,
 
        AUTO_EXPOSURE_MANUAL_GAIN = 1,
 
        MANUAL_EXPOSURE_AUTO_GAIN = 2,
 
        MANUAL_EXPOSURE_MANUAL_GAIN = 3
    };
 
    AutoMode getAutoMode() {
        return static_cast<AutoMode>(readIntParameter("auto_exposure_mode"));
    }
 
    void setAutoMode(AutoMode mode) {
        writeIntParameter("auto_exposure_mode", static_cast<int>(mode));
    }
 
    double getAutoTargetIntensity() {
        return readDoubleParameter("auto_target_intensity");
    }
 
    void setAutoTargetIntensity(double intensity) {
        writeDoubleParameter("auto_target_intensity", intensity);
    }
 
    double getAutoTargetIntensityThirdCamera() {
        return readDoubleParameter("auto_target_intensity_color");
    }
 
    void setAutoTargetIntensityThirdCamera(double intensity) {
        writeDoubleParameter("auto_target_intensity_color", intensity);
    }
 
    double getAutoIntensityDelta() {
        return readDoubleParameter("auto_intensity_delta");
    }
 
    void setAutoIntensityDelta(double delta) {
        writeDoubleParameter("auto_intensity_delta", delta);
    }
 
    enum TargetFrame {
        LEFT_FRAME = 0,
 
        RIGHT_FRAME = 1,
 
        BOTH_FRAMES = 2,
    };
 
    TargetFrame getAutoTargetFrame() {
        return static_cast<TargetFrame>(readIntParameter("auto_target_frame"));
    }
 
    void setAutoTargetFrame(TargetFrame target) {
        writeIntParameter("auto_target_frame", static_cast<int>(target));
    }
 
    int getAutoSkippedFrames() {
        return readIntParameter("auto_skipped_frames");
    }
 
    void setAutoSkippedFrames(int skipped) {
        writeIntParameter("auto_skipped_frames", skipped);
    }
 
    double getAutoMaxExposureTime() {
        return readDoubleParameter("auto_maximum_exposure_time");
    }
 
    void setAutoMaxExposureTime(double time) {
        writeDoubleParameter("auto_maximum_exposure_time", time);
    }
 
    double getAutoMaxGain() {
        return readDoubleParameter("auto_maximum_gain");
    }
 
    void setAutoMaxGain(double gain) {
        writeDoubleParameter("auto_maximum_gain", gain);
    }
 
    double getAutoMaxGainThirdCamera() {
        return readDoubleParameter("auto_maximum_gain_color");
    }
 
    void setAutoMaxGainThirdCamera(double gain) {
        writeDoubleParameter("auto_maximum_gain_color", gain);
    }
 
    double getManualExposureTime() {
        return readDoubleParameter("manual_exposure_time");
    }
 
    void setManualExposureTime(double time) {
        writeDoubleParameter("manual_exposure_time", time);
    }
 
    double getManualExposureTimeThirdCamera() {
        return readDoubleParameter("manual_exposure_time_color");
    }
 
    void setManualExposureTimeThirdCamera(double time) {
        writeDoubleParameter("manual_exposure_time_color", time);
    }
 
    double getManualGain() {
        return readDoubleParameter("manual_gain");
    }
 
    void setManualGain(double gain) {
        writeDoubleParameter("manual_gain", gain);
    }
 
    double getManualGainThirdCamera() {
        return readDoubleParameter("manual_gain_color");
    }
 
    void setManualGainThirdCamera(double gain) {
        writeDoubleParameter("manual_gain_color", gain);
    }
 
    bool getAutoROIEnabled() {
        return readBoolParameter("auto_exposure_roi_enabled");
    }
 
    void setAutoROIEnabled(bool enabled) {
        writeBoolParameter("auto_exposure_roi_enabled", enabled);
    }
 
    void getAutoROI(int& x, int& y, int& width, int& height) {
        x = readIntParameter("auto_exposure_roi_x");
        y = readIntParameter("auto_exposure_roi_y");
        width = readIntParameter("auto_exposure_roi_width");
        height = readIntParameter("auto_exposure_roi_height");
    }
 
    void setAutoROI(int x, int y, int width, int height) {
        writeIntParameter("auto_exposure_roi_x", x);
        writeIntParameter("auto_exposure_roi_y", y);
        writeIntParameter("auto_exposure_roi_width", width);
        writeIntParameter("auto_exposure_roi_height", height);
    }
 
    // Gamma settings
 
    double getGamma() {
        return readDoubleParameter("gamma");
    }
 
    void setGamma(double gamma) {
        writeDoubleParameter("gamma", gamma);
    }
 
    double getGammaThirdCamera() {
        return readDoubleParameter("gamma_color");
    }
 
    void setGammaThirdCamera(double gamma) {
        writeDoubleParameter("gamma_color", gamma);
    }
 
 
 
    // Trigger and pairing settings
 
    int getMaxFrameTimeDifference() {
        return readIntParameter("max_frame_time_difference_ms");
    }
 
    void setMaxFrameTimeDifference(int diffMs) {
        writeIntParameter("max_frame_time_difference_ms", diffMs);
    }
 
    double getTriggerFrequency() {
        return readDoubleParameter("trigger_frequency");
    }
 
    void setTriggerFrequency(double freq) {
        writeDoubleParameter("trigger_frequency", freq);
    }
 
    bool getTrigger0Enabled() {
        return readBoolParameter("trigger_0_enabled");
    }
 
    void setTrigger0Enabled(bool enabled) {
        writeBoolParameter("trigger_0_enabled", enabled);
    }
 
    bool getTrigger0Constant() {
        return readBoolParameter("trigger_0_constant");
    }
 
    void setTrigger0Constant(bool on) {
        writeBoolParameter("trigger_0_constant", on);
    }
 
    bool getTrigger0Polarity() {
        return readBoolParameter("trigger_0_polarity");
    }
 
    void setTrigger0Polarity(bool invert) {
        writeBoolParameter("trigger_0_polarity", invert);
    }
 
    bool getTrigger1Enabled() {
        return readBoolParameter("trigger_1_enabled");
    }
 
    void setTrigger1Enabled(bool enabled) {
        writeBoolParameter("trigger_1_enabled", enabled);
    }
 
    bool getTrigger1Constant() {
        return readBoolParameter("trigger_1_constant");
    }
 
    void setTrigger1Constant(bool on) {
        writeBoolParameter("trigger_1_constant", on);
    }
 
    bool getTrigger1Polarity() {
        return readBoolParameter("trigger_1_polarity");
    }
 
    void setTrigger1Polarity(bool invert) {
        writeBoolParameter("trigger_1_polarity", invert);
    }
 
    double getTrigger0PulseWidth(int pulse=0) {
        switch(pulse) {
            case 0: return readDoubleParameter("trigger_0_pulse_width");
            case 1: return readDoubleParameter("trigger_0b_pulse_width");
            case 2: return readDoubleParameter("trigger_0c_pulse_width");
            case 3: return readDoubleParameter("trigger_0d_pulse_width");
            case 4: return readDoubleParameter("trigger_0e_pulse_width");
            case 5: return readDoubleParameter("trigger_0f_pulse_width");
            case 6: return readDoubleParameter("trigger_0g_pulse_width");
            case 7: return readDoubleParameter("trigger_0h_pulse_width");
            default: return -1;
        }
    }
 
    void setTrigger0PulseWidth(double width, int pulse=0) {
        switch(pulse) {
            case 0: writeDoubleParameter("trigger_0_pulse_width", width);break;
            case 1: writeDoubleParameter("trigger_0b_pulse_width", width);break;
            case 2: writeDoubleParameter("trigger_0c_pulse_width", width);break;
            case 3: writeDoubleParameter("trigger_0d_pulse_width", width);break;
            case 4: writeDoubleParameter("trigger_0e_pulse_width", width);break;
            case 5: writeDoubleParameter("trigger_0f_pulse_width", width);break;
            case 6: writeDoubleParameter("trigger_0g_pulse_width", width);break;
            case 7: writeDoubleParameter("trigger_0h_pulse_width", width);break;
            default: return;
        }
    }
 
    double getTrigger1PulseWidth(int pulse=0) {
        switch(pulse) {
            case 0: return readDoubleParameter("trigger_1_pulse_width");
            case 1: return readDoubleParameter("trigger_1b_pulse_width");
            case 2: return readDoubleParameter("trigger_1c_pulse_width");
            case 3: return readDoubleParameter("trigger_1d_pulse_width");
            case 4: return readDoubleParameter("trigger_1e_pulse_width");
            case 5: return readDoubleParameter("trigger_1f_pulse_width");
            case 6: return readDoubleParameter("trigger_1g_pulse_width");
            case 7: return readDoubleParameter("trigger_1h_pulse_width");
            default: return -1;
        }
    }
 
    void setTrigger1PulseWidth(double width, int pulse=0) {
        switch(pulse) {
            case 0: writeDoubleParameter("trigger_1_pulse_width", width);break;
            case 1: writeDoubleParameter("trigger_1b_pulse_width", width);break;
            case 2: writeDoubleParameter("trigger_1c_pulse_width", width);break;
            case 3: writeDoubleParameter("trigger_1d_pulse_width", width);break;
            case 4: writeDoubleParameter("trigger_1e_pulse_width", width);break;
            case 5: writeDoubleParameter("trigger_1f_pulse_width", width);break;
            case 6: writeDoubleParameter("trigger_1g_pulse_width", width);break;
            case 7: writeDoubleParameter("trigger_1h_pulse_width", width);break;
            default: return;
        }
    }
 
    double getTrigger1Offset() {
        return readDoubleParameter("trigger_1_offset");
    }
 
    void setTrigger1Offset(double offset) {
        writeDoubleParameter("trigger_1_offset", offset);
    }
 
    enum TriggerInputMode {
        INTERNAL = 0,
 
        EXTERNAL = 1,
 
        SOFTWARE = 2
    };
 
    TriggerInputMode getTriggerInputMode() {
        return static_cast<TriggerInputMode>(readIntParameter("trigger_input"));
    }
 
    void setTriggerInputMode(TriggerInputMode mode) {
        writeIntParameter("trigger_input", static_cast<int>(mode));
    }
 
    int getSkippedTriggerCount() {
        return readIntParameter("RT_skipped_trigger_count");
    }
 
    // Auto calibration parameters
 
    bool getAutoRecalibrationEnabled() {
        return readBoolParameter("auto_recalibration_enabled");
    }
 
    void setAutoRecalibrationEnabled(bool enabled) {
        writeBoolParameter("auto_recalibration_enabled", enabled);
    }
 
    bool getSaveAutoRecalibration() {
        return readBoolParameter("auto_recalibration_permanent");
    }
 
    void setSaveAutoRecalibration(bool save) {
        writeBoolParameter("auto_recalibration_permanent", save);
    }
 
    bool getSubpixelOptimizationROIEnabled() {
        return readBoolParameter("subpixel_optimization_roi_enabled");
    }
 
    void setSubpixelOptimizationROIEnabled(bool enabled) {
        writeBoolParameter("subpixel_optimization_roi_enabled", enabled);
    }
 
    void getSubpixelOptimizationROI(int& x, int& y, int& width, int& height) {
        x = readIntParameter("subpixel_optimization_roi_x");
        y = readIntParameter("subpixel_optimization_roi_y");
        width = readIntParameter("subpixel_optimization_roi_width");
        height = readIntParameter("subpixel_optimization_roi_height");
    }
 
    void setSubpixelOptimizationROI(int x, int y, int width, int height) {
        writeIntParameter("subpixel_optimization_roi_x", x);
        writeIntParameter("subpixel_optimization_roi_y", y);
        writeIntParameter("subpixel_optimization_roi_width", width);
        writeIntParameter("subpixel_optimization_roi_height", height);
    }
 
    void reboot() {
        writeBoolParameterUnguarded("reboot", true);
    }
 
    void triggerNow() {
        writeBoolParameterUnguarded("trigger_now", true);
    }
 
    DEPRECATED("Use getParameterSet() instead")
    std::map<std::string, ParameterInfo> getAllParameters();
 
    template<typename T>
    DEPRECATED("Use setParameter() instead")
    void setNamedParameter(const std::string& name, T value);
 
    template<typename T>
    void setParameter(const std::string& name, T value);
 
    template<typename T>
    DEPRECATED("Use getParameter() instead")
    T getNamedParameter(const std::string& name);
 
    void saveParameter(const char* uid, bool blockingCall=true);
 
#if VISIONTRANSFER_CPLUSPLUS_VERSION >= 201103L
 
    bool hasParameter(const std::string& name) const;
 
    visiontransfer::param::Parameter getParameter(const std::string& name) const;
 
    visiontransfer::param::ParameterSet getParameterSet() const;
 
    visiontransfer::param::Parameter pollParameter(const std::string& name, bool blockingCall=true);
 
    void setParameterUpdateCallback(std::function<void(const std::string& uid)> callback, bool threaded=true);
 
    void setConnectionStateChangeCallback(std::function<void(visiontransfer::ConnectionState)> callback);
 
    class VT_EXPORT TransactionLock {
        private:
            Pimpl* pimpl;
        public:
            TransactionLock(Pimpl* pimpl);
            ~TransactionLock();
            void commitAndWait(int maxWaitMilliseconds=1000);
    };
    friend class TransactionLock;
 
    std::unique_ptr<TransactionLock> transactionLock();
 
    void saveParameter(const std::string& uid, bool blockingCall=true);
 
    void saveParameter(const visiontransfer::param::Parameter& param, bool blockingCall=true);
 
    void saveParameters(const std::vector<std::string>& uids, bool blockingCall=true);
 
    void saveParameters(const std::set<std::string>& uids, bool blockingCall=true);
 
    void saveParameters(std::initializer_list<std::string> uids, bool blockingCall=true);
 
#endif
 
private:
    // This class cannot be copied
    DeviceParameters(const DeviceParameters& other);
    DeviceParameters& operator=(const DeviceParameters& other);
 
    // Generic functions for reading parameters
    int readIntParameter(const char* id);
    double readDoubleParameter(const char* id);
    bool readBoolParameter(const char* id);
 
    // Generic functions for writing parameters
    void writeIntParameter(const char* id, int value);
    void writeDoubleParameter(const char* id, double value);
    void writeBoolParameter(const char* id, bool value);
    // Unguarded version used for sending real-time commands (omit reply handshake)
    void writeBoolParameterUnguarded(const char* id, bool value);
 
};
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// For source compatibility
DEPRECATED("Use DeviceParameters instead.")
typedef DeviceParameters SceneScanParameters;
#endif
 
} // namespace
 
#endif