libvisiontransfer  10.0.0
deviceparameters.h
1 /*******************************************************************************
2  * Copyright (c) 2022 Nerian Vision GmbH
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a copy
5  * of this software and associated documentation files (the "Software"), to deal
6  * in the Software without restriction, including without limitation the rights
7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8  * copies of the Software, and to permit persons to whom the Software is
9  * furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *******************************************************************************/
14 
15 #ifndef VISIONTRANSFER_DEVICEPARAMETERS_H
16 #define VISIONTRANSFER_DEVICEPARAMETERS_H
17 
18 #include "visiontransfer/common.h"
19 #include "visiontransfer/deviceinfo.h"
20 #include "visiontransfer/standardparameterids.h"
21 #include "visiontransfer/parameterinfo.h"
22 #if __cplusplus >= 201103L
23 #include "visiontransfer/parameter.h"
24 #include "visiontransfer/parameterset.h"
25 #endif
26 
27 #include <map>
28 
29 namespace visiontransfer {
30 
50 class VT_EXPORT DeviceParameters {
51 public:
59  DeviceParameters(const DeviceInfo& device);
60 
70  DeviceParameters(const char* address, const char* service = "7683");
71 
73 
74  // Processing settings
75 
81  PASS_THROUGH = 0,
82 
84  RECTIFY = 1,
85 
87  STEREO_MATCHING = 2
88  };
89 
97  return static_cast<OperationMode>(readIntParameter("operation_mode"));
98  }
99 
107  writeIntParameter("operation_mode", static_cast<int>(mode));
108  }
109 
114  return readIntParameter("disparity_offset");
115  }
116 
122  void setDisparityOffset(int offset) {
123  writeIntParameter("disparity_offset", offset);
124  }
125 
126  // Algorithmic settings
127 
132  return readIntParameter("sgm_p1_edge");
133  }
134 
140  void setStereoMatchingP1Edge(int p1) {
141  writeIntParameter("sgm_p1_edge", p1);
142  }
143 
148  return readIntParameter("sgm_p1_no_edge");
149  }
150 
157  writeIntParameter("sgm_p1_no_edge", p1);
158  }
159 
164  return readIntParameter("sgm_p2_edge");
165  }
166 
172  void setStereoMatchingP2Edge(int p2) {
173  writeIntParameter("sgm_p2_edge", p2);
174  }
175 
180  return readIntParameter("sgm_p2_no_edge");
181  }
182 
189  writeIntParameter("sgm_p2_no_edge", p2);
190  }
191 
196  return readIntParameter("sgm_edge_sensitivity");
197  }
198 
204  void setStereoMatchingEdgeSensitivity(int sensitivity) {
205  writeIntParameter("sgm_edge_sensitivity", sensitivity);
206  }
207 
213  return readBoolParameter("mask_border_pixels_enabled");
214  }
215 
220  void setMaskBorderPixelsEnabled(bool enabled) {
221  writeBoolParameter("mask_border_pixels_enabled", enabled);
222  }
223 
228  return readBoolParameter("consistency_check_enabled");
229  }
230 
234  void setConsistencyCheckEnabled(bool enabled) {
235  writeBoolParameter("consistency_check_enabled", enabled);
236  }
237 
242  return readIntParameter("consistency_check_sensitivity");
243  }
244 
250  void setConsistencyCheckSensitivity(int sensitivity) {
251  writeIntParameter("consistency_check_sensitivity", sensitivity);
252  }
253 
258  return readBoolParameter("uniqueness_check_enabled");
259  }
260 
264  void setUniquenessCheckEnabled(bool enabled) {
265  writeBoolParameter("uniqueness_check_enabled", enabled);
266  }
267 
272  return readIntParameter("uniqueness_check_sensitivity");
273  }
274 
280  void setUniquenessCheckSensitivity(int sensitivity) {
281  writeIntParameter("uniqueness_check_sensitivity", sensitivity);
282  }
283 
288  return readBoolParameter("texture_filter_enabled");
289  }
290 
294  void setTextureFilterEnabled(bool enabled) {
295  writeBoolParameter("texture_filter_enabled", enabled);
296  }
297 
302  return readIntParameter("texture_filter_sensitivity");
303  }
304 
310  void setTextureFilterSensitivity(int sensitivity) {
311  writeIntParameter("texture_filter_sensitivity", sensitivity);
312  }
313 
318  return readBoolParameter("gap_interpolation_enabled");
319  }
320 
324  void setGapInterpolationEnabled(bool enabled) {
325  writeBoolParameter("gap_interpolation_enabled", enabled);
326  }
327 
332  return readBoolParameter("noise_reduction_enabled");
333  }
334 
338  void setNoiseReductionEnabled(bool enabled) {
339  writeBoolParameter("noise_reduction_enabled", enabled);
340  }
341 
346  return readIntParameter("speckle_filter_iterations");
347  }
348 
352  void setSpeckleFilterIterations(int iter) {
353  writeIntParameter("speckle_filter_iterations", iter);
354  }
355 
356  // Exposure and gain settings
357 
361  enum AutoMode {
363  AUTO_EXPOSURE_AND_GAIN = 0,
364 
366  AUTO_EXPOSURE_MANUAL_GAIN = 1,
367 
369  MANUAL_EXPOSORE_AUTO_GAIN = 2,
370 
372  MANUAL_EXPOSURE_MANUAL_GAIN = 3
373  };
374 
380  return static_cast<AutoMode>(readIntParameter("auto_exposure_mode"));
381  }
382 
387  void setAutoMode(AutoMode mode) {
388  writeIntParameter("auto_exposure_mode", static_cast<int>(mode));
389  }
390 
399  return readDoubleParameter("auto_target_intensity");
400  }
401 
409  void setAutoTargetIntensity(double intensity) {
410  writeDoubleParameter("auto_target_intensity", intensity);
411  }
412 
421  return readDoubleParameter("auto_intensity_delta");
422  }
423 
431  void setAutoIntensityDelta(double delta) {
432  writeDoubleParameter("auto_intensity_delta", delta);
433  }
434 
439  enum TargetFrame {
441  LEFT_FRAME = 0,
442 
444  RIGHT_FRAME = 1,
445 
447  BOTH_FRAMES = 2,
448  };
449 
455  return static_cast<TargetFrame>(readIntParameter("auto_target_frame"));
456  }
457 
463  writeIntParameter("auto_target_frame", static_cast<int>(target));
464  }
465 
474  return readIntParameter("auto_skipped_frames");
475  }
476 
484  void setAutoSkippedFrames(int skipped) {
485  writeIntParameter("auto_skipped_frames", skipped);
486  }
487 
493  return readDoubleParameter("auto_maximum_exposure_time");
494  }
495 
500  void setAutoMaxExposureTime(double time) {
501  writeDoubleParameter("auto_maximum_exposure_time", time);
502  }
503 
508  double getAutoMaxGain() {
509  return readDoubleParameter("auto_maximum_gain");
510  }
511 
516  void setAutoMaxGain(double gain) {
517  writeDoubleParameter("auto_maximum_gain", gain);
518  }
519 
530  return readDoubleParameter("manual_exposure_time");
531  }
532 
542  void setManualExposureTime(double time) {
543  writeDoubleParameter("manual_exposure_time", time);
544  }
545 
555  double getManualGain() {
556  return readDoubleParameter("manual_gain");
557  }
558 
568  void setManualGain(double gain) {
569  writeDoubleParameter("manual_gain", gain);
570  }
571 
576  return readBoolParameter("auto_exposure_roi_enabled");
577  }
578 
582  void setAutoROIEnabled(bool enabled) {
583  writeBoolParameter("auto_exposure_roi_enabled", enabled);
584  }
585 
599  void getAutoROI(int& x, int& y, int& width, int& height) {
600  x = readIntParameter("auto_exposure_roi_x");
601  y = readIntParameter("auto_exposure_roi_y");
602  width = readIntParameter("auto_exposure_roi_width");
603  height = readIntParameter("auto_exposure_roi_height");
604  }
605 
619  void setAutoROI(int x, int y, int width, int height) {
620  writeIntParameter("auto_exposure_roi_x", x);
621  writeIntParameter("auto_exposure_roi_y", y);
622  writeIntParameter("auto_exposure_roi_width", width);
623  writeIntParameter("auto_exposure_roi_height", height);
624  }
625 
626  // Trigger and pairing settings
627 
635  return readIntParameter("max_frame_time_difference_ms");
636  }
637 
644  void setMaxFrameTimeDifference(int diffMs) {
645  writeIntParameter("max_frame_time_difference_ms", diffMs);
646  }
647 
653  return readDoubleParameter("trigger_frequency");
654  }
655 
660  void setTriggerFrequency(double freq) {
661  writeDoubleParameter("trigger_frequency", freq);
662  }
663 
668  return readBoolParameter("trigger_0_enabled");
669  }
670 
674  void setTrigger0Enabled(bool enabled) {
675  writeBoolParameter("trigger_0_enabled", enabled);
676  }
677 
682  return readBoolParameter("trigger_0_constant");
683  }
684 
688  void setTrigger0Constant(bool on) {
689  writeBoolParameter("trigger_0_constant", on);
690  }
691 
697  return readBoolParameter("trigger_0_polarity");
698  }
699 
704  void setTrigger0Polarity(bool invert) {
705  writeBoolParameter("trigger_0_polarity", invert);
706  }
707 
712  return readBoolParameter("trigger_1_enabled");
713  }
714 
718  void setTrigger1Enabled(bool enabled) {
719  writeBoolParameter("trigger_1_enabled", enabled);
720  }
721 
726  return readBoolParameter("trigger_1_constant");
727  }
728 
732  void setTrigger1Constant(bool on) {
733  writeBoolParameter("trigger_1_constant", on);
734  }
735 
741  return readBoolParameter("trigger_1_polarity");
742  }
743 
748  void setTrigger1Polarity(bool invert) {
749  writeBoolParameter("trigger_1_polarity", invert);
750  }
751 
759  double getTrigger0PulseWidth(int pulse=0) {
760  switch(pulse) {
761  case 0: return readDoubleParameter("trigger_0_pulse_width");
762  case 1: return readDoubleParameter("trigger_0b_pulse_width");
763  case 2: return readDoubleParameter("trigger_0c_pulse_width");
764  case 3: return readDoubleParameter("trigger_0d_pulse_width");
765  case 4: return readDoubleParameter("trigger_0e_pulse_width");
766  case 5: return readDoubleParameter("trigger_0f_pulse_width");
767  case 6: return readDoubleParameter("trigger_0g_pulse_width");
768  case 7: return readDoubleParameter("trigger_0h_pulse_width");
769  default: return -1;
770  }
771  }
772 
780  void setTrigger0PulseWidth(double width, int pulse=0) {
781  switch(pulse) {
782  case 0: writeDoubleParameter("trigger_0_pulse_width", width);break;
783  case 1: writeDoubleParameter("trigger_0b_pulse_width", width);break;
784  case 2: writeDoubleParameter("trigger_0c_pulse_width", width);break;
785  case 3: writeDoubleParameter("trigger_0d_pulse_width", width);break;
786  case 4: writeDoubleParameter("trigger_0e_pulse_width", width);break;
787  case 5: writeDoubleParameter("trigger_0f_pulse_width", width);break;
788  case 6: writeDoubleParameter("trigger_0g_pulse_width", width);break;
789  case 7: writeDoubleParameter("trigger_0h_pulse_width", width);break;
790  default: return;
791  }
792  }
793 
801  double getTrigger1PulseWidth(int pulse=0) {
802  switch(pulse) {
803  case 0: return readDoubleParameter("trigger_1_pulse_width");
804  case 1: return readDoubleParameter("trigger_1b_pulse_width");
805  case 2: return readDoubleParameter("trigger_1c_pulse_width");
806  case 3: return readDoubleParameter("trigger_1d_pulse_width");
807  case 4: return readDoubleParameter("trigger_1e_pulse_width");
808  case 5: return readDoubleParameter("trigger_1f_pulse_width");
809  case 6: return readDoubleParameter("trigger_1g_pulse_width");
810  case 7: return readDoubleParameter("trigger_1h_pulse_width");
811  default: return -1;
812  }
813  }
814 
822  void setTrigger1PulseWidth(double width, int pulse=0) {
823  switch(pulse) {
824  case 0: writeDoubleParameter("trigger_1_pulse_width", width);break;
825  case 1: writeDoubleParameter("trigger_1b_pulse_width", width);break;
826  case 2: writeDoubleParameter("trigger_1c_pulse_width", width);break;
827  case 3: writeDoubleParameter("trigger_1d_pulse_width", width);break;
828  case 4: writeDoubleParameter("trigger_1e_pulse_width", width);break;
829  case 5: writeDoubleParameter("trigger_1f_pulse_width", width);break;
830  case 6: writeDoubleParameter("trigger_1g_pulse_width", width);break;
831  case 7: writeDoubleParameter("trigger_1h_pulse_width", width);break;
832  default: return;
833  }
834  }
835 
840  double getTrigger1Offset() {
841  return readDoubleParameter("trigger_1_offset");
842  }
843 
848  void setTrigger1Offset(double offset) {
849  writeDoubleParameter("trigger_1_offset", offset);
850  }
851 
855  bool getInput() {
856  return readBoolParameter("trigger_input");
857  }
858 
862  void setTrigger1Offset(bool enabled) {
863  writeBoolParameter("trigger_input", enabled);
864  }
865 
866 
867  // Auto calibration parameters
868 
873  return readBoolParameter("auto_recalibration_enabled");
874  }
875 
879  void setAutoRecalibrationEnabled(bool enabled) {
880  writeBoolParameter("auto_recalibration_enabled", enabled);
881  }
882 
887  return readBoolParameter("auto_recalibration_permanent");
888  }
889 
893  void setSaveAutoRecalibration(bool save) {
894  writeBoolParameter("auto_recalibration_permanent", save);
895  }
896 
902  return readBoolParameter("subpixel_optimization_roi_enabled");
903  }
904 
910  writeBoolParameter("subpixel_optimization_roi_enabled", enabled);
911  }
912 
926  void getSubpixelOptimizationROI(int& x, int& y, int& width, int& height) {
927  x = readIntParameter("subpixel_optimization_roi_x");
928  y = readIntParameter("subpixel_optimization_roi_y");
929  width = readIntParameter("subpixel_optimization_roi_width");
930  height = readIntParameter("subpixel_optimization_roi_height");
931  }
932 
946  void setSubpixelOptimizationROI(int x, int y, int width, int height) {
947  writeIntParameter("subpixel_optimization_roi_x", x);
948  writeIntParameter("subpixel_optimization_roi_y", y);
949  writeIntParameter("subpixel_optimization_roi_width", width);
950  writeIntParameter("subpixel_optimization_roi_height", height);
951  }
952 
956  void reboot() {
957  writeBoolParameter("reboot", true);
958  }
959 
968  DEPRECATED("Use getParameterSet() instead")
969  std::map<std::string, ParameterInfo> getAllParameters();
970 
977  template<typename T>
978  DEPRECATED("Use setParameter() instead")
979  void setNamedParameter(const std::string& name, T value);
980 
984  template<typename T>
985  void setParameter(const std::string& name, T value);
986 
993  template<typename T>
994  DEPRECATED("Use getParameter() instead")
995  T getNamedParameter(const std::string& name);
996 
997 #if __cplusplus >= 201103L
998 
1006  visiontransfer::param::Parameter getParameter(const std::string& name);
1007 
1018  visiontransfer::param::ParameterSet getParameterSet();
1019 
1020 #endif
1021 
1022 private:
1023  // We (mostly) follow the pimpl idiom here
1024  class Pimpl;
1025  Pimpl* pimpl;
1026 
1027  // This class cannot be copied
1028  DeviceParameters(const DeviceParameters& other);
1029  DeviceParameters& operator=(const DeviceParameters& other);
1030 
1031  // Generic functions for reading parameters
1032  int readIntParameter(const char* id);
1033  double readDoubleParameter(const char* id);
1034  bool readBoolParameter(const char* id);
1035 
1036  // Generic functions for writing parameters
1037  void writeIntParameter(const char* id, int value);
1038  void writeDoubleParameter(const char* id, double value);
1039  void writeBoolParameter(const char* id, bool value);
1040 
1041 };
1042 
1043 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1044 // For source compatibility
1045 DEPRECATED("Use DeviceParameters instead.")
1046 typedef DeviceParameters SceneScanParameters;
1047 #endif
1048 
1049 } // namespace
1050 
1051 #endif
void setTrigger0Constant(bool on)
Sets the constant value that is output when trigger 0 is disabled.
void setTrigger1Enabled(bool enabled)
Enables or disables trigger signal 1.
int getAutoSkippedFrames()
Gets the current interval at which the automatic exposure and gain control is run.
bool getTextureFilterEnabled()
Returns true if the texture filter is enabled.
double getTrigger1PulseWidth(int pulse=0)
Gets the pulse width of trigger signal 1.
void setAutoTargetFrame(TargetFrame target)
Selects the target frame for automatic exposure and gain control.
void setMaskBorderPixelsEnabled(bool enabled)
Enables or disables the removal of border pixels from the computed disparity map. ...
void setAutoROI(int x, int y, int width, int height)
Sets the configured ROI for automatic exposure and gain control.
bool getTrigger1Polarity()
Returns false if trigger1 polarity is active-high (non-inverted) and false if polarity is active-low ...
int getConsistencyCheckSensitivity()
Gets the current sensitivity value for the consistency check.
bool getTrigger1Enabled()
Returns true if trigger signal 1 is enabled.
void setAutoMaxExposureTime(double time)
Sets the maximum exposure time that can be selected automatically.
TargetFrame
Possible options for the target frame selection of the automatic exposure and gain control...
double getAutoIntensityDelta()
Gets the minimum intensity change that is required for adjusting the camera settings.
TargetFrame getAutoTargetFrame()
Gets the selected target frame for automatic exposure and gain control.
int getStereoMatchingP2NoEdge()
Gets the SGM penalty P2 for large disparity changes at image edges.
bool getMaskBorderPixelsEnabled()
Returns true if border pixels are removed from the computed disparity map.
int getSpeckleFilterIterations()
Returns true if the speckle filter is enabled.
void setAutoTargetIntensity(double intensity)
Sets the target image intensity of the automatic exposure and gain control.
void setAutoIntensityDelta(double delta)
Sets the minimum intensity change that is required for adjusting the camera settings.
void setAutoROIEnabled(bool enabled)
Enables or disables an ROI for automatic exposure and gain control.
void setDisparityOffset(int offset)
Sets the offset of the evaluated disparity range.
void setTrigger0Polarity(bool invert)
Sets the polarity for trigger0. If invert is false, the polarity is active-high (non-inverted). Otherwise the polarity is active-low (inverted).
double getAutoMaxGain()
Gets the maximum gain that can be selected automatically.
void setTrigger1Polarity(bool invert)
Sets the polarity for trigger1. If invert is false, the polarity is active-high (non-inverted). Otherwise the polarity is active-low (inverted).
OperationMode getOperationMode()
Gets the current operation mode.
void reboot()
Remotely triggers a reboot of the device.
void setConsistencyCheckEnabled(bool enabled)
Enables or disables the consistency check.
void setAutoRecalibrationEnabled(bool enabled)
Enables or disables auto-recalibration.
void setOperationMode(OperationMode mode)
Configures the device to a new operation mode.
void setStereoMatchingEdgeSensitivity(int sensitivity)
Sets the edge sensitivity of the SGM algorithm.
double getTrigger0PulseWidth(int pulse=0)
Gets the pulse width of trigger signal 0.
void setTrigger1Constant(bool on)
Sets the constant value that is output when trigger 1 is disabled.
void setTrigger0Enabled(bool enabled)
Enables or disables trigger signal 0.
void setTrigger0PulseWidth(double width, int pulse=0)
Sets the pulse width of trigger signal 0.
bool getTrigger0Polarity()
Returns false if trigger0 polarity is active-high (non-inverted) and false if polarity is active-low ...
void setSubpixelOptimizationROIEnabled(bool enabled)
Enables or disables an ROI for the subpixel optimization algorithm. (if disabled, complete frames are...
void setGapInterpolationEnabled(bool enabled)
Enables or disables the gap interpolation.
int getStereoMatchingEdgeSensitivity()
Gets the edge sensitivity of the SGM algorithm.
double getAutoMaxExposureTime()
Gets the maximum exposure time that can be selected automatically.
double getTriggerFrequency()
Gets the frequency of the trigger signal.
void getAutoROI(int &x, int &y, int &width, int &height)
Gets the configured ROI for automatic exposure and gain control.
bool getSubpixelOptimizationROIEnabled()
Returns true if an ROI for the subpixel optimization algorithm is enabled (otherwise complete frames ...
bool getAutoROIEnabled()
Returns true if an ROI for automatic exposure and gain control is enabled.
void setConsistencyCheckSensitivity(int sensitivity)
Sets a new sensitivity value for the consistency check.
double getTrigger1Offset()
Gets the time offset between trigger signal 1 and signal 0.
bool getUniquenessCheckEnabled()
Returns true if the consistency check is enabled.
bool getInput()
Returns true if the extgernal trigger input is enabled.
void setTriggerFrequency(double freq)
Sets the frequency of the trigger signal.
double getManualGain()
Gets the manually selected gain.
void setSpeckleFilterIterations(int iter)
Enables or disables the speckle filter.
void setSubpixelOptimizationROI(int x, int y, int width, int height)
Sets the configured ROI for the subpixel optimization algorithm.
void setStereoMatchingP1Edge(int p1)
Sets the SGM penalty P1 for small disparity changes at image edges.
void getSubpixelOptimizationROI(int &x, int &y, int &width, int &height)
Gets the configured ROI for the subpixel optimization algorithm.
double getAutoTargetIntensity()
Gets the target image intensity of the automatic exposure and gain control.
void setStereoMatchingP2Edge(int p2)
Sets the SGM penalty P2 for large disparity changes at image edges.
int getMaxFrameTimeDifference()
Gets the maximum allowed time difference between two corresponding frames.
void setTextureFilterSensitivity(int sensitivity)
Sets a new sensitivity value for the texture filter.
int getUniquenessCheckSensitivity()
Gets the current sensitivity value for the uniqueness check.
bool getTrigger0Constant()
Returns the constant value that is output when trigger 0 is disabled.
void setNoiseReductionEnabled(bool enabled)
Enables or disables the noise reduction filter.
Aggregates information about a discovered device.
Definition: deviceinfo.h:47
Allows for configuration of the parameters of a Nerian stereo device through a network connection...
int getTextureFilterSensitivity()
Gets the current sensitivity value for the texture filter.
void setStereoMatchingP2NoEdge(int p2)
Sets the SGM penalty P2 for large disparity changes at image edges.
void setTrigger1PulseWidth(double width, int pulse=0)
Sets the pulse width of trigger signal 1.
void setTrigger1Offset(bool enabled)
Enables or disables the external trigger input.
bool getAutoRecalibrationEnabled()
Returns true if auto re-calibration is enabled.
void setAutoSkippedFrames(int skipped)
Sets the current interval at which the automatic exposure and gain control is run.
void setSaveAutoRecalibration(bool save)
Enables or disables persistent storage of auto re-calibration results.
int getStereoMatchingP1NoEdge()
Gets the SGM penalty P1 for small disparity changes outside image edges.
void setManualExposureTime(double time)
Sets the manually selected exposure time.
int getStereoMatchingP2Edge()
Gets the SGM penalty P2 for large disparity changes at image edges.
int getStereoMatchingP1Edge()
Gets the SGM penalty P1 for small disparity changes at image edges.
void setUniquenessCheckEnabled(bool enabled)
Enables or disables the uniqueness check.
int getDisparityOffset()
Gets the current offset of the evaluated disparity range.
void setUniquenessCheckSensitivity(int sensitivity)
Sets a new sensitivity value for the uniqueness check.
AutoMode getAutoMode()
Gets the current mode of the automatic exposure and gain control.
void setTrigger1Offset(double offset)
Sets the time offset between trigger signal 1 and signal 0.
bool getSaveAutoRecalibration()
Returns true if persistent storage of auto re-calibration results is enabled.
void setAutoMaxGain(double gain)
Gets the maximum gain that can be selected automatically.
void setTextureFilterEnabled(bool enabled)
Enables or disables the texture filter.
double getManualExposureTime()
Gets the manually selected exposure time.
bool getTrigger1Constant()
Returns the constant value that is output when trigger 1 is disabled.
bool getConsistencyCheckEnabled()
Returns true if the consistency check is enabled.
bool getTrigger0Enabled()
Returns true if trigger signal 0 is enabled.
void setStereoMatchingP1NoEdge(int p1)
Sets the SGM penalty P1 for small disparity changes outside image edges.
AutoMode
Possible modes of the automatic exposure and gain control.
bool getNoiseReductionEnabled()
Returns true if the noise reduction filter is enabled.
void setMaxFrameTimeDifference(int diffMs)
Sets the maximum allowed time difference between two corresponding frames.
bool getGapInterpolationEnabled()
Returns true if the texture gap interpolation is enabled.
void setAutoMode(AutoMode mode)
Sets the current mode of the automatic exposure and gain control.
void setManualGain(double gain)
Sets the manually selected gain.
OperationMode
Operation modes supported by Nerian stereo devices.
Nerian Vision Technologies