Libargus API
Libargus Camera API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
Settings.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016-2020, NVIDIA CORPORATION. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * * Redistributions of source code must retain the above copyright
8  * notice, this list of conditions and the following disclaimer.
9  * * Redistributions in binary form must reproduce the above copyright
10  * notice, this list of conditions and the following disclaimer in the
11  * documentation and/or other materials provided with the distribution.
12  * * Neither the name of NVIDIA CORPORATION nor the names of its
13  * contributors may be used to endorse or promote products derived
14  * from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
24  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 /**
30  * @file
31  * <b>Libargus API: Settings API</b>
32  *
33  * @b Description: This file defines the settings that control the sensor module.
34  */
35 
36 #ifndef _ARGUS_SETTINGS_H
37 #define _ARGUS_SETTINGS_H
38 
39 namespace Argus
40 {
41 
42 /**
43  * @class ISourceSettings
44  *
45  * Interface to the source settings (provided by IRequest::getSourceSettings()).
46  *
47  * @ingroup ArgusSourceSettings
48  */
49 DEFINE_UUID(InterfaceID, IID_SOURCE_SETTINGS, eb7ae38c,3c62,4161,a92a,a6,4f,ba,c6,38,83);
50 class ISourceSettings : public Interface
51 {
52 public:
53  static const InterfaceID& id() { return IID_SOURCE_SETTINGS; }
54 
55  /**
56  * Sets the exposure time range of the source, in nanoseconds.
57  * If the exposure range is outside of the available range, the capture's exposure time
58  * will be as close as possible to the exposure range specified.
59  * @param[in] exposureTimeRange Exposure time range, in nanoseconds.
60  * @see ISensorMode::getExposureTimeRange()
61  * @todo Document implications of quantization.
62  *
63  * @returns success/status of the call.
64  */
65  virtual Status setExposureTimeRange(const Range<uint64_t>& exposureTimeRange) = 0;
66 
67  /**
68  * Returns the exposure time range of the source, in nanoseconds.
69  */
70  virtual Range<uint64_t> getExposureTimeRange() const = 0;
71 
72  /**
73  * Sets the focus position, in focuser units. If the position
74  * is set outside of the focuser limits, the position will be clamped.
75  * @param[in] position The new focus position, in focuser units.
76  * @see ICameraProperties::getFocusPositionRange()
77  *
78  * @returns success/status of the call.
79  */
80  virtual Status setFocusPosition(int32_t position) = 0;
81 
82  /**
83  * Returns the focus position, in focuser units.
84  */
85  virtual int32_t getFocusPosition() const = 0;
86 
87  /**
88  * Sets the aperture position. If the position is not valid,
89  * error will be returned.
90  * @param[in] position The new aperture position.
91  * @see ICameraProperties::getAperturePositionRange()
92  *
93  * @returns success/status of the call.
94  */
95  virtual Status setAperturePosition(int32_t position) = 0;
96 
97  /**
98  * Returns the aperture position.
99  */
100  virtual int32_t getAperturePosition() const = 0;
101 
102  /**
103  * Sets the aperture motor speed in motor steps/second. If the speed
104  * is set outside of the speed limits, the speed will be clamped.
105  * @param[in] speed The new speed.
106  * @see ICameraProperties::getApertureMotorSpeedRange()
107  *
108  * @returns success/status of the call.
109  */
110  virtual Status setApertureMotorSpeed(float speed) = 0;
111 
112  /**
113  * Returns the aperture motor speed in motor steps/second.
114  */
115  virtual float getApertureMotorSpeed() const = 0;
116 
117  /**
118  * Sets the aperture f-number. If the f-number is not valid,
119  * error will be returned.
120  * @param[in] fnumber The new f-number.
121  *
122  * @returns success/status of the call.
123  */
124  virtual Status setApertureFNumber(float fnumber) = 0;
125 
126  /**
127  * Returns the aperture f-number.
128  */
129  virtual float getApertureFNumber() const = 0;
130 
131  /**
132  * Sets the frame duration range, in nanoseconds.
133  * If frame range is out of bounds of the current sensor mode,
134  * the capture's frame duration will be as close as possible to the range specified.
135  * @param[in] frameDurationRange Frame duration range, in nanoseconds
136  * @see ISensorMode::getFrameDurationRange()
137  *
138  * @returns success/status of the call.
139  */
140  virtual Status setFrameDurationRange(const Range<uint64_t>& frameDurationRange) = 0;
141 
142  /**
143  * Returns the frame duration range, in nanoseconds.
144  */
145  virtual Range<uint64_t> getFrameDurationRange() const = 0;
146 
147  /**
148  * Sets the gain range for the sensor.
149  * The range has to be within the max and min reported in the CameraProperties
150  * Otherwise the range will be clipped.
151  * @param[in] gainRange scalar gain range
152  * @see ISensorMode::getAnalogGainRange()
153  *
154  * @returns success/status of the call.
155  */
156  virtual Status setGainRange(const Range<float>& gainRange) = 0;
157 
158  /**
159  * Returns the gain range.
160  */
161  virtual Range<float> getGainRange() const = 0;
162 
163  /**
164  * Sets the sensor mode.
165  * Note that changing sensor mode from one capture to the next may result in
166  * multiple sensor frames being dropped between the two captures.
167  * @param[in] mode Desired sensor mode for the capture.
168  * @see ICameraProperties::getAllSensorModes()
169  *
170  * @returns success/status of the call.
171  */
172  virtual Status setSensorMode(SensorMode* mode) = 0;
173 
174  /**
175  * Returns the sensor mode.
176  */
177  virtual SensorMode* getSensorMode() const = 0;
178 
179  /**
180  * Sets the user-specified optical black levels.
181  * These values will be ignored unless <tt>getOpticalBlackEnable() == true</tt>
182  * Values are floating point in the range [0,1) normalized based on sensor bit depth.
183  * @param[in] opticalBlackLevels opticalBlack levels in range [0,1) per bayer phase
184  *
185  * @returns success/status of the call.
186  */
187  virtual Status setOpticalBlack(const BayerTuple<float>& opticalBlackLevels) = 0;
188 
189  /**
190  * Returns user-specified opticalBlack level per bayer phase.
191  *
192  * @returns opticalBlackLevels
193  */
194  virtual BayerTuple<float> getOpticalBlack() const = 0;
195 
196  /**
197  * Sets whether or not user-provided optical black levels are used.
198  * @param[in] enable If @c true, Argus will use the user-specified optical black levels.
199  * @see setOpticalBlack()
200  * If @c false, the Argus implementation will choose the optical black values.
201  *
202  * @returns success/status of the call.
203  */
204  virtual Status setOpticalBlackEnable(bool enable) = 0;
205 
206  /**
207  * Returns whether user-specified optical black levels are enabled.
208  * If false, the Argus implementation will choose the optical black values.
209  * @see setOpticalBlackEnable()
210  *
211  * @returns enable
212  */
213  virtual bool getOpticalBlackEnable() const = 0;
214 
215 
216 protected:
218 };
219 
220 /**
221  * @class IAutoControlSettings
222  *
223  * Interface to the auto control settings (provided by IRequest::getAutoControlSettings()).
224  *
225  * @ingroup ArgusAutoControlSettings
226  */
227 DEFINE_UUID(InterfaceID, IID_AUTO_CONTROL_SETTINGS, 1f2ad1c6,cb13,440b,bc95,3f,fd,0d,19,91,db);
229 {
230 public:
231  static const InterfaceID& id() { return IID_AUTO_CONTROL_SETTINGS; }
232 
233  /**
234  * Sets the AE antibanding mode.
235  * @param[in] mode The requested antibanding mode.
236  *
237  * @returns success/status of the call.
238  */
239  virtual Status setAeAntibandingMode(const AeAntibandingMode& mode) = 0;
240 
241  /**
242  * Returns the AE antibanding mode.
243  */
244  virtual AeAntibandingMode getAeAntibandingMode() const = 0;
245 
246  /**
247  * Sets the AE lock. When locked, AE will maintain constant exposure.
248  * @param[in] lock If @c true, locks AE at its current exposure.
249  *
250  * @returns success/status of the call.
251  */
252  virtual Status setAeLock(bool lock) = 0;
253 
254  /**
255  * Returns the AE lock.
256  */
257  virtual bool getAeLock() const = 0;
258 
259  /**
260  * Sets the AE regions of interest.
261  * If no regions are specified, the region of interest will be determined by device
262  * and obtain by CameraMetadata::getAeRegions.
263  * @param[in] regions The AE regions of interest.
264  * The maximum number of regions is returned by @c ICameraProperties::getMaxAeRegions().
265  * The minimum supported size of resultatnt region is returned by
266  * @c ICameraProperties::getMinAeRegionSize().
267  *
268  * @returns success/status of the call.
269  */
270  virtual Status setAeRegions(const std::vector<AcRegion>& regions) = 0;
271 
272  /**
273  * Returns the AE regions of interest.
274  * @param[out] regions A vector that will be populated with the AE regions of interest.
275  *
276  * @returns success/status of the call.
277  */
278  virtual Status getAeRegions(std::vector<AcRegion>* regions) const = 0;
279 
280  /**
281  * Sets the bayer histogram region of interest.
282  * If no region is specified, the entire image is the region of interest.
283  * @param[in] region The bayer histogram region of interest.
284  *
285  * @returns success/status of the call.
286  */
287  virtual Status setBayerHistogramRegion(const Rectangle<uint32_t>& region) = 0;
288 
289  /**
290  * Returns the rectangle of the bayer histogram region of interest.
291  */
292  virtual Rectangle<uint32_t> getBayerHistogramRegion() const = 0;
293 
294  /**
295  * Sets the AWB lock.
296  * @param[in] lock If @c true, locks AWB at its current state.
297  *
298  * @returns success/status of the call.
299  */
300  virtual Status setAwbLock(bool lock) = 0;
301 
302  /**
303  * Returns the AWB lock.
304  */
305  virtual bool getAwbLock() const = 0;
306 
307  /**
308  * Sets the AWB mode.
309  * @param[in] mode The new AWB mode.
310  *
311  * @returns success/status of the call.
312  */
313  virtual Status setAwbMode(const AwbMode& mode) = 0;
314 
315  /**
316  * Returns the AWB mode.
317  */
318  virtual AwbMode getAwbMode() const = 0;
319 
320  /**
321  * Sets the AWB regions of interest.
322  * If no regions are specified, the region of interest will be determined by device
323  * and obtain by CameraMetadata::getAwbRegions.
324  * @param[in] regions The AWB regions of interest.
325  * The maximum number of regions is returned by @c ICameraProperties::getMaxAwbRegions().
326  *
327  * @returns success/status of the call.
328  */
329  virtual Status setAwbRegions(const std::vector<AcRegion>& regions) = 0;
330 
331  /**
332  * Returns the AWB regions of interest.
333  * @param[out] regions A vector that will be populated with the AWB regions of interest.
334  *
335  * @returns success/status of the call.
336  */
337  virtual Status getAwbRegions(std::vector<AcRegion>* regions) const = 0;
338 
339  /**
340  * Sets the AF regions of interest.
341  * If no regions are specified, the region of interest will be determined by device
342  * and obtain by CameraMetadata::getAfRegions.
343  * @param[in] regions The AF regions of interest.
344  * The maximum number of regions is returned by @c ICameraProperties::getMaxAfRegions().
345  *
346  * @returns success/status of the call.
347  */
348  virtual Status setAfRegions(const std::vector<AcRegion>& regions) = 0;
349 
350  /**
351  * Returns the AF regions of interest.
352  * @param[out] regions A vector that will be populated with the AF regions of interest.
353  *
354  * @returns success/status of the call.
355  */
356  virtual Status getAfRegions(std::vector<AcRegion>* regions) const = 0;
357 
358  /**
359  * Sets the Manual White Balance gains.
360  * @param[in] gains The Manual White Balance Gains
361  *
362  * @returns success/status of the call.
363  */
364  virtual Status setWbGains(const BayerTuple<float>& gains) = 0;
365 
366  /**
367  * Returns the Manual White Balance gains.
368  *
369  * @returns Manual White Balance Gains structure
370  */
371  virtual BayerTuple<float> getWbGains() const = 0;
372 
373  /**
374  * Returns the size of the color correction matrix.
375  */
377 
378  /**
379  * Sets the user-specified color correction matrix.
380  * This matrix will be ignored unless <tt>getColorCorrectionMatrixEnable() == true</tt>.
381  * The active color correction matrix used for image processing may be internally modified
382  * to account for the active color saturation value (either user-specified or automatically
383  * generated, after biasing, @see setColorSaturation and @see setColorSaturationBias).
384  * @param[in] matrix A color correction matrix that maps sensor RGB to linear sRGB. This matrix
385  * is given in row-major order and must have the size w*h, where w and h are
386  * the width and height of the Size returned by getColorCorrectionMatrixSize()
387  *
388  * @returns success/status of the call.
389  */
390  virtual Status setColorCorrectionMatrix(const std::vector<float>& matrix) = 0;
391 
392  /**
393  * Returns the user-specified color correction matrix.
394  * @param[out] matrix A matrix that will be populated with the CCM.
395  *
396  * @returns success/status of the call.
397  */
398  virtual Status getColorCorrectionMatrix(std::vector<float>* matrix) const = 0;
399 
400  /**
401  * Enables the user-specified color correction matrix.
402  * @param[in] enable If @c true, libargus uses the user-specified matrix.
403  * @see setColorCorrectionMatrix()
404  *
405  * @returns success/status of the call.
406  */
407  virtual Status setColorCorrectionMatrixEnable(bool enable) = 0;
408 
409  /**
410  * Returns the enable for the user-specified color correction matrix.
411  */
412  virtual bool getColorCorrectionMatrixEnable() const = 0;
413 
414  /**
415  * Sets the user-specified absolute color saturation. This must be enabled via
416  * @see setColorSaturationEnable, otherwise saturation will be determined automatically.
417  * This saturation value may be used to modify the color correction matrix used
418  * for processing (@see setColorCorrectionMatrix), and these changes will be reflected
419  * in the color correction matrix output to the capture metadata.
420  * @param[in] saturation The absolute color saturation. Acceptable values are in
421  * [0.0, 2.0], and the default value is 1.0.
422 
423  * @returns success/status of the call.
424  */
425  virtual Status setColorSaturation(float saturation) = 0;
426 
427  /**
428  * Returns the user-specified absolute color saturation (@see setColorSaturation).
429  */
430  virtual float getColorSaturation() const = 0;
431 
432  /**
433  * Enables the user-specified absolute color saturation.
434  * @param[in] enable If @c true, libargus uses the user-specified color saturation.
435  * @see setColorSaturation()
436  *
437  * @returns success/status of the call.
438  */
439  virtual Status setColorSaturationEnable(bool enable) = 0;
440 
441  /**
442  * Returns the enable for the user-specified color saturation.
443  */
444  virtual bool getColorSaturationEnable() const = 0;
445 
446  /**
447  * Sets the color saturation bias. This bias is used to multiply the active saturation
448  * value, either the user-specified or the automatically generated value depending on the state
449  * of @see getColorSaturationEnable, and produces the final saturation value to use for
450  * capture processing. This is used primarily to tweak automatically generated saturation
451  * values when the application prefers more or less saturation than what the implementation
452  * or hardware generates by default. The final saturation value (after biasing) may affect the
453  * color correction matrix used for processing (@see setColorCorrectionMatrix).
454  * @param[in] bias The color saturation bias. Acceptable values are in [0.0, 2.0], where
455  * 1.0 does not modify the saturation (default), 0.0 is fully desaturated
456  * (greyscale), and 2.0 is highly saturated.
457  *
458  * @returns success/status of the call.
459  */
460  virtual Status setColorSaturationBias(float bias) = 0;
461 
462  /**
463  * Returns the color saturation bias.
464  */
465  virtual float getColorSaturationBias() const = 0;
466 
467  /**
468  * Sets the exposure compensation.
469  * Exposure compensation is applied after AE is solved.
470  * @param[in] ev The exposure adjustment step in stops.
471  *
472  * @returns success/status of the call.
473  */
474  virtual Status setExposureCompensation(float ev) = 0;
475 
476  /**
477  * Returns the exposure compensation.
478  */
479  virtual float getExposureCompensation() const = 0;
480 
481  /**
482  * Returns the number of elements required for the tone map curve.
483  * @param[in] channel The color channel the curve size corresponds to.
484  */
485  virtual uint32_t getToneMapCurveSize(RGBChannel channel) const = 0;
486 
487  /**
488  * Sets the user-specified tone map curve for a channel on the stream.
489  * The user-specified tone map will be ignored unless <tt>getToneMapCurveEnable() == true</tt>.
490  * @param[in] channel The color the curve corresponds to.
491  * @param[in] curve A float vector that describes the LUT.
492  * The number of elements must match the number of elements
493  * returned from getToneMapCurve() of the same channel.
494  *
495  * @returns success/status of the call.
496  */
497  virtual Status setToneMapCurve(RGBChannel channel, const std::vector<float>& curve) = 0;
498 
499  /**
500  * Returns the user-specified tone map curve for a channel on the stream.
501  * @param[in] channel The color the curve corresponds to.
502  * @param[out] curve A vector that will be populated by the tone map curve for the specified
503  * color channel.
504  *
505  * @returns success/status of the call.
506  */
507  virtual Status getToneMapCurve(RGBChannel channel, std::vector<float>* curve) const = 0;
508 
509  /**
510  * Enables the user-specified tone map.
511  * @param[in] enable If @c true, libargus uses the user-specified tone map.
512  *
513  * @returns success/status of the call.
514  */
515  virtual Status setToneMapCurveEnable(bool enable) = 0;
516 
517  /**
518  * Returns the enable for the user-specified tone map.
519  */
520  virtual bool getToneMapCurveEnable() const = 0;
521 
522  /**
523  * Sets the user-specified Isp Digital gain range.
524  * @param[in] gain The user-specified Isp Digital gain.
525  *
526  * @returns success/status of the call.
527  */
528  virtual Status setIspDigitalGainRange(const Range<float>& gain) = 0;
529 
530  /**
531  * Returns the user-specified Isp Digital gain range.
532  *
533  * @returns Isp Digital gain
534  */
535  virtual Range<float> getIspDigitalGainRange() const = 0;
536 
537 protected:
539 };
540 
541 /**
542  * @class IStreamSettings
543  *
544  * Interface to per-stream settings (provided by IRequest::getStreamSettings()).
545  *
546  * @ingroup ArgusStreamSettings
547  */
548 DEFINE_UUID(InterfaceID, IID_STREAM_SETTINGS, c477aeaf,9cc8,4467,a834,c7,07,d7,b6,9f,a4);
550 {
551 public:
552  static const InterfaceID& id() { return IID_STREAM_SETTINGS; }
553 
554  /**
555  * Sets the clip rectangle for the stream.
556  * A clip rectangle is a normalized rectangle
557  * with valid coordinates contained in the [0.0,1.0] range.
558  * @param[in] clipRect The clip rectangle.
559  *
560  * @returns success/status of the call.
561  */
562  virtual Status setSourceClipRect(const Rectangle<float>& clipRect) = 0;
563 
564  /**
565  * Returns the clip rectangle for the stream.
566  */
567  virtual Rectangle<float> getSourceClipRect() const = 0;
568 
569  /**
570  * Sets whether or not post-processing is enabled for this stream.
571  * Post-processing features are controlled on a per-Request basis and all streams share the
572  * same post-processing control values, but this enable allows certain streams to be excluded
573  * from all post-processing. The current controls defined to be a part of "post-processing"
574  * includes (but may not be limited to):
575  * - Denoise
576  * Default value is true.
577  */
578  virtual void setPostProcessingEnable(bool enable) = 0;
579 
580  /**
581  * Returns the post-processing enable for the stream.
582  */
583  virtual bool getPostProcessingEnable() const = 0;
584 
585 protected:
587 };
588 
589 /**
590  * @class IDenoiseSettings
591  *
592  * Interface to denoise settings.
593  *
594  * @ingroup ArgusRequest
595  */
596 DEFINE_UUID(InterfaceID, IID_DENOISE_SETTINGS, 7A461D20,6AE1,11E6,BDF4,08,00,20,0C,9A,66);
598 {
599 public:
600  static const InterfaceID& id() { return IID_DENOISE_SETTINGS; }
601 
602  /**
603  * Sets the denoise (noise reduction) mode for the request.
604  * @param[in] mode The denoise mode:
605  * OFF: Denoise algorithms are disabled.
606  * FAST: Noise reduction will be enabled, but it will not slow down
607  * the capture rate.
608  * HIGH_QUALITY: Maximum noise reduction will be enabled to achieve
609  * the highest quality, but may slow down the capture rate.
610  * @returns success/status of the call.
611  */
612  virtual Status setDenoiseMode(const DenoiseMode& mode) = 0;
613 
614  /**
615  * Returns the denoise mode for the request.
616  */
617  virtual DenoiseMode getDenoiseMode() const = 0;
618 
619  /**
620  * Sets the strength for the denoise operation.
621  * @param[in] strength The denoise strength. This must be within the range [0.0, 1.0], where
622  * 0.0 is the least and 1.0 is the most amount of noise reduction that can be
623  * applied. This denoise strength is relative to the current noise reduction mode;
624  * using a FAST denoise mode with a full strength of 1.0 may not perform as well
625  * as using a HIGH_QUALITY mode with a lower relative strength.
626  * @returns success/status of the call.
627  */
628  virtual Status setDenoiseStrength(float strength) = 0;
629 
630  /**
631  * Returns the denoise strength.
632  */
633  virtual float getDenoiseStrength() const = 0;
634 
635 protected:
637 };
638 
639 /**
640  * @class IEdgeEnhanceSettings
641  *
642  * Interface to edge enhancement settings.
643  *
644  * @ingroup ArgusRequest
645  */
646 DEFINE_UUID(InterfaceID, IID_EDGE_ENHANCE_SETTINGS, 7A461D21,6AE1,11E6,BDF4,08,00,20,0C,9A,66);
648 {
649 public:
650  static const InterfaceID& id() { return IID_EDGE_ENHANCE_SETTINGS; }
651 
652  /**
653  * Sets the edge enhancement mode for the request.
654  * @param[in] mode The edge enhancement mode:
655  * OFF: Edge enhancement algorithms are disabled.
656  * FAST: Edge enhancement will be enabled, but it will not slow down
657  * the capture rate.
658  * HIGH_QUALITY: Maximum edge enhancement will be enabled to achieve
659  * the highest quality, but may slow down the capture rate.
660  * @returns success/status of the call.
661  */
662  virtual Status setEdgeEnhanceMode(const EdgeEnhanceMode& mode) = 0;
663 
664  /**
665  * Returns the edge enhancement mode for the request.
666  */
667  virtual EdgeEnhanceMode getEdgeEnhanceMode() const = 0;
668 
669  /**
670  * Sets the strength for the edge enhancement operation.
671  * @param[in] strength The edge enhancement strength. This must be within the range [0.0, 1.0],
672  * where 0.0 is the least and 1.0 is the most amount of edge enhancement that can be
673  * applied. This strength is relative to the current edge enhancement mode; using
674  * a FAST edge enhancement mode with a full strength of 1.0 may not perform as well
675  * as using a HIGH_QUALITY mode with a lower relative strength.
676  * @returns success/status of the call.
677  */
678  virtual Status setEdgeEnhanceStrength(float strength) = 0;
679 
680  /**
681  * Returns the edge enhancement strength.
682  */
683  virtual float getEdgeEnhanceStrength() const = 0;
684 
685 protected:
687 };
688 
689 } // namespace Argus
690 
691 #endif // _ARGUS_SETTINGS_H