Libargus API Libargus Camera API

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

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:
217 ~ISourceSettings() {}
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);
228 class IAutoControlSettings : public Interface
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 */
376 virtual Size2D<uint32_t> getColorCorrectionMatrixSize() const = 0;
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:
538 ~IAutoControlSettings() {}
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);
549 class IStreamSettings : public Interface
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:
586 ~IStreamSettings() {}
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);
597 class IDenoiseSettings : public Interface
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:
636 ~IDenoiseSettings() {}
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);
647 class IEdgeEnhanceSettings : public Interface
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:
686 ~IEdgeEnhanceSettings() {}
687 };
688
689 } // namespace Argus
690
691 #endif // _ARGUS_SETTINGS_H