Zivid C++ API 2.5.0+19fa6891-1
Defining the Future of 3D Machine Vision
Settings.h
Go to the documentation of this file.
1
2
3/*******************************************************************************
4
5 * This file is part of the Zivid 3D Camera API
6
7 *
8
9 * Copyright 2015-2021 (C) Zivid AS
10
11 * All rights reserved.
12
13 *
14
15 * Zivid Software License, v1.0
16
17 *
18
19 * Redistribution and use in source and binary forms, with or without
20
21 * modification, are permitted provided that the following conditions are met:
22
23 *
24
25 * 1. Redistributions of source code must retain the above copyright notice,
26
27 * this list of conditions and the following disclaimer.
28
29 *
30
31 * 2. Redistributions in binary form must reproduce the above copyright notice,
32
33 * this list of conditions and the following disclaimer in the documentation
34
35 * and/or other materials provided with the distribution.
36
37 *
38
39 * 3. Neither the name of Zivid AS nor the names of its contributors may be used
40
41 * to endorse or promote products derived from this software without specific
42
43 * prior written permission.
44
45 *
46
47 * 4. This software, with or without modification, must not be used with any
48
49 * other 3D camera than from Zivid AS.
50
51 *
52
53 * 5. Any software provided in binary form under this license must not be
54
55 * reverse engineered, decompiled, modified and/or disassembled.
56
57 *
58
59 * THIS SOFTWARE IS PROVIDED BY ZIVID AS "AS IS" AND ANY EXPRESS OR IMPLIED
60
61 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
62
63 * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
64
65 * DISCLAIMED. IN NO EVENT SHALL ZIVID AS OR CONTRIBUTORS BE LIABLE FOR ANY
66
67 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
68
69 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
70
71 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
72
73 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
74
75 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
76
77 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
78
79 *
80
81 * Contact: Zivid Customer Success Team <customersuccess@zivid.com>
82
83 * Info: http://www.zivid.com
84
85 ******************************************************************************/
86
87
88
89#pragma once
90
91#include <array>
92#include <chrono>
93#include <cmath>
94#include <ctime>
95#include <iomanip>
96#include <memory>
97#include <set>
98#include <sstream>
99#include <string>
100#include <tuple>
101#include <utility>
102#include <vector>
103
104#include "Zivid/DataModel/Detail/Detail.h"
105#include "Zivid/DataModel/NodeType.h"
106#include "Zivid/DataModel/Traits.h"
107#include "Zivid/Detail/CoreExport.h"
108#include "Zivid/Detail/TypeTraits.h"
109#include "Zivid/Range.h"
110
111#ifdef _MSC_VER
112# pragma warning(push)
113# pragma warning(disable : 4251) // "X needs to have dll-interface to be used by clients of class Y."
114#endif
115
116namespace Zivid
117{
119 class ZIVID_CORE_EXPORT Settings
120 {
121 public:
123 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
124
126 static constexpr const char *path{ "" };
127
129 static constexpr const char *name{ "Settings" };
130
132 static constexpr const char *description{
133 R"description(Settings used when capturing with a Zivid camera)description"
134 };
135
136 static constexpr size_t version{ 8 };
137
138#ifndef NO_DOC
139 template<size_t>
140 struct Version;
141
142 using LatestVersion = Zivid::Settings;
143
144 // Short identifier. This value is not guaranteed to be universally unique
145 // Todo(ZIVID-2808): Move this to internal DataModelExt header
146 static constexpr std::array<uint8_t, 3> binaryId{ 's', 'e', 't' };
147
148#endif
149
151 class ZIVID_CORE_EXPORT Acquisition
152 {
153 public:
155 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
156
158 static constexpr const char *path{ "Acquisition" };
159
161 static constexpr const char *name{ "Acquisition" };
162
164 static constexpr const char *description{ R"description(Settings for a single acquisition)description" };
165
169 class ZIVID_CORE_EXPORT Aperture
170 {
171 public:
173 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
174
176 static constexpr const char *path{ "Acquisition/Aperture" };
177
179 static constexpr const char *name{ "Aperture" };
180
182 static constexpr const char *description{
183 R"description(Aperture setting for the camera. Specified as an f-number (the ratio of lens focal length to
184the effective aperture diameter).
185)description"
186 };
187
189 using ValueType = double;
190
192 static constexpr Range<double> validRange()
193 {
194 return { 1.4, 32.0 };
195 }
196
198 Aperture() = default;
199
201 explicit constexpr Aperture(double value)
202 : m_opt{ verifyValue(value) }
203 {}
204
209 double value() const;
210
212 bool hasValue() const;
213
215 void reset();
216
218 std::string toString() const;
219
221 bool operator==(const Aperture &other) const
222 {
223 return m_opt == other.m_opt;
224 }
225
227 bool operator!=(const Aperture &other) const
228 {
229 return m_opt != other.m_opt;
230 }
231
233 bool operator<(const Aperture &other) const
234 {
235 return m_opt < other.m_opt;
236 }
237
239 bool operator>(const Aperture &other) const
240 {
241 return m_opt > other.m_opt;
242 }
243
245 friend std::ostream &operator<<(std::ostream &stream, const Aperture &value)
246 {
247 return stream << value.toString();
248 }
249
250 private:
251 void setFromString(const std::string &value);
252
253 constexpr ValueType static verifyValue(const ValueType &value)
254 {
255 return validRange().isInRange(value)
256 ? value
257 : throw std::out_of_range{ "Aperture{ " + std::to_string(value) + " } is not in range ["
258 + std::to_string(validRange().min()) + ", "
259 + std::to_string(validRange().max()) + "]" };
260 }
261
262 Zivid::DataModel::Detail::Optional<double> m_opt;
263
264 friend struct DataModel::Detail::Befriend<Aperture>;
265 };
266
280 class ZIVID_CORE_EXPORT Brightness
281 {
282 public:
284 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
285
287 static constexpr const char *path{ "Acquisition/Brightness" };
288
290 static constexpr const char *name{ "Brightness" };
291
293 static constexpr const char *description{
294 R"description(Brightness controls the light output from the projector.
295
296Brightness above 1.0 may be needed when the distance between the camera and the scene is large,
297or in case of high levels of ambient lighting. Brightness above 1.0 is supported on Zivid One
298Plus and Zivid Two.
299
300When brightness is above 1.0 the duty cycle of the camera (the percentage of time the camera
301can capture) will be reduced. For Zivid One Plus the duty cycle in boost mode is 50%. For Zivid
302Two the duty cycle is reduced linearly from 100% at brightness 1.0, to 50% at brightness 1.8.
303The duty cycle is calculated over a 10 second period. This limitation is enforced automatically
304by the camera. Calling capture when the duty cycle limit has been reached will cause the camera
305to first wait (sleep) for a duration of time to cool down, before capture will start.
306)description"
307 };
308
310 using ValueType = double;
311
313 static constexpr Range<double> validRange()
314 {
315 return { 0, 1.8 };
316 }
317
319 Brightness() = default;
320
322 explicit constexpr Brightness(double value)
323 : m_opt{ verifyValue(value) }
324 {}
325
330 double value() const;
331
333 bool hasValue() const;
334
336 void reset();
337
339 std::string toString() const;
340
342 bool operator==(const Brightness &other) const
343 {
344 return m_opt == other.m_opt;
345 }
346
348 bool operator!=(const Brightness &other) const
349 {
350 return m_opt != other.m_opt;
351 }
352
354 bool operator<(const Brightness &other) const
355 {
356 return m_opt < other.m_opt;
357 }
358
360 bool operator>(const Brightness &other) const
361 {
362 return m_opt > other.m_opt;
363 }
364
366 friend std::ostream &operator<<(std::ostream &stream, const Brightness &value)
367 {
368 return stream << value.toString();
369 }
370
371 private:
372 void setFromString(const std::string &value);
373
374 constexpr ValueType static verifyValue(const ValueType &value)
375 {
376 return validRange().isInRange(value)
377 ? value
378 : throw std::out_of_range{ "Brightness{ " + std::to_string(value)
379 + " } is not in range [" + std::to_string(validRange().min())
380 + ", " + std::to_string(validRange().max()) + "]" };
381 }
382
383 Zivid::DataModel::Detail::Optional<double> m_opt;
384
385 friend struct DataModel::Detail::Befriend<Brightness>;
386 };
387
389 class ZIVID_CORE_EXPORT ExposureTime
390 {
391 public:
393 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
394
396 static constexpr const char *path{ "Acquisition/ExposureTime" };
397
399 static constexpr const char *name{ "ExposureTime" };
400
402 static constexpr const char *description{
403 R"description(Exposure time for each single image in the measurement. Affects frame rate.)description"
404 };
405
407 using ValueType = std::chrono::microseconds;
408
410 static constexpr Range<std::chrono::microseconds> validRange()
411 {
412 return { std::chrono::microseconds{ 1677 }, std::chrono::microseconds{ 100000 } };
413 }
414
416 ExposureTime() = default;
417
419 explicit constexpr ExposureTime(std::chrono::microseconds value)
420 : m_opt{ verifyValue(value) }
421 {}
422
427 std::chrono::microseconds value() const;
428
430 bool hasValue() const;
431
433 void reset();
434
436 std::string toString() const;
437
439 bool operator==(const ExposureTime &other) const
440 {
441 return m_opt == other.m_opt;
442 }
443
445 bool operator!=(const ExposureTime &other) const
446 {
447 return m_opt != other.m_opt;
448 }
449
451 bool operator<(const ExposureTime &other) const
452 {
453 return m_opt < other.m_opt;
454 }
455
457 bool operator>(const ExposureTime &other) const
458 {
459 return m_opt > other.m_opt;
460 }
461
463 friend std::ostream &operator<<(std::ostream &stream, const ExposureTime &value)
464 {
465 return stream << value.toString();
466 }
467
468 private:
469 void setFromString(const std::string &value);
470
471 constexpr ValueType static verifyValue(const ValueType &value)
472 {
473 return validRange().isInRange(value)
474 ? value
475 : throw std::out_of_range{ "ExposureTime{ " + std::to_string(value.count())
476 + " } is not in range ["
477 + std::to_string(validRange().min().count()) + ", "
478 + std::to_string(validRange().max().count()) + "]" };
479 }
480
481 Zivid::DataModel::Detail::Optional<std::chrono::microseconds> m_opt;
482
483 friend struct DataModel::Detail::Befriend<ExposureTime>;
484 };
485
487 class ZIVID_CORE_EXPORT Gain
488 {
489 public:
491 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
492
494 static constexpr const char *path{ "Acquisition/Gain" };
495
497 static constexpr const char *name{ "Gain" };
498
500 static constexpr const char *description{ R"description(Analog gain in the camera)description" };
501
503 using ValueType = double;
504
506 static constexpr Range<double> validRange()
507 {
508 return { 1, 16 };
509 }
510
512 Gain() = default;
513
515 explicit constexpr Gain(double value)
516 : m_opt{ verifyValue(value) }
517 {}
518
523 double value() const;
524
526 bool hasValue() const;
527
529 void reset();
530
532 std::string toString() const;
533
535 bool operator==(const Gain &other) const
536 {
537 return m_opt == other.m_opt;
538 }
539
541 bool operator!=(const Gain &other) const
542 {
543 return m_opt != other.m_opt;
544 }
545
547 bool operator<(const Gain &other) const
548 {
549 return m_opt < other.m_opt;
550 }
551
553 bool operator>(const Gain &other) const
554 {
555 return m_opt > other.m_opt;
556 }
557
559 friend std::ostream &operator<<(std::ostream &stream, const Gain &value)
560 {
561 return stream << value.toString();
562 }
563
564 private:
565 void setFromString(const std::string &value);
566
567 constexpr ValueType static verifyValue(const ValueType &value)
568 {
569 return validRange().isInRange(value)
570 ? value
571 : throw std::out_of_range{ "Gain{ " + std::to_string(value) + " } is not in range ["
572 + std::to_string(validRange().min()) + ", "
573 + std::to_string(validRange().max()) + "]" };
574 }
575
576 Zivid::DataModel::Detail::Optional<double> m_opt;
577
578 friend struct DataModel::Detail::Befriend<Gain>;
579 };
580
581 using Descendants = std::tuple<Settings::Acquisition::Aperture,
582 Settings::Acquisition::Brightness,
583 Settings::Acquisition::ExposureTime,
584 Settings::Acquisition::Gain>;
585
587 Acquisition();
588
603#ifndef NO_DOC
604 template<typename... Args,
605 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
606 typename std::enable_if<
607 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants,
608 typename std::decay<Args>::type...>::value,
609 int>::type = 0>
610#else
611 template<typename... Args>
612#endif
613 explicit Acquisition(Args &&...args)
614 {
615 using namespace Zivid::Detail::TypeTraits;
616
617 static_assert(AllArgsDecayedAreUnique<Args...>::value,
618 "Found duplicate types among the arguments passed to Acquisition(...). "
619 "Types should be listed at most once.");
620
621 set(std::forward<Args>(args)...);
622 }
623
637#ifndef NO_DOC
638 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
639#else
640 template<typename... Args>
641#endif
642 void set(Args &&...args)
643 {
644 using namespace Zivid::Detail::TypeTraits;
645
646 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
647 static_assert(AllArgsAreDescendantNodes::value,
648 "All arguments passed to set(...) must be descendant nodes.");
649
650 static_assert(AllArgsDecayedAreUnique<Args...>::value,
651 "Found duplicate types among the arguments passed to set(...). "
652 "Types should be listed at most once.");
653
654 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
655 }
656
671#ifndef NO_DOC
672 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
673#else
674 template<typename... Args>
675#endif
676 Acquisition copyWith(Args &&...args) const
677 {
678 using namespace Zivid::Detail::TypeTraits;
679
680 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
681 static_assert(AllArgsAreDescendantNodes::value,
682 "All arguments passed to copyWith(...) must be descendant nodes.");
683
684 static_assert(AllArgsDecayedAreUnique<Args...>::value,
685 "Found duplicate types among the arguments passed to copyWith(...). "
686 "Types should be listed at most once.");
687
688 auto copy{ *this };
689 copy.set(std::forward<Args>(args)...);
690 return copy;
691 }
692
694 const Aperture &aperture() const
695 {
696 return m_aperture;
697 }
698
700 Aperture &aperture()
701 {
702 return m_aperture;
703 }
704
706 Acquisition &set(const Aperture &value)
707 {
708 m_aperture = value;
709 return *this;
710 }
711
713 const Brightness &brightness() const
714 {
715 return m_brightness;
716 }
717
719 Brightness &brightness()
720 {
721 return m_brightness;
722 }
723
725 Acquisition &set(const Brightness &value)
726 {
727 m_brightness = value;
728 return *this;
729 }
730
732 const ExposureTime &exposureTime() const
733 {
734 return m_exposureTime;
735 }
736
738 ExposureTime &exposureTime()
739 {
740 return m_exposureTime;
741 }
742
744 Acquisition &set(const ExposureTime &value)
745 {
746 m_exposureTime = value;
747 return *this;
748 }
749
751 const Gain &gain() const
752 {
753 return m_gain;
754 }
755
757 Gain &gain()
758 {
759 return m_gain;
760 }
761
763 Acquisition &set(const Gain &value)
764 {
765 m_gain = value;
766 return *this;
767 }
768
769 template<typename T,
770 typename std::enable_if<std::is_same<T, Settings::Acquisition::Aperture>::value, int>::type = 0>
771 const Settings::Acquisition::Aperture &get() const
772 {
773 return m_aperture;
774 }
775
776 template<typename T,
777 typename std::enable_if<std::is_same<T, Settings::Acquisition::Brightness>::value, int>::type = 0>
778 const Settings::Acquisition::Brightness &get() const
779 {
780 return m_brightness;
781 }
782
783 template<
784 typename T,
785 typename std::enable_if<std::is_same<T, Settings::Acquisition::ExposureTime>::value, int>::type = 0>
786 const Settings::Acquisition::ExposureTime &get() const
787 {
788 return m_exposureTime;
789 }
790
791 template<typename T,
792 typename std::enable_if<std::is_same<T, Settings::Acquisition::Gain>::value, int>::type = 0>
793 const Settings::Acquisition::Gain &get() const
794 {
795 return m_gain;
796 }
797
798 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
799 const Settings::Acquisition::Aperture &get() const
800 {
801 return m_aperture;
802 }
803
804 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
805 const Settings::Acquisition::Brightness &get() const
806 {
807 return m_brightness;
808 }
809
810 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
811 const Settings::Acquisition::ExposureTime &get() const
812 {
813 return m_exposureTime;
814 }
815
816 template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
817 const Settings::Acquisition::Gain &get() const
818 {
819 return m_gain;
820 }
821
823 template<typename F>
824 void forEach(const F &f) const
825 {
826 f(m_aperture);
827 f(m_brightness);
828 f(m_exposureTime);
829 f(m_gain);
830 }
831
833 template<typename F>
834 void forEach(const F &f)
835 {
836 f(m_aperture);
837 f(m_brightness);
838 f(m_exposureTime);
839 f(m_gain);
840 }
841
843 bool operator==(const Acquisition &other) const;
844
846 bool operator!=(const Acquisition &other) const;
847
849 std::string toString() const;
850
852 friend std::ostream &operator<<(std::ostream &stream, const Acquisition &value)
853 {
854 return stream << value.toString();
855 }
856
857 private:
858 void setFromString(const std::string &value);
859
860 void setFromString(const std::string &fullPath, const std::string &value);
861
862 std::string getString(const std::string &fullPath) const;
863
864 Aperture m_aperture;
865 Brightness m_brightness;
866 ExposureTime m_exposureTime;
867 Gain m_gain;
868
869 friend struct DataModel::Detail::Befriend<Acquisition>;
870 };
871
873 class ZIVID_CORE_EXPORT Acquisitions
874 {
875 public:
877 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafDataModelList;
878
880 static constexpr const char *path{ "Acquisitions" };
881
883 static constexpr const char *name{ "Acquisitions" };
884
886 static constexpr const char *description{ R"description(List of Acquisition objects)description" };
887
889 using ValueType = std::vector<Settings::Acquisition>;
890
892 static constexpr Range<ValueType::size_type> validSize()
893 {
894 return { 0, std::numeric_limits<ValueType::size_type>::max() };
895 }
896
898 Acquisitions() = default;
899
901 explicit Acquisitions(std::vector<Settings::Acquisition> value)
902 : m_value{ std::move(value) }
903 {}
904
906 explicit Acquisitions(std::initializer_list<Settings::Acquisition> value)
907 : Acquisitions{ ValueType{ value } }
908 {}
909
911 const std::vector<Settings::Acquisition> &value() const;
912
914 std::string toString() const;
915
917 std::size_t size() const noexcept;
918
920 bool isEmpty() const noexcept;
921
927 template<typename... Args>
928 void emplaceBack(Args &&...args)
929 {
930 m_value.emplace_back(std::forward<Args>(args)...);
931 }
932
938 Settings::Acquisition &at(std::size_t pos);
939
945 const Settings::Acquisition &at(std::size_t pos) const;
946
952 Settings::Acquisition &operator[](std::size_t pos);
953
959 const Settings::Acquisition &operator[](std::size_t pos) const;
960
962 template<typename F>
963 void forEach(const F &f)
964 {
965 for(auto &child : m_value)
966 {
967 f(child);
968 }
969 }
970
972 template<typename F>
973 void forEach(const F &f) const
974 {
975 for(const auto &child : m_value)
976 {
977 f(child);
978 }
979 }
980
982 bool operator==(const Acquisitions &other) const
983 {
984 return m_value == other.m_value;
985 }
986
988 bool operator!=(const Acquisitions &other) const
989 {
990 return m_value != other.m_value;
991 }
992
994 friend std::ostream &operator<<(std::ostream &stream, const Acquisitions &value)
995 {
996 return stream << value.toString();
997 }
998
999 private:
1000 void setFromString(const std::string &value);
1001
1002 std::vector<Settings::Acquisition> m_value{};
1003
1004 friend struct DataModel::Detail::Befriend<Acquisitions>;
1005 };
1006
1008 class ZIVID_CORE_EXPORT Experimental
1009 {
1010 public:
1012 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
1013
1015 static constexpr const char *path{ "Experimental" };
1016
1018 static constexpr const char *name{ "Experimental" };
1019
1021 static constexpr const char *description{
1022 R"description(Experimental features. These settings may be changed, renamed, moved or deleted in the future.)description"
1023 };
1024
1034 class ZIVID_CORE_EXPORT Engine
1035 {
1036 public:
1038 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
1039
1041 static constexpr const char *path{ "Experimental/Engine" };
1042
1044 static constexpr const char *name{ "Engine" };
1045
1047 static constexpr const char *description{ R"description(Set the Zivid Vision Engine to use.
1048
1049The Phase Engine is the current default Zivid Vision Engine.
1050
1051The Stripe Engine uses anti-reflection technology to suppress interreflection artifacts
1052and improve data quality on shiny objects like cylinders and chrome-plated parts.
1053Additional acquisition and processing time are required for the Stripe Engine.
1054The Stripe Engine is currently experimental, and may be changed and improved in the future.
1055)description" };
1056
1058 enum class ValueType
1059 {
1060 phase,
1061 stripe
1062 };
1063 static const Engine phase;
1064 static const Engine stripe;
1065
1067 static std::set<ValueType> validValues()
1068 {
1069 return { ValueType::phase, ValueType::stripe };
1070 }
1071
1073 Engine() = default;
1074
1076 explicit constexpr Engine(ValueType value)
1077 : m_opt{ verifyValue(value) }
1078 {}
1079
1084 ValueType value() const;
1085
1087 bool hasValue() const;
1088
1090 void reset();
1091
1093 std::string toString() const;
1094
1096 friend std::ostream &operator<<(std::ostream &stream, const Engine::ValueType &value)
1097 {
1098 return stream << Engine{ value }.toString();
1099 }
1100
1102 bool operator==(const Engine &other) const
1103 {
1104 return m_opt == other.m_opt;
1105 }
1106
1108 bool operator!=(const Engine &other) const
1109 {
1110 return m_opt != other.m_opt;
1111 }
1112
1114 friend std::ostream &operator<<(std::ostream &stream, const Engine &value)
1115 {
1116 return stream << value.toString();
1117 }
1118
1119 private:
1120 void setFromString(const std::string &value);
1121
1122 constexpr ValueType static verifyValue(const ValueType &value)
1123 {
1124 return value == ValueType::phase || value == ValueType::stripe
1125 ? value
1126 : throw std::invalid_argument{
1127 "Invalid value: Engine{ "
1128 + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
1129 };
1130 }
1131
1132 Zivid::DataModel::Detail::Optional<ValueType> m_opt;
1133
1134 friend struct DataModel::Detail::Befriend<Engine>;
1135 };
1136
1137 using Descendants = std::tuple<Settings::Experimental::Engine>;
1138
1140 Experimental();
1141
1153#ifndef NO_DOC
1154 template<typename... Args,
1155 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
1156 typename std::enable_if<
1157 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants,
1158 typename std::decay<Args>::type...>::value,
1159 int>::type = 0>
1160#else
1161 template<typename... Args>
1162#endif
1163 explicit Experimental(Args &&...args)
1164 {
1165 using namespace Zivid::Detail::TypeTraits;
1166
1167 static_assert(AllArgsDecayedAreUnique<Args...>::value,
1168 "Found duplicate types among the arguments passed to Experimental(...). "
1169 "Types should be listed at most once.");
1170
1171 set(std::forward<Args>(args)...);
1172 }
1173
1184#ifndef NO_DOC
1185 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
1186#else
1187 template<typename... Args>
1188#endif
1189 void set(Args &&...args)
1190 {
1191 using namespace Zivid::Detail::TypeTraits;
1192
1193 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
1194 static_assert(AllArgsAreDescendantNodes::value,
1195 "All arguments passed to set(...) must be descendant nodes.");
1196
1197 static_assert(AllArgsDecayedAreUnique<Args...>::value,
1198 "Found duplicate types among the arguments passed to set(...). "
1199 "Types should be listed at most once.");
1200
1201 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
1202 }
1203
1215#ifndef NO_DOC
1216 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
1217#else
1218 template<typename... Args>
1219#endif
1220 Experimental copyWith(Args &&...args) const
1221 {
1222 using namespace Zivid::Detail::TypeTraits;
1223
1224 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
1225 static_assert(AllArgsAreDescendantNodes::value,
1226 "All arguments passed to copyWith(...) must be descendant nodes.");
1227
1228 static_assert(AllArgsDecayedAreUnique<Args...>::value,
1229 "Found duplicate types among the arguments passed to copyWith(...). "
1230 "Types should be listed at most once.");
1231
1232 auto copy{ *this };
1233 copy.set(std::forward<Args>(args)...);
1234 return copy;
1235 }
1236
1238 const Engine &engine() const
1239 {
1240 return m_engine;
1241 }
1242
1244 Engine &engine()
1245 {
1246 return m_engine;
1247 }
1248
1250 Experimental &set(const Engine &value)
1251 {
1252 m_engine = value;
1253 return *this;
1254 }
1255
1256 template<typename T,
1257 typename std::enable_if<std::is_same<T, Settings::Experimental::Engine>::value, int>::type = 0>
1258 const Settings::Experimental::Engine &get() const
1259 {
1260 return m_engine;
1261 }
1262
1263 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
1264 const Settings::Experimental::Engine &get() const
1265 {
1266 return m_engine;
1267 }
1268
1270 template<typename F>
1271 void forEach(const F &f) const
1272 {
1273 f(m_engine);
1274 }
1275
1277 template<typename F>
1278 void forEach(const F &f)
1279 {
1280 f(m_engine);
1281 }
1282
1284 bool operator==(const Experimental &other) const;
1285
1287 bool operator!=(const Experimental &other) const;
1288
1290 std::string toString() const;
1291
1293 friend std::ostream &operator<<(std::ostream &stream, const Experimental &value)
1294 {
1295 return stream << value.toString();
1296 }
1297
1298 private:
1299 void setFromString(const std::string &value);
1300
1301 void setFromString(const std::string &fullPath, const std::string &value);
1302
1303 std::string getString(const std::string &fullPath) const;
1304
1305 Engine m_engine;
1306
1307 friend struct DataModel::Detail::Befriend<Experimental>;
1308 };
1309
1311 class ZIVID_CORE_EXPORT Processing
1312 {
1313 public:
1315 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
1316
1318 static constexpr const char *path{ "Processing" };
1319
1321 static constexpr const char *name{ "Processing" };
1322
1324 static constexpr const char *description{
1325 R"description(Settings related to processing of a capture, including filters and color balance)description"
1326 };
1327
1329 class ZIVID_CORE_EXPORT Color
1330 {
1331 public:
1333 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
1334
1336 static constexpr const char *path{ "Processing/Color" };
1337
1339 static constexpr const char *name{ "Color" };
1340
1342 static constexpr const char *description{ R"description(Color settings)description" };
1343
1345 class ZIVID_CORE_EXPORT Balance
1346 {
1347 public:
1349 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
1350
1352 static constexpr const char *path{ "Processing/Color/Balance" };
1353
1355 static constexpr const char *name{ "Balance" };
1356
1358 static constexpr const char *description{ R"description(Color balance settings)description" };
1359
1361 class ZIVID_CORE_EXPORT Blue
1362 {
1363 public:
1365 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
1366
1368 static constexpr const char *path{ "Processing/Color/Balance/Blue" };
1369
1371 static constexpr const char *name{ "Blue" };
1372
1374 static constexpr const char *description{
1375 R"description(Digital gain applied to blue channel)description"
1376 };
1377
1379 using ValueType = double;
1380
1382 static constexpr Range<double> validRange()
1383 {
1384 return { 1.0, 8.0 };
1385 }
1386
1388 Blue() = default;
1389
1391 explicit constexpr Blue(double value)
1392 : m_opt{ verifyValue(value) }
1393 {}
1394
1399 double value() const;
1400
1402 bool hasValue() const;
1403
1405 void reset();
1406
1408 std::string toString() const;
1409
1411 bool operator==(const Blue &other) const
1412 {
1413 return m_opt == other.m_opt;
1414 }
1415
1417 bool operator!=(const Blue &other) const
1418 {
1419 return m_opt != other.m_opt;
1420 }
1421
1423 bool operator<(const Blue &other) const
1424 {
1425 return m_opt < other.m_opt;
1426 }
1427
1429 bool operator>(const Blue &other) const
1430 {
1431 return m_opt > other.m_opt;
1432 }
1433
1435 friend std::ostream &operator<<(std::ostream &stream, const Blue &value)
1436 {
1437 return stream << value.toString();
1438 }
1439
1440 private:
1441 void setFromString(const std::string &value);
1442
1443 constexpr ValueType static verifyValue(const ValueType &value)
1444 {
1445 return validRange().isInRange(value)
1446 ? value
1447 : throw std::out_of_range{ "Blue{ " + std::to_string(value)
1448 + " } is not in range ["
1449 + std::to_string(validRange().min()) + ", "
1450 + std::to_string(validRange().max()) + "]" };
1451 }
1452
1453 Zivid::DataModel::Detail::Optional<double> m_opt;
1454
1455 friend struct DataModel::Detail::Befriend<Blue>;
1456 };
1457
1459 class ZIVID_CORE_EXPORT Green
1460 {
1461 public:
1463 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
1464
1466 static constexpr const char *path{ "Processing/Color/Balance/Green" };
1467
1469 static constexpr const char *name{ "Green" };
1470
1472 static constexpr const char *description{
1473 R"description(Digital gain applied to green channel)description"
1474 };
1475
1477 using ValueType = double;
1478
1480 static constexpr Range<double> validRange()
1481 {
1482 return { 1.0, 8.0 };
1483 }
1484
1486 Green() = default;
1487
1489 explicit constexpr Green(double value)
1490 : m_opt{ verifyValue(value) }
1491 {}
1492
1497 double value() const;
1498
1500 bool hasValue() const;
1501
1503 void reset();
1504
1506 std::string toString() const;
1507
1509 bool operator==(const Green &other) const
1510 {
1511 return m_opt == other.m_opt;
1512 }
1513
1515 bool operator!=(const Green &other) const
1516 {
1517 return m_opt != other.m_opt;
1518 }
1519
1521 bool operator<(const Green &other) const
1522 {
1523 return m_opt < other.m_opt;
1524 }
1525
1527 bool operator>(const Green &other) const
1528 {
1529 return m_opt > other.m_opt;
1530 }
1531
1533 friend std::ostream &operator<<(std::ostream &stream, const Green &value)
1534 {
1535 return stream << value.toString();
1536 }
1537
1538 private:
1539 void setFromString(const std::string &value);
1540
1541 constexpr ValueType static verifyValue(const ValueType &value)
1542 {
1543 return validRange().isInRange(value)
1544 ? value
1545 : throw std::out_of_range{ "Green{ " + std::to_string(value)
1546 + " } is not in range ["
1547 + std::to_string(validRange().min()) + ", "
1548 + std::to_string(validRange().max()) + "]" };
1549 }
1550
1551 Zivid::DataModel::Detail::Optional<double> m_opt;
1552
1553 friend struct DataModel::Detail::Befriend<Green>;
1554 };
1555
1557 class ZIVID_CORE_EXPORT Red
1558 {
1559 public:
1561 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
1562
1564 static constexpr const char *path{ "Processing/Color/Balance/Red" };
1565
1567 static constexpr const char *name{ "Red" };
1568
1570 static constexpr const char *description{
1571 R"description(Digital gain applied to red channel)description"
1572 };
1573
1575 using ValueType = double;
1576
1578 static constexpr Range<double> validRange()
1579 {
1580 return { 1.0, 8.0 };
1581 }
1582
1584 Red() = default;
1585
1587 explicit constexpr Red(double value)
1588 : m_opt{ verifyValue(value) }
1589 {}
1590
1595 double value() const;
1596
1598 bool hasValue() const;
1599
1601 void reset();
1602
1604 std::string toString() const;
1605
1607 bool operator==(const Red &other) const
1608 {
1609 return m_opt == other.m_opt;
1610 }
1611
1613 bool operator!=(const Red &other) const
1614 {
1615 return m_opt != other.m_opt;
1616 }
1617
1619 bool operator<(const Red &other) const
1620 {
1621 return m_opt < other.m_opt;
1622 }
1623
1625 bool operator>(const Red &other) const
1626 {
1627 return m_opt > other.m_opt;
1628 }
1629
1631 friend std::ostream &operator<<(std::ostream &stream, const Red &value)
1632 {
1633 return stream << value.toString();
1634 }
1635
1636 private:
1637 void setFromString(const std::string &value);
1638
1639 constexpr ValueType static verifyValue(const ValueType &value)
1640 {
1641 return validRange().isInRange(value)
1642 ? value
1643 : throw std::out_of_range{ "Red{ " + std::to_string(value)
1644 + " } is not in range ["
1645 + std::to_string(validRange().min()) + ", "
1646 + std::to_string(validRange().max()) + "]" };
1647 }
1648
1649 Zivid::DataModel::Detail::Optional<double> m_opt;
1650
1651 friend struct DataModel::Detail::Befriend<Red>;
1652 };
1653
1654 using Descendants = std::tuple<Settings::Processing::Color::Balance::Blue,
1655 Settings::Processing::Color::Balance::Green,
1656 Settings::Processing::Color::Balance::Red>;
1657
1659 Balance();
1660
1674#ifndef NO_DOC
1675 template<typename... Args,
1676 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
1677 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
1678 Descendants,
1679 typename std::decay<Args>::type...>::value,
1680 int>::type = 0>
1681#else
1682 template<typename... Args>
1683#endif
1684 explicit Balance(Args &&...args)
1685 {
1686 using namespace Zivid::Detail::TypeTraits;
1687
1688 static_assert(AllArgsDecayedAreUnique<Args...>::value,
1689 "Found duplicate types among the arguments passed to Balance(...). "
1690 "Types should be listed at most once.");
1691
1692 set(std::forward<Args>(args)...);
1693 }
1694
1707#ifndef NO_DOC
1708 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
1709#else
1710 template<typename... Args>
1711#endif
1712 void set(Args &&...args)
1713 {
1714 using namespace Zivid::Detail::TypeTraits;
1715
1716 using AllArgsAreDescendantNodes =
1717 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
1718 static_assert(AllArgsAreDescendantNodes::value,
1719 "All arguments passed to set(...) must be descendant nodes.");
1720
1721 static_assert(AllArgsDecayedAreUnique<Args...>::value,
1722 "Found duplicate types among the arguments passed to set(...). "
1723 "Types should be listed at most once.");
1724
1725 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
1726 }
1727
1741#ifndef NO_DOC
1742 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
1743#else
1744 template<typename... Args>
1745#endif
1746 Balance copyWith(Args &&...args) const
1747 {
1748 using namespace Zivid::Detail::TypeTraits;
1749
1750 using AllArgsAreDescendantNodes =
1751 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
1752 static_assert(AllArgsAreDescendantNodes::value,
1753 "All arguments passed to copyWith(...) must be descendant nodes.");
1754
1755 static_assert(AllArgsDecayedAreUnique<Args...>::value,
1756 "Found duplicate types among the arguments passed to copyWith(...). "
1757 "Types should be listed at most once.");
1758
1759 auto copy{ *this };
1760 copy.set(std::forward<Args>(args)...);
1761 return copy;
1762 }
1763
1765 const Blue &blue() const
1766 {
1767 return m_blue;
1768 }
1769
1771 Blue &blue()
1772 {
1773 return m_blue;
1774 }
1775
1777 Balance &set(const Blue &value)
1778 {
1779 m_blue = value;
1780 return *this;
1781 }
1782
1784 const Green &green() const
1785 {
1786 return m_green;
1787 }
1788
1790 Green &green()
1791 {
1792 return m_green;
1793 }
1794
1796 Balance &set(const Green &value)
1797 {
1798 m_green = value;
1799 return *this;
1800 }
1801
1803 const Red &red() const
1804 {
1805 return m_red;
1806 }
1807
1809 Red &red()
1810 {
1811 return m_red;
1812 }
1813
1815 Balance &set(const Red &value)
1816 {
1817 m_red = value;
1818 return *this;
1819 }
1820
1821 template<typename T,
1822 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Blue>::value,
1823 int>::type = 0>
1824 const Settings::Processing::Color::Balance::Blue &get() const
1825 {
1826 return m_blue;
1827 }
1828
1829 template<
1830 typename T,
1831 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Green>::value,
1832 int>::type = 0>
1833 const Settings::Processing::Color::Balance::Green &get() const
1834 {
1835 return m_green;
1836 }
1837
1838 template<typename T,
1839 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Red>::value,
1840 int>::type = 0>
1841 const Settings::Processing::Color::Balance::Red &get() const
1842 {
1843 return m_red;
1844 }
1845
1846 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
1847 const Settings::Processing::Color::Balance::Blue &get() const
1848 {
1849 return m_blue;
1850 }
1851
1852 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
1853 const Settings::Processing::Color::Balance::Green &get() const
1854 {
1855 return m_green;
1856 }
1857
1858 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
1859 const Settings::Processing::Color::Balance::Red &get() const
1860 {
1861 return m_red;
1862 }
1863
1865 template<typename F>
1866 void forEach(const F &f) const
1867 {
1868 f(m_blue);
1869 f(m_green);
1870 f(m_red);
1871 }
1872
1874 template<typename F>
1875 void forEach(const F &f)
1876 {
1877 f(m_blue);
1878 f(m_green);
1879 f(m_red);
1880 }
1881
1883 bool operator==(const Balance &other) const;
1884
1886 bool operator!=(const Balance &other) const;
1887
1889 std::string toString() const;
1890
1892 friend std::ostream &operator<<(std::ostream &stream, const Balance &value)
1893 {
1894 return stream << value.toString();
1895 }
1896
1897 private:
1898 void setFromString(const std::string &value);
1899
1900 void setFromString(const std::string &fullPath, const std::string &value);
1901
1902 std::string getString(const std::string &fullPath) const;
1903
1904 Blue m_blue;
1905 Green m_green;
1906 Red m_red;
1907
1908 friend struct DataModel::Detail::Befriend<Balance>;
1909 };
1910
1912 class ZIVID_CORE_EXPORT Experimental
1913 {
1914 public:
1916 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
1917
1919 static constexpr const char *path{ "Processing/Color/Experimental" };
1920
1922 static constexpr const char *name{ "Experimental" };
1923
1925 static constexpr const char *description{
1926 R"description(Experimental color settings. These may be renamed, moved or deleted in the future.)description"
1927 };
1928
1930 class ZIVID_CORE_EXPORT ToneMapping
1931 {
1932 public:
1934 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
1935
1937 static constexpr const char *path{ "Processing/Color/Experimental/ToneMapping" };
1938
1940 static constexpr const char *name{ "ToneMapping" };
1941
1943 static constexpr const char *description{ R"description(Tonemapping settings.)description" };
1944
1954 class ZIVID_CORE_EXPORT Enabled
1955 {
1956 public:
1958 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
1959
1961 static constexpr const char *path{ "Processing/Color/Experimental/ToneMapping/Enabled" };
1962
1964 static constexpr const char *name{ "Enabled" };
1965
1967 static constexpr const char *description{
1968 R"description(This setting controls when tone mapping of colors is performed. Tone mapping will normalize
1969the captured color image to the full available output range by applying a gain factor to the
1970colors. For single-captures this can be used to brighten dark images. For HDR captures this
1971is required to map high-dynamic-range colors to the more limited dynamic range output.
1972
1973This setting has two possible values. `Always` will perform tone-mapping for all captures.
1974`HdrOnly` will perform tone mapping for HDR captures but not for single-captures. It is not
1975possible to disable tone mapping for HDR captures.
1976)description"
1977 };
1978
1980 enum class ValueType
1981 {
1982 always,
1983 hdrOnly
1984 };
1985 static const Enabled always;
1986 static const Enabled hdrOnly;
1987
1989 static std::set<ValueType> validValues()
1990 {
1991 return { ValueType::always, ValueType::hdrOnly };
1992 }
1993
1995 Enabled() = default;
1996
1998 explicit constexpr Enabled(ValueType value)
1999 : m_opt{ verifyValue(value) }
2000 {}
2001
2006 ValueType value() const;
2007
2009 bool hasValue() const;
2010
2012 void reset();
2013
2015 std::string toString() const;
2016
2018 friend std::ostream &operator<<(std::ostream &stream, const Enabled::ValueType &value)
2019 {
2020 return stream << Enabled{ value }.toString();
2021 }
2022
2024 bool operator==(const Enabled &other) const
2025 {
2026 return m_opt == other.m_opt;
2027 }
2028
2030 bool operator!=(const Enabled &other) const
2031 {
2032 return m_opt != other.m_opt;
2033 }
2034
2036 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
2037 {
2038 return stream << value.toString();
2039 }
2040
2041 private:
2042 void setFromString(const std::string &value);
2043
2044 constexpr ValueType static verifyValue(const ValueType &value)
2045 {
2046 return value == ValueType::always || value == ValueType::hdrOnly
2047 ? value
2048 : throw std::invalid_argument{
2049 "Invalid value: Enabled{ "
2050 + std::to_string(
2051 static_cast<std::underlying_type<ValueType>::type>(value))
2052 + " }"
2053 };
2054 }
2055
2056 Zivid::DataModel::Detail::Optional<ValueType> m_opt;
2057
2058 friend struct DataModel::Detail::Befriend<Enabled>;
2059 };
2060
2061 using Descendants = std::tuple<Settings::Processing::Color::Experimental::ToneMapping::Enabled>;
2062
2064 ToneMapping();
2065
2077#ifndef NO_DOC
2078 template<typename... Args,
2079 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
2080 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
2081 Descendants,
2082 typename std::decay<Args>::type...>::value,
2083 int>::type = 0>
2084#else
2085 template<typename... Args>
2086#endif
2087 explicit ToneMapping(Args &&...args)
2088 {
2089 using namespace Zivid::Detail::TypeTraits;
2090
2091 static_assert(AllArgsDecayedAreUnique<Args...>::value,
2092 "Found duplicate types among the arguments passed to ToneMapping(...). "
2093 "Types should be listed at most once.");
2094
2095 set(std::forward<Args>(args)...);
2096 }
2097
2108#ifndef NO_DOC
2109 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
2110#else
2111 template<typename... Args>
2112#endif
2113 void set(Args &&...args)
2114 {
2115 using namespace Zivid::Detail::TypeTraits;
2116
2117 using AllArgsAreDescendantNodes =
2118 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
2119 static_assert(AllArgsAreDescendantNodes::value,
2120 "All arguments passed to set(...) must be descendant nodes.");
2121
2122 static_assert(AllArgsDecayedAreUnique<Args...>::value,
2123 "Found duplicate types among the arguments passed to set(...). "
2124 "Types should be listed at most once.");
2125
2126 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
2127 }
2128
2140#ifndef NO_DOC
2141 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
2142#else
2143 template<typename... Args>
2144#endif
2145 ToneMapping copyWith(Args &&...args) const
2146 {
2147 using namespace Zivid::Detail::TypeTraits;
2148
2149 using AllArgsAreDescendantNodes =
2150 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
2151 static_assert(AllArgsAreDescendantNodes::value,
2152 "All arguments passed to copyWith(...) must be descendant nodes.");
2153
2154 static_assert(AllArgsDecayedAreUnique<Args...>::value,
2155 "Found duplicate types among the arguments passed to copyWith(...). "
2156 "Types should be listed at most once.");
2157
2158 auto copy{ *this };
2159 copy.set(std::forward<Args>(args)...);
2160 return copy;
2161 }
2162
2164 const Enabled &isEnabled() const
2165 {
2166 return m_enabled;
2167 }
2168
2170 Enabled &isEnabled()
2171 {
2172 return m_enabled;
2173 }
2174
2176 ToneMapping &set(const Enabled &value)
2177 {
2178 m_enabled = value;
2179 return *this;
2180 }
2181
2182 template<
2183 typename T,
2184 typename std::enable_if<
2185 std::is_same<T, Settings::Processing::Color::Experimental::ToneMapping::Enabled>::value,
2186 int>::type = 0>
2187 const Settings::Processing::Color::Experimental::ToneMapping::Enabled &get() const
2188 {
2189 return m_enabled;
2190 }
2191
2192 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
2193 const Settings::Processing::Color::Experimental::ToneMapping::Enabled &get() const
2194 {
2195 return m_enabled;
2196 }
2197
2199 template<typename F>
2200 void forEach(const F &f) const
2201 {
2202 f(m_enabled);
2203 }
2204
2206 template<typename F>
2207 void forEach(const F &f)
2208 {
2209 f(m_enabled);
2210 }
2211
2213 bool operator==(const ToneMapping &other) const;
2214
2216 bool operator!=(const ToneMapping &other) const;
2217
2219 std::string toString() const;
2220
2222 friend std::ostream &operator<<(std::ostream &stream, const ToneMapping &value)
2223 {
2224 return stream << value.toString();
2225 }
2226
2227 private:
2228 void setFromString(const std::string &value);
2229
2230 void setFromString(const std::string &fullPath, const std::string &value);
2231
2232 std::string getString(const std::string &fullPath) const;
2233
2234 Enabled m_enabled;
2235
2236 friend struct DataModel::Detail::Befriend<ToneMapping>;
2237 };
2238
2239 using Descendants = std::tuple<Settings::Processing::Color::Experimental::ToneMapping,
2240 Settings::Processing::Color::Experimental::ToneMapping::Enabled>;
2241
2243 Experimental();
2244
2257#ifndef NO_DOC
2258 template<typename... Args,
2259 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
2260 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
2261 Descendants,
2262 typename std::decay<Args>::type...>::value,
2263 int>::type = 0>
2264#else
2265 template<typename... Args>
2266#endif
2267 explicit Experimental(Args &&...args)
2268 {
2269 using namespace Zivid::Detail::TypeTraits;
2270
2271 static_assert(AllArgsDecayedAreUnique<Args...>::value,
2272 "Found duplicate types among the arguments passed to Experimental(...). "
2273 "Types should be listed at most once.");
2274
2275 set(std::forward<Args>(args)...);
2276 }
2277
2289#ifndef NO_DOC
2290 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
2291#else
2292 template<typename... Args>
2293#endif
2294 void set(Args &&...args)
2295 {
2296 using namespace Zivid::Detail::TypeTraits;
2297
2298 using AllArgsAreDescendantNodes =
2299 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
2300 static_assert(AllArgsAreDescendantNodes::value,
2301 "All arguments passed to set(...) must be descendant nodes.");
2302
2303 static_assert(AllArgsDecayedAreUnique<Args...>::value,
2304 "Found duplicate types among the arguments passed to set(...). "
2305 "Types should be listed at most once.");
2306
2307 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
2308 }
2309
2322#ifndef NO_DOC
2323 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
2324#else
2325 template<typename... Args>
2326#endif
2327 Experimental copyWith(Args &&...args) const
2328 {
2329 using namespace Zivid::Detail::TypeTraits;
2330
2331 using AllArgsAreDescendantNodes =
2332 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
2333 static_assert(AllArgsAreDescendantNodes::value,
2334 "All arguments passed to copyWith(...) must be descendant nodes.");
2335
2336 static_assert(AllArgsDecayedAreUnique<Args...>::value,
2337 "Found duplicate types among the arguments passed to copyWith(...). "
2338 "Types should be listed at most once.");
2339
2340 auto copy{ *this };
2341 copy.set(std::forward<Args>(args)...);
2342 return copy;
2343 }
2344
2346 const ToneMapping &toneMapping() const
2347 {
2348 return m_toneMapping;
2349 }
2350
2352 ToneMapping &toneMapping()
2353 {
2354 return m_toneMapping;
2355 }
2356
2358 Experimental &set(const ToneMapping &value)
2359 {
2360 m_toneMapping = value;
2361 return *this;
2362 }
2363
2365 Experimental &set(const ToneMapping::Enabled &value)
2366 {
2367 m_toneMapping.set(value);
2368 return *this;
2369 }
2370
2371 template<typename T,
2372 typename std::enable_if<
2373 std::is_same<T, Settings::Processing::Color::Experimental::ToneMapping>::value,
2374 int>::type = 0>
2375 const Settings::Processing::Color::Experimental::ToneMapping &get() const
2376 {
2377 return m_toneMapping;
2378 }
2379
2380 template<
2381 typename T,
2382 typename std::enable_if<
2383 std::is_same<T, Settings::Processing::Color::Experimental::ToneMapping::Enabled>::value,
2384 int>::type = 0>
2385 const Settings::Processing::Color::Experimental::ToneMapping::Enabled &get() const
2386 {
2387 return m_toneMapping.get<Settings::Processing::Color::Experimental::ToneMapping::Enabled>();
2388 }
2389
2390 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
2391 const Settings::Processing::Color::Experimental::ToneMapping &get() const
2392 {
2393 return m_toneMapping;
2394 }
2395
2397 template<typename F>
2398 void forEach(const F &f) const
2399 {
2400 f(m_toneMapping);
2401 }
2402
2404 template<typename F>
2405 void forEach(const F &f)
2406 {
2407 f(m_toneMapping);
2408 }
2409
2411 bool operator==(const Experimental &other) const;
2412
2414 bool operator!=(const Experimental &other) const;
2415
2417 std::string toString() const;
2418
2420 friend std::ostream &operator<<(std::ostream &stream, const Experimental &value)
2421 {
2422 return stream << value.toString();
2423 }
2424
2425 private:
2426 void setFromString(const std::string &value);
2427
2428 void setFromString(const std::string &fullPath, const std::string &value);
2429
2430 std::string getString(const std::string &fullPath) const;
2431
2432 ToneMapping m_toneMapping;
2433
2434 friend struct DataModel::Detail::Befriend<Experimental>;
2435 };
2436
2440 class ZIVID_CORE_EXPORT Gamma
2441 {
2442 public:
2444 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
2445
2447 static constexpr const char *path{ "Processing/Color/Gamma" };
2448
2450 static constexpr const char *name{ "Gamma" };
2451
2453 static constexpr const char *description{
2454 R"description(Gamma applied to the color values. Gamma less than 1 makes the colors brighter, while gamma
2455greater than 1 makes the colors darker.
2456)description"
2457 };
2458
2460 using ValueType = double;
2461
2463 static constexpr Range<double> validRange()
2464 {
2465 return { 0.25, 1.5 };
2466 }
2467
2469 Gamma() = default;
2470
2472 explicit constexpr Gamma(double value)
2473 : m_opt{ verifyValue(value) }
2474 {}
2475
2480 double value() const;
2481
2483 bool hasValue() const;
2484
2486 void reset();
2487
2489 std::string toString() const;
2490
2492 bool operator==(const Gamma &other) const
2493 {
2494 return m_opt == other.m_opt;
2495 }
2496
2498 bool operator!=(const Gamma &other) const
2499 {
2500 return m_opt != other.m_opt;
2501 }
2502
2504 bool operator<(const Gamma &other) const
2505 {
2506 return m_opt < other.m_opt;
2507 }
2508
2510 bool operator>(const Gamma &other) const
2511 {
2512 return m_opt > other.m_opt;
2513 }
2514
2516 friend std::ostream &operator<<(std::ostream &stream, const Gamma &value)
2517 {
2518 return stream << value.toString();
2519 }
2520
2521 private:
2522 void setFromString(const std::string &value);
2523
2524 constexpr ValueType static verifyValue(const ValueType &value)
2525 {
2526 return validRange().isInRange(value)
2527 ? value
2528 : throw std::out_of_range{ "Gamma{ " + std::to_string(value) + " } is not in range ["
2529 + std::to_string(validRange().min()) + ", "
2530 + std::to_string(validRange().max()) + "]" };
2531 }
2532
2533 Zivid::DataModel::Detail::Optional<double> m_opt;
2534
2535 friend struct DataModel::Detail::Befriend<Gamma>;
2536 };
2537
2538 using Descendants = std::tuple<Settings::Processing::Color::Balance,
2539 Settings::Processing::Color::Balance::Blue,
2540 Settings::Processing::Color::Balance::Green,
2541 Settings::Processing::Color::Balance::Red,
2542 Settings::Processing::Color::Experimental,
2543 Settings::Processing::Color::Experimental::ToneMapping,
2544 Settings::Processing::Color::Experimental::ToneMapping::Enabled,
2545 Settings::Processing::Color::Gamma>;
2546
2548 Color();
2549
2568#ifndef NO_DOC
2569 template<typename... Args,
2570 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
2571 typename std::enable_if<
2572 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants,
2573 typename std::decay<Args>::type...>::value,
2574 int>::type = 0>
2575#else
2576 template<typename... Args>
2577#endif
2578 explicit Color(Args &&...args)
2579 {
2580 using namespace Zivid::Detail::TypeTraits;
2581
2582 static_assert(AllArgsDecayedAreUnique<Args...>::value,
2583 "Found duplicate types among the arguments passed to Color(...). "
2584 "Types should be listed at most once.");
2585
2586 set(std::forward<Args>(args)...);
2587 }
2588
2606#ifndef NO_DOC
2607 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
2608#else
2609 template<typename... Args>
2610#endif
2611 void set(Args &&...args)
2612 {
2613 using namespace Zivid::Detail::TypeTraits;
2614
2615 using AllArgsAreDescendantNodes =
2616 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
2617 static_assert(AllArgsAreDescendantNodes::value,
2618 "All arguments passed to set(...) must be descendant nodes.");
2619
2620 static_assert(AllArgsDecayedAreUnique<Args...>::value,
2621 "Found duplicate types among the arguments passed to set(...). "
2622 "Types should be listed at most once.");
2623
2624 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
2625 }
2626
2645#ifndef NO_DOC
2646 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
2647#else
2648 template<typename... Args>
2649#endif
2650 Color copyWith(Args &&...args) const
2651 {
2652 using namespace Zivid::Detail::TypeTraits;
2653
2654 using AllArgsAreDescendantNodes =
2655 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
2656 static_assert(AllArgsAreDescendantNodes::value,
2657 "All arguments passed to copyWith(...) must be descendant nodes.");
2658
2659 static_assert(AllArgsDecayedAreUnique<Args...>::value,
2660 "Found duplicate types among the arguments passed to copyWith(...). "
2661 "Types should be listed at most once.");
2662
2663 auto copy{ *this };
2664 copy.set(std::forward<Args>(args)...);
2665 return copy;
2666 }
2667
2669 const Balance &balance() const
2670 {
2671 return m_balance;
2672 }
2673
2675 Balance &balance()
2676 {
2677 return m_balance;
2678 }
2679
2681 Color &set(const Balance &value)
2682 {
2683 m_balance = value;
2684 return *this;
2685 }
2686
2688 Color &set(const Balance::Blue &value)
2689 {
2690 m_balance.set(value);
2691 return *this;
2692 }
2693
2695 Color &set(const Balance::Green &value)
2696 {
2697 m_balance.set(value);
2698 return *this;
2699 }
2700
2702 Color &set(const Balance::Red &value)
2703 {
2704 m_balance.set(value);
2705 return *this;
2706 }
2707
2709 const Experimental &experimental() const
2710 {
2711 return m_experimental;
2712 }
2713
2715 Experimental &experimental()
2716 {
2717 return m_experimental;
2718 }
2719
2721 Color &set(const Experimental &value)
2722 {
2723 m_experimental = value;
2724 return *this;
2725 }
2726
2728 Color &set(const Experimental::ToneMapping &value)
2729 {
2730 m_experimental.set(value);
2731 return *this;
2732 }
2733
2735 Color &set(const Experimental::ToneMapping::Enabled &value)
2736 {
2737 m_experimental.set(value);
2738 return *this;
2739 }
2740
2742 const Gamma &gamma() const
2743 {
2744 return m_gamma;
2745 }
2746
2748 Gamma &gamma()
2749 {
2750 return m_gamma;
2751 }
2752
2754 Color &set(const Gamma &value)
2755 {
2756 m_gamma = value;
2757 return *this;
2758 }
2759
2760 template<typename T,
2761 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance>::value,
2762 int>::type = 0>
2763 const Settings::Processing::Color::Balance &get() const
2764 {
2765 return m_balance;
2766 }
2767
2768 template<typename T,
2769 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Blue>::value,
2770 int>::type = 0>
2771 const Settings::Processing::Color::Balance::Blue &get() const
2772 {
2773 return m_balance.get<Settings::Processing::Color::Balance::Blue>();
2774 }
2775
2776 template<typename T,
2777 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Green>::value,
2778 int>::type = 0>
2779 const Settings::Processing::Color::Balance::Green &get() const
2780 {
2781 return m_balance.get<Settings::Processing::Color::Balance::Green>();
2782 }
2783
2784 template<typename T,
2785 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Red>::value,
2786 int>::type = 0>
2787 const Settings::Processing::Color::Balance::Red &get() const
2788 {
2789 return m_balance.get<Settings::Processing::Color::Balance::Red>();
2790 }
2791
2792 template<typename T,
2793 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental>::value,
2794 int>::type = 0>
2795 const Settings::Processing::Color::Experimental &get() const
2796 {
2797 return m_experimental;
2798 }
2799
2800 template<typename T,
2801 typename std::enable_if<
2802 std::is_same<T, Settings::Processing::Color::Experimental::ToneMapping>::value,
2803 int>::type = 0>
2804 const Settings::Processing::Color::Experimental::ToneMapping &get() const
2805 {
2806 return m_experimental.get<Settings::Processing::Color::Experimental::ToneMapping>();
2807 }
2808
2809 template<typename T,
2810 typename std::enable_if<
2811 std::is_same<T, Settings::Processing::Color::Experimental::ToneMapping::Enabled>::value,
2812 int>::type = 0>
2813 const Settings::Processing::Color::Experimental::ToneMapping::Enabled &get() const
2814 {
2815 return m_experimental.get<Settings::Processing::Color::Experimental::ToneMapping::Enabled>();
2816 }
2817
2818 template<
2819 typename T,
2820 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Gamma>::value, int>::type = 0>
2821 const Settings::Processing::Color::Gamma &get() const
2822 {
2823 return m_gamma;
2824 }
2825
2826 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
2827 const Settings::Processing::Color::Balance &get() const
2828 {
2829 return m_balance;
2830 }
2831
2832 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
2833 const Settings::Processing::Color::Experimental &get() const
2834 {
2835 return m_experimental;
2836 }
2837
2838 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
2839 const Settings::Processing::Color::Gamma &get() const
2840 {
2841 return m_gamma;
2842 }
2843
2845 template<typename F>
2846 void forEach(const F &f) const
2847 {
2848 f(m_balance);
2849 f(m_experimental);
2850 f(m_gamma);
2851 }
2852
2854 template<typename F>
2855 void forEach(const F &f)
2856 {
2857 f(m_balance);
2858 f(m_experimental);
2859 f(m_gamma);
2860 }
2861
2863 bool operator==(const Color &other) const;
2864
2866 bool operator!=(const Color &other) const;
2867
2869 std::string toString() const;
2870
2872 friend std::ostream &operator<<(std::ostream &stream, const Color &value)
2873 {
2874 return stream << value.toString();
2875 }
2876
2877 private:
2878 void setFromString(const std::string &value);
2879
2880 void setFromString(const std::string &fullPath, const std::string &value);
2881
2882 std::string getString(const std::string &fullPath) const;
2883
2884 Balance m_balance;
2885 Experimental m_experimental;
2886 Gamma m_gamma;
2887
2888 friend struct DataModel::Detail::Befriend<Color>;
2889 };
2890
2892 class ZIVID_CORE_EXPORT Filters
2893 {
2894 public:
2896 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
2897
2899 static constexpr const char *path{ "Processing/Filters" };
2900
2902 static constexpr const char *name{ "Filters" };
2903
2905 static constexpr const char *description{ R"description(Filters)description" };
2906
2908 class ZIVID_CORE_EXPORT Experimental
2909 {
2910 public:
2912 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
2913
2915 static constexpr const char *path{ "Processing/Filters/Experimental" };
2916
2918 static constexpr const char *name{ "Experimental" };
2919
2921 static constexpr const char *description{
2922 R"description(Experimental filters. These may be renamed, moved or deleted in the future.)description"
2923 };
2924
2930 class ZIVID_CORE_EXPORT ContrastDistortion
2931 {
2932 public:
2934 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
2935
2937 static constexpr const char *path{ "Processing/Filters/Experimental/ContrastDistortion" };
2938
2940 static constexpr const char *name{ "ContrastDistortion" };
2941
2943 static constexpr const char *description{
2944 R"description(Corrects artifacts that appear when imaging scenes with large texture gradients
2945or high contrast. These artifacts are caused by blurring in the lens. The filter
2946works best when aperture values are chosen such that the camera has quite good focus.
2947The filter also supports removing the points that experience a large correction.
2948)description"
2949 };
2950
2952 class ZIVID_CORE_EXPORT Correction
2953 {
2954 public:
2956 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
2957
2959 static constexpr const char *path{
2960 "Processing/Filters/Experimental/ContrastDistortion/Correction"
2961 };
2962
2964 static constexpr const char *name{ "Correction" };
2965
2967 static constexpr const char *description{ R"description(Correction)description" };
2968
2970 class ZIVID_CORE_EXPORT Enabled
2971 {
2972 public:
2974 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
2975
2977 static constexpr const char *path{
2978 "Processing/Filters/Experimental/ContrastDistortion/Correction/Enabled"
2979 };
2980
2982 static constexpr const char *name{ "Enabled" };
2983
2985 static constexpr const char *description{ R"description(Enabled)description" };
2986
2988 using ValueType = bool;
2989 static const Enabled yes;
2990 static const Enabled no;
2991
2993 static std::set<bool> validValues()
2994 {
2995 return { false, true };
2996 }
2997
2999 Enabled() = default;
3000
3002 explicit constexpr Enabled(bool value)
3003 : m_opt{ value }
3004 {}
3005
3010 bool value() const;
3011
3013 bool hasValue() const;
3014
3016 void reset();
3017
3019 std::string toString() const;
3020
3022 bool operator==(const Enabled &other) const
3023 {
3024 return m_opt == other.m_opt;
3025 }
3026
3028 bool operator!=(const Enabled &other) const
3029 {
3030 return m_opt != other.m_opt;
3031 }
3032
3034 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
3035 {
3036 return stream << value.toString();
3037 }
3038
3039 private:
3040 void setFromString(const std::string &value);
3041
3042 Zivid::DataModel::Detail::Optional<bool> m_opt;
3043
3044 friend struct DataModel::Detail::Befriend<Enabled>;
3045 };
3046
3048 class ZIVID_CORE_EXPORT Strength
3049 {
3050 public:
3052 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
3053
3055 static constexpr const char *path{
3056 "Processing/Filters/Experimental/ContrastDistortion/Correction/Strength"
3057 };
3058
3060 static constexpr const char *name{ "Strength" };
3061
3063 static constexpr const char *description{
3064 R"description(Higher values gives more correction.)description"
3065 };
3066
3068 using ValueType = double;
3069
3071 static constexpr Range<double> validRange()
3072 {
3073 return { 0.0, 1.0 };
3074 }
3075
3077 Strength() = default;
3078
3080 explicit constexpr Strength(double value)
3081 : m_opt{ verifyValue(value) }
3082 {}
3083
3088 double value() const;
3089
3091 bool hasValue() const;
3092
3094 void reset();
3095
3097 std::string toString() const;
3098
3100 bool operator==(const Strength &other) const
3101 {
3102 return m_opt == other.m_opt;
3103 }
3104
3106 bool operator!=(const Strength &other) const
3107 {
3108 return m_opt != other.m_opt;
3109 }
3110
3112 bool operator<(const Strength &other) const
3113 {
3114 return m_opt < other.m_opt;
3115 }
3116
3118 bool operator>(const Strength &other) const
3119 {
3120 return m_opt > other.m_opt;
3121 }
3122
3124 friend std::ostream &operator<<(std::ostream &stream, const Strength &value)
3125 {
3126 return stream << value.toString();
3127 }
3128
3129 private:
3130 void setFromString(const std::string &value);
3131
3132 constexpr ValueType static verifyValue(const ValueType &value)
3133 {
3134 return validRange().isInRange(value)
3135 ? value
3136 : throw std::out_of_range{ "Strength{ " + std::to_string(value)
3137 + " } is not in range ["
3138 + std::to_string(validRange().min()) + ", "
3139 + std::to_string(validRange().max()) + "]" };
3140 }
3141
3142 Zivid::DataModel::Detail::Optional<double> m_opt;
3143
3144 friend struct DataModel::Detail::Befriend<Strength>;
3145 };
3146
3147 using Descendants = std::tuple<
3148 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled,
3149 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>;
3150
3152 Correction();
3153
3166#ifndef NO_DOC
3167 template<typename... Args,
3168 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
3169 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
3170 Descendants,
3171 typename std::decay<Args>::type...>::value,
3172 int>::type = 0>
3173#else
3174 template<typename... Args>
3175#endif
3176 explicit Correction(Args &&...args)
3177 {
3178 using namespace Zivid::Detail::TypeTraits;
3179
3180 static_assert(AllArgsDecayedAreUnique<Args...>::value,
3181 "Found duplicate types among the arguments passed to Correction(...). "
3182 "Types should be listed at most once.");
3183
3184 set(std::forward<Args>(args)...);
3185 }
3186
3198#ifndef NO_DOC
3199 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
3200#else
3201 template<typename... Args>
3202#endif
3203 void set(Args &&...args)
3204 {
3205 using namespace Zivid::Detail::TypeTraits;
3206
3207 using AllArgsAreDescendantNodes =
3208 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
3209 static_assert(AllArgsAreDescendantNodes::value,
3210 "All arguments passed to set(...) must be descendant nodes.");
3211
3212 static_assert(AllArgsDecayedAreUnique<Args...>::value,
3213 "Found duplicate types among the arguments passed to set(...). "
3214 "Types should be listed at most once.");
3215
3216 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
3217 }
3218
3231#ifndef NO_DOC
3232 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
3233#else
3234 template<typename... Args>
3235#endif
3236 Correction copyWith(Args &&...args) const
3237 {
3238 using namespace Zivid::Detail::TypeTraits;
3239
3240 using AllArgsAreDescendantNodes =
3241 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
3242 static_assert(AllArgsAreDescendantNodes::value,
3243 "All arguments passed to copyWith(...) must be descendant nodes.");
3244
3245 static_assert(AllArgsDecayedAreUnique<Args...>::value,
3246 "Found duplicate types among the arguments passed to copyWith(...). "
3247 "Types should be listed at most once.");
3248
3249 auto copy{ *this };
3250 copy.set(std::forward<Args>(args)...);
3251 return copy;
3252 }
3253
3255 const Enabled &isEnabled() const
3256 {
3257 return m_enabled;
3258 }
3259
3261 Enabled &isEnabled()
3262 {
3263 return m_enabled;
3264 }
3265
3267 Correction &set(const Enabled &value)
3268 {
3269 m_enabled = value;
3270 return *this;
3271 }
3272
3274 const Strength &strength() const
3275 {
3276 return m_strength;
3277 }
3278
3280 Strength &strength()
3281 {
3282 return m_strength;
3283 }
3284
3286 Correction &set(const Strength &value)
3287 {
3288 m_strength = value;
3289 return *this;
3290 }
3291
3292 template<typename T,
3293 typename std::enable_if<
3294 std::is_same<T,
3295 Settings::Processing::Filters::Experimental::ContrastDistortion::
3296 Correction::Enabled>::value,
3297 int>::type = 0>
3298 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &
3299 get() const
3300 {
3301 return m_enabled;
3302 }
3303
3304 template<typename T,
3305 typename std::enable_if<
3306 std::is_same<T,
3307 Settings::Processing::Filters::Experimental::ContrastDistortion::
3308 Correction::Strength>::value,
3309 int>::type = 0>
3310 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength
3311 &
3312 get() const
3313 {
3314 return m_strength;
3315 }
3316
3317 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
3318 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &
3319 get() const
3320 {
3321 return m_enabled;
3322 }
3323
3324 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
3325 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength
3326 &
3327 get() const
3328 {
3329 return m_strength;
3330 }
3331
3333 template<typename F>
3334 void forEach(const F &f) const
3335 {
3336 f(m_enabled);
3337 f(m_strength);
3338 }
3339
3341 template<typename F>
3342 void forEach(const F &f)
3343 {
3344 f(m_enabled);
3345 f(m_strength);
3346 }
3347
3349 bool operator==(const Correction &other) const;
3350
3352 bool operator!=(const Correction &other) const;
3353
3355 std::string toString() const;
3356
3358 friend std::ostream &operator<<(std::ostream &stream, const Correction &value)
3359 {
3360 return stream << value.toString();
3361 }
3362
3363 private:
3364 void setFromString(const std::string &value);
3365
3366 void setFromString(const std::string &fullPath, const std::string &value);
3367
3368 std::string getString(const std::string &fullPath) const;
3369
3370 Enabled m_enabled;
3371 Strength m_strength;
3372
3373 friend struct DataModel::Detail::Befriend<Correction>;
3374 };
3375
3377 class ZIVID_CORE_EXPORT Removal
3378 {
3379 public:
3381 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
3382
3384 static constexpr const char *path{
3385 "Processing/Filters/Experimental/ContrastDistortion/Removal"
3386 };
3387
3389 static constexpr const char *name{ "Removal" };
3390
3392 static constexpr const char *description{ R"description(Removal)description" };
3393
3395 class ZIVID_CORE_EXPORT Enabled
3396 {
3397 public:
3399 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
3400
3402 static constexpr const char *path{
3403 "Processing/Filters/Experimental/ContrastDistortion/Removal/Enabled"
3404 };
3405
3407 static constexpr const char *name{ "Enabled" };
3408
3410 static constexpr const char *description{ R"description(Enabled)description" };
3411
3413 using ValueType = bool;
3414 static const Enabled yes;
3415 static const Enabled no;
3416
3418 static std::set<bool> validValues()
3419 {
3420 return { false, true };
3421 }
3422
3424 Enabled() = default;
3425
3427 explicit constexpr Enabled(bool value)
3428 : m_opt{ value }
3429 {}
3430
3435 bool value() const;
3436
3438 bool hasValue() const;
3439
3441 void reset();
3442
3444 std::string toString() const;
3445
3447 bool operator==(const Enabled &other) const
3448 {
3449 return m_opt == other.m_opt;
3450 }
3451
3453 bool operator!=(const Enabled &other) const
3454 {
3455 return m_opt != other.m_opt;
3456 }
3457
3459 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
3460 {
3461 return stream << value.toString();
3462 }
3463
3464 private:
3465 void setFromString(const std::string &value);
3466
3467 Zivid::DataModel::Detail::Optional<bool> m_opt;
3468
3469 friend struct DataModel::Detail::Befriend<Enabled>;
3470 };
3471
3473 class ZIVID_CORE_EXPORT Threshold
3474 {
3475 public:
3477 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
3478
3480 static constexpr const char *path{
3481 "Processing/Filters/Experimental/ContrastDistortion/Removal/Threshold"
3482 };
3483
3485 static constexpr const char *name{ "Threshold" };
3486
3488 static constexpr const char *description{
3489 R"description(Higher values remove more points.)description"
3490 };
3491
3493 using ValueType = double;
3494
3496 static constexpr Range<double> validRange()
3497 {
3498 return { 0.0, 1.0 };
3499 }
3500
3502 Threshold() = default;
3503
3505 explicit constexpr Threshold(double value)
3506 : m_opt{ verifyValue(value) }
3507 {}
3508
3513 double value() const;
3514
3516 bool hasValue() const;
3517
3519 void reset();
3520
3522 std::string toString() const;
3523
3525 bool operator==(const Threshold &other) const
3526 {
3527 return m_opt == other.m_opt;
3528 }
3529
3531 bool operator!=(const Threshold &other) const
3532 {
3533 return m_opt != other.m_opt;
3534 }
3535
3537 bool operator<(const Threshold &other) const
3538 {
3539 return m_opt < other.m_opt;
3540 }
3541
3543 bool operator>(const Threshold &other) const
3544 {
3545 return m_opt > other.m_opt;
3546 }
3547
3549 friend std::ostream &operator<<(std::ostream &stream, const Threshold &value)
3550 {
3551 return stream << value.toString();
3552 }
3553
3554 private:
3555 void setFromString(const std::string &value);
3556
3557 constexpr ValueType static verifyValue(const ValueType &value)
3558 {
3559 return validRange().isInRange(value)
3560 ? value
3561 : throw std::out_of_range{ "Threshold{ " + std::to_string(value)
3562 + " } is not in range ["
3563 + std::to_string(validRange().min()) + ", "
3564 + std::to_string(validRange().max()) + "]" };
3565 }
3566
3567 Zivid::DataModel::Detail::Optional<double> m_opt;
3568
3569 friend struct DataModel::Detail::Befriend<Threshold>;
3570 };
3571
3572 using Descendants = std::tuple<
3573 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled,
3574 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>;
3575
3577 Removal();
3578
3591#ifndef NO_DOC
3592 template<typename... Args,
3593 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
3594 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
3595 Descendants,
3596 typename std::decay<Args>::type...>::value,
3597 int>::type = 0>
3598#else
3599 template<typename... Args>
3600#endif
3601 explicit Removal(Args &&...args)
3602 {
3603 using namespace Zivid::Detail::TypeTraits;
3604
3605 static_assert(AllArgsDecayedAreUnique<Args...>::value,
3606 "Found duplicate types among the arguments passed to Removal(...). "
3607 "Types should be listed at most once.");
3608
3609 set(std::forward<Args>(args)...);
3610 }
3611
3623#ifndef NO_DOC
3624 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
3625#else
3626 template<typename... Args>
3627#endif
3628 void set(Args &&...args)
3629 {
3630 using namespace Zivid::Detail::TypeTraits;
3631
3632 using AllArgsAreDescendantNodes =
3633 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
3634 static_assert(AllArgsAreDescendantNodes::value,
3635 "All arguments passed to set(...) must be descendant nodes.");
3636
3637 static_assert(AllArgsDecayedAreUnique<Args...>::value,
3638 "Found duplicate types among the arguments passed to set(...). "
3639 "Types should be listed at most once.");
3640
3641 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
3642 }
3643
3656#ifndef NO_DOC
3657 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
3658#else
3659 template<typename... Args>
3660#endif
3661 Removal copyWith(Args &&...args) const
3662 {
3663 using namespace Zivid::Detail::TypeTraits;
3664
3665 using AllArgsAreDescendantNodes =
3666 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
3667 static_assert(AllArgsAreDescendantNodes::value,
3668 "All arguments passed to copyWith(...) must be descendant nodes.");
3669
3670 static_assert(AllArgsDecayedAreUnique<Args...>::value,
3671 "Found duplicate types among the arguments passed to copyWith(...). "
3672 "Types should be listed at most once.");
3673
3674 auto copy{ *this };
3675 copy.set(std::forward<Args>(args)...);
3676 return copy;
3677 }
3678
3680 const Enabled &isEnabled() const
3681 {
3682 return m_enabled;
3683 }
3684
3686 Enabled &isEnabled()
3687 {
3688 return m_enabled;
3689 }
3690
3692 Removal &set(const Enabled &value)
3693 {
3694 m_enabled = value;
3695 return *this;
3696 }
3697
3699 const Threshold &threshold() const
3700 {
3701 return m_threshold;
3702 }
3703
3705 Threshold &threshold()
3706 {
3707 return m_threshold;
3708 }
3709
3711 Removal &set(const Threshold &value)
3712 {
3713 m_threshold = value;
3714 return *this;
3715 }
3716
3717 template<
3718 typename T,
3719 typename std::enable_if<std::is_same<T,
3720 Settings::Processing::Filters::Experimental::
3721 ContrastDistortion::Removal::Enabled>::value,
3722 int>::type = 0>
3723 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &
3724 get() const
3725 {
3726 return m_enabled;
3727 }
3728
3729 template<
3730 typename T,
3731 typename std::enable_if<std::is_same<T,
3732 Settings::Processing::Filters::Experimental::
3733 ContrastDistortion::Removal::Threshold>::value,
3734 int>::type = 0>
3735 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &
3736 get() const
3737 {
3738 return m_threshold;
3739 }
3740
3741 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
3742 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &
3743 get() const
3744 {
3745 return m_enabled;
3746 }
3747
3748 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
3749 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &
3750 get() const
3751 {
3752 return m_threshold;
3753 }
3754
3756 template<typename F>
3757 void forEach(const F &f) const
3758 {
3759 f(m_enabled);
3760 f(m_threshold);
3761 }
3762
3764 template<typename F>
3765 void forEach(const F &f)
3766 {
3767 f(m_enabled);
3768 f(m_threshold);
3769 }
3770
3772 bool operator==(const Removal &other) const;
3773
3775 bool operator!=(const Removal &other) const;
3776
3778 std::string toString() const;
3779
3781 friend std::ostream &operator<<(std::ostream &stream, const Removal &value)
3782 {
3783 return stream << value.toString();
3784 }
3785
3786 private:
3787 void setFromString(const std::string &value);
3788
3789 void setFromString(const std::string &fullPath, const std::string &value);
3790
3791 std::string getString(const std::string &fullPath) const;
3792
3793 Enabled m_enabled;
3794 Threshold m_threshold;
3795
3796 friend struct DataModel::Detail::Befriend<Removal>;
3797 };
3798
3799 using Descendants = std::tuple<
3800 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction,
3801 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled,
3802 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength,
3803 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal,
3804 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled,
3805 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>;
3806
3808 ContrastDistortion();
3809
3826#ifndef NO_DOC
3827 template<typename... Args,
3828 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
3829 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
3830 Descendants,
3831 typename std::decay<Args>::type...>::value,
3832 int>::type = 0>
3833#else
3834 template<typename... Args>
3835#endif
3836 explicit ContrastDistortion(Args &&...args)
3837 {
3838 using namespace Zivid::Detail::TypeTraits;
3839
3840 static_assert(
3841 AllArgsDecayedAreUnique<Args...>::value,
3842 "Found duplicate types among the arguments passed to ContrastDistortion(...). "
3843 "Types should be listed at most once.");
3844
3845 set(std::forward<Args>(args)...);
3846 }
3847
3863#ifndef NO_DOC
3864 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
3865#else
3866 template<typename... Args>
3867#endif
3868 void set(Args &&...args)
3869 {
3870 using namespace Zivid::Detail::TypeTraits;
3871
3872 using AllArgsAreDescendantNodes =
3873 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
3874 static_assert(AllArgsAreDescendantNodes::value,
3875 "All arguments passed to set(...) must be descendant nodes.");
3876
3877 static_assert(AllArgsDecayedAreUnique<Args...>::value,
3878 "Found duplicate types among the arguments passed to set(...). "
3879 "Types should be listed at most once.");
3880
3881 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
3882 }
3883
3900#ifndef NO_DOC
3901 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
3902#else
3903 template<typename... Args>
3904#endif
3905 ContrastDistortion copyWith(Args &&...args) const
3906 {
3907 using namespace Zivid::Detail::TypeTraits;
3908
3909 using AllArgsAreDescendantNodes =
3910 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
3911 static_assert(AllArgsAreDescendantNodes::value,
3912 "All arguments passed to copyWith(...) must be descendant nodes.");
3913
3914 static_assert(AllArgsDecayedAreUnique<Args...>::value,
3915 "Found duplicate types among the arguments passed to copyWith(...). "
3916 "Types should be listed at most once.");
3917
3918 auto copy{ *this };
3919 copy.set(std::forward<Args>(args)...);
3920 return copy;
3921 }
3922
3924 const Correction &correction() const
3925 {
3926 return m_correction;
3927 }
3928
3930 Correction &correction()
3931 {
3932 return m_correction;
3933 }
3934
3936 ContrastDistortion &set(const Correction &value)
3937 {
3938 m_correction = value;
3939 return *this;
3940 }
3941
3943 ContrastDistortion &set(const Correction::Enabled &value)
3944 {
3945 m_correction.set(value);
3946 return *this;
3947 }
3948
3950 ContrastDistortion &set(const Correction::Strength &value)
3951 {
3952 m_correction.set(value);
3953 return *this;
3954 }
3955
3957 const Removal &removal() const
3958 {
3959 return m_removal;
3960 }
3961
3963 Removal &removal()
3964 {
3965 return m_removal;
3966 }
3967
3969 ContrastDistortion &set(const Removal &value)
3970 {
3971 m_removal = value;
3972 return *this;
3973 }
3974
3976 ContrastDistortion &set(const Removal::Enabled &value)
3977 {
3978 m_removal.set(value);
3979 return *this;
3980 }
3981
3983 ContrastDistortion &set(const Removal::Threshold &value)
3984 {
3985 m_removal.set(value);
3986 return *this;
3987 }
3988
3989 template<typename T,
3990 typename std::enable_if<std::is_same<T,
3991 Settings::Processing::Filters::Experimental::
3992 ContrastDistortion::Correction>::value,
3993 int>::type = 0>
3994 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction &get() const
3995 {
3996 return m_correction;
3997 }
3998
3999 template<
4000 typename T,
4001 typename std::enable_if<std::is_same<T,
4002 Settings::Processing::Filters::Experimental::
4003 ContrastDistortion::Correction::Enabled>::value,
4004 int>::type = 0>
4005 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &
4006 get() const
4007 {
4008 return m_correction.get<
4009 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>();
4010 }
4011
4012 template<
4013 typename T,
4014 typename std::enable_if<std::is_same<T,
4015 Settings::Processing::Filters::Experimental::
4016 ContrastDistortion::Correction::Strength>::value,
4017 int>::type = 0>
4018 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &
4019 get() const
4020 {
4021 return m_correction.get<Settings::Processing::Filters::Experimental::ContrastDistortion::
4022 Correction::Strength>();
4023 }
4024
4025 template<typename T,
4026 typename std::enable_if<std::is_same<T,
4027 Settings::Processing::Filters::Experimental::
4028 ContrastDistortion::Removal>::value,
4029 int>::type = 0>
4030 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal &get() const
4031 {
4032 return m_removal;
4033 }
4034
4035 template<typename T,
4036 typename std::enable_if<std::is_same<T,
4037 Settings::Processing::Filters::Experimental::
4038 ContrastDistortion::Removal::Enabled>::value,
4039 int>::type = 0>
4040 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &get()
4041 const
4042 {
4043 return m_removal.get<
4044 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>();
4045 }
4046
4047 template<
4048 typename T,
4049 typename std::enable_if<std::is_same<T,
4050 Settings::Processing::Filters::Experimental::
4051 ContrastDistortion::Removal::Threshold>::value,
4052 int>::type = 0>
4053 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &get()
4054 const
4055 {
4056 return m_removal.get<
4057 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>();
4058 }
4059
4060 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
4061 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction &get() const
4062 {
4063 return m_correction;
4064 }
4065
4066 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
4067 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal &get() const
4068 {
4069 return m_removal;
4070 }
4071
4073 template<typename F>
4074 void forEach(const F &f) const
4075 {
4076 f(m_correction);
4077 f(m_removal);
4078 }
4079
4081 template<typename F>
4082 void forEach(const F &f)
4083 {
4084 f(m_correction);
4085 f(m_removal);
4086 }
4087
4089 bool operator==(const ContrastDistortion &other) const;
4090
4092 bool operator!=(const ContrastDistortion &other) const;
4093
4095 std::string toString() const;
4096
4098 friend std::ostream &operator<<(std::ostream &stream, const ContrastDistortion &value)
4099 {
4100 return stream << value.toString();
4101 }
4102
4103 private:
4104 void setFromString(const std::string &value);
4105
4106 void setFromString(const std::string &fullPath, const std::string &value);
4107
4108 std::string getString(const std::string &fullPath) const;
4109
4110 Correction m_correction;
4111 Removal m_removal;
4112
4113 friend struct DataModel::Detail::Befriend<ContrastDistortion>;
4114 };
4115
4116 using Descendants = std::tuple<
4117 Settings::Processing::Filters::Experimental::ContrastDistortion,
4118 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction,
4119 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled,
4120 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength,
4121 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal,
4122 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled,
4123 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>;
4124
4126 Experimental();
4127
4145#ifndef NO_DOC
4146 template<typename... Args,
4147 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
4148 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
4149 Descendants,
4150 typename std::decay<Args>::type...>::value,
4151 int>::type = 0>
4152#else
4153 template<typename... Args>
4154#endif
4155 explicit Experimental(Args &&...args)
4156 {
4157 using namespace Zivid::Detail::TypeTraits;
4158
4159 static_assert(AllArgsDecayedAreUnique<Args...>::value,
4160 "Found duplicate types among the arguments passed to Experimental(...). "
4161 "Types should be listed at most once.");
4162
4163 set(std::forward<Args>(args)...);
4164 }
4165
4182#ifndef NO_DOC
4183 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
4184#else
4185 template<typename... Args>
4186#endif
4187 void set(Args &&...args)
4188 {
4189 using namespace Zivid::Detail::TypeTraits;
4190
4191 using AllArgsAreDescendantNodes =
4192 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
4193 static_assert(AllArgsAreDescendantNodes::value,
4194 "All arguments passed to set(...) must be descendant nodes.");
4195
4196 static_assert(AllArgsDecayedAreUnique<Args...>::value,
4197 "Found duplicate types among the arguments passed to set(...). "
4198 "Types should be listed at most once.");
4199
4200 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
4201 }
4202
4220#ifndef NO_DOC
4221 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
4222#else
4223 template<typename... Args>
4224#endif
4225 Experimental copyWith(Args &&...args) const
4226 {
4227 using namespace Zivid::Detail::TypeTraits;
4228
4229 using AllArgsAreDescendantNodes =
4230 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
4231 static_assert(AllArgsAreDescendantNodes::value,
4232 "All arguments passed to copyWith(...) must be descendant nodes.");
4233
4234 static_assert(AllArgsDecayedAreUnique<Args...>::value,
4235 "Found duplicate types among the arguments passed to copyWith(...). "
4236 "Types should be listed at most once.");
4237
4238 auto copy{ *this };
4239 copy.set(std::forward<Args>(args)...);
4240 return copy;
4241 }
4242
4244 const ContrastDistortion &contrastDistortion() const
4245 {
4246 return m_contrastDistortion;
4247 }
4248
4250 ContrastDistortion &contrastDistortion()
4251 {
4252 return m_contrastDistortion;
4253 }
4254
4256 Experimental &set(const ContrastDistortion &value)
4257 {
4258 m_contrastDistortion = value;
4259 return *this;
4260 }
4261
4263 Experimental &set(const ContrastDistortion::Correction &value)
4264 {
4265 m_contrastDistortion.set(value);
4266 return *this;
4267 }
4268
4270 Experimental &set(const ContrastDistortion::Correction::Enabled &value)
4271 {
4272 m_contrastDistortion.set(value);
4273 return *this;
4274 }
4275
4277 Experimental &set(const ContrastDistortion::Correction::Strength &value)
4278 {
4279 m_contrastDistortion.set(value);
4280 return *this;
4281 }
4282
4284 Experimental &set(const ContrastDistortion::Removal &value)
4285 {
4286 m_contrastDistortion.set(value);
4287 return *this;
4288 }
4289
4291 Experimental &set(const ContrastDistortion::Removal::Enabled &value)
4292 {
4293 m_contrastDistortion.set(value);
4294 return *this;
4295 }
4296
4298 Experimental &set(const ContrastDistortion::Removal::Threshold &value)
4299 {
4300 m_contrastDistortion.set(value);
4301 return *this;
4302 }
4303
4304 template<
4305 typename T,
4306 typename std::enable_if<
4307 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
4308 int>::type = 0>
4309 const Settings::Processing::Filters::Experimental::ContrastDistortion &get() const
4310 {
4311 return m_contrastDistortion;
4312 }
4313
4314 template<typename T,
4315 typename std::enable_if<std::is_same<T,
4316 Settings::Processing::Filters::Experimental::
4317 ContrastDistortion::Correction>::value,
4318 int>::type = 0>
4319 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction &get() const
4320 {
4321 return m_contrastDistortion
4322 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>();
4323 }
4324
4325 template<typename T,
4326 typename std::enable_if<std::is_same<T,
4327 Settings::Processing::Filters::Experimental::
4328 ContrastDistortion::Correction::Enabled>::value,
4329 int>::type = 0>
4330 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &get()
4331 const
4332 {
4333 return m_contrastDistortion.get<
4334 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>();
4335 }
4336
4337 template<typename T,
4338 typename std::enable_if<std::is_same<T,
4339 Settings::Processing::Filters::Experimental::
4340 ContrastDistortion::Correction::Strength>::value,
4341 int>::type = 0>
4342 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &get()
4343 const
4344 {
4345 return m_contrastDistortion.get<
4346 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>();
4347 }
4348
4349 template<
4350 typename T,
4351 typename std::enable_if<
4352 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::
4353 value,
4354 int>::type = 0>
4355 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal &get() const
4356 {
4357 return m_contrastDistortion
4358 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>();
4359 }
4360
4361 template<typename T,
4362 typename std::enable_if<std::is_same<T,
4363 Settings::Processing::Filters::Experimental::
4364 ContrastDistortion::Removal::Enabled>::value,
4365 int>::type = 0>
4366 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &get() const
4367 {
4368 return m_contrastDistortion
4369 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>();
4370 }
4371
4372 template<typename T,
4373 typename std::enable_if<std::is_same<T,
4374 Settings::Processing::Filters::Experimental::
4375 ContrastDistortion::Removal::Threshold>::value,
4376 int>::type = 0>
4377 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &get()
4378 const
4379 {
4380 return m_contrastDistortion
4381 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>();
4382 }
4383
4384 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
4385 const Settings::Processing::Filters::Experimental::ContrastDistortion &get() const
4386 {
4387 return m_contrastDistortion;
4388 }
4389
4391 template<typename F>
4392 void forEach(const F &f) const
4393 {
4394 f(m_contrastDistortion);
4395 }
4396
4398 template<typename F>
4399 void forEach(const F &f)
4400 {
4401 f(m_contrastDistortion);
4402 }
4403
4405 bool operator==(const Experimental &other) const;
4406
4408 bool operator!=(const Experimental &other) const;
4409
4411 std::string toString() const;
4412
4414 friend std::ostream &operator<<(std::ostream &stream, const Experimental &value)
4415 {
4416 return stream << value.toString();
4417 }
4418
4419 private:
4420 void setFromString(const std::string &value);
4421
4422 void setFromString(const std::string &fullPath, const std::string &value);
4423
4424 std::string getString(const std::string &fullPath) const;
4425
4426 ContrastDistortion m_contrastDistortion;
4427
4428 friend struct DataModel::Detail::Befriend<Experimental>;
4429 };
4430
4432 class ZIVID_CORE_EXPORT Noise
4433 {
4434 public:
4436 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
4437
4439 static constexpr const char *path{ "Processing/Filters/Noise" };
4440
4442 static constexpr const char *name{ "Noise" };
4443
4445 static constexpr const char *description{
4446 R"description(Contains a filter that removes points with low signal-to-noise ratio (SNR))description"
4447 };
4448
4450 class ZIVID_CORE_EXPORT Removal
4451 {
4452 public:
4454 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
4455
4457 static constexpr const char *path{ "Processing/Filters/Noise/Removal" };
4458
4460 static constexpr const char *name{ "Removal" };
4461
4463 static constexpr const char *description{
4464 R"description(Discard points with signal-to-noise ratio (SNR) values below a threshold)description"
4465 };
4466
4468 class ZIVID_CORE_EXPORT Enabled
4469 {
4470 public:
4472 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
4473
4475 static constexpr const char *path{ "Processing/Filters/Noise/Removal/Enabled" };
4476
4478 static constexpr const char *name{ "Enabled" };
4479
4481 static constexpr const char *description{
4482 R"description(Enable or disable the SNR filter)description"
4483 };
4484
4486 using ValueType = bool;
4487 static const Enabled yes;
4488 static const Enabled no;
4489
4491 static std::set<bool> validValues()
4492 {
4493 return { false, true };
4494 }
4495
4497 Enabled() = default;
4498
4500 explicit constexpr Enabled(bool value)
4501 : m_opt{ value }
4502 {}
4503
4508 bool value() const;
4509
4511 bool hasValue() const;
4512
4514 void reset();
4515
4517 std::string toString() const;
4518
4520 bool operator==(const Enabled &other) const
4521 {
4522 return m_opt == other.m_opt;
4523 }
4524
4526 bool operator!=(const Enabled &other) const
4527 {
4528 return m_opt != other.m_opt;
4529 }
4530
4532 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
4533 {
4534 return stream << value.toString();
4535 }
4536
4537 private:
4538 void setFromString(const std::string &value);
4539
4540 Zivid::DataModel::Detail::Optional<bool> m_opt;
4541
4542 friend struct DataModel::Detail::Befriend<Enabled>;
4543 };
4544
4546 class ZIVID_CORE_EXPORT Threshold
4547 {
4548 public:
4550 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
4551
4553 static constexpr const char *path{ "Processing/Filters/Noise/Removal/Threshold" };
4554
4556 static constexpr const char *name{ "Threshold" };
4557
4559 static constexpr const char *description{
4560 R"description(Discard points with signal-to-noise ratio (SNR) below the given value)description"
4561 };
4562
4564 using ValueType = double;
4565
4567 static constexpr Range<double> validRange()
4568 {
4569 return { 0.0, 100.0 };
4570 }
4571
4573 Threshold() = default;
4574
4576 explicit constexpr Threshold(double value)
4577 : m_opt{ verifyValue(value) }
4578 {}
4579
4584 double value() const;
4585
4587 bool hasValue() const;
4588
4590 void reset();
4591
4593 std::string toString() const;
4594
4596 bool operator==(const Threshold &other) const
4597 {
4598 return m_opt == other.m_opt;
4599 }
4600
4602 bool operator!=(const Threshold &other) const
4603 {
4604 return m_opt != other.m_opt;
4605 }
4606
4608 bool operator<(const Threshold &other) const
4609 {
4610 return m_opt < other.m_opt;
4611 }
4612
4614 bool operator>(const Threshold &other) const
4615 {
4616 return m_opt > other.m_opt;
4617 }
4618
4620 friend std::ostream &operator<<(std::ostream &stream, const Threshold &value)
4621 {
4622 return stream << value.toString();
4623 }
4624
4625 private:
4626 void setFromString(const std::string &value);
4627
4628 constexpr ValueType static verifyValue(const ValueType &value)
4629 {
4630 return validRange().isInRange(value)
4631 ? value
4632 : throw std::out_of_range{ "Threshold{ " + std::to_string(value)
4633 + " } is not in range ["
4634 + std::to_string(validRange().min()) + ", "
4635 + std::to_string(validRange().max()) + "]" };
4636 }
4637
4638 Zivid::DataModel::Detail::Optional<double> m_opt;
4639
4640 friend struct DataModel::Detail::Befriend<Threshold>;
4641 };
4642
4643 using Descendants = std::tuple<Settings::Processing::Filters::Noise::Removal::Enabled,
4644 Settings::Processing::Filters::Noise::Removal::Threshold>;
4645
4647 Removal();
4648
4661#ifndef NO_DOC
4662 template<typename... Args,
4663 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
4664 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
4665 Descendants,
4666 typename std::decay<Args>::type...>::value,
4667 int>::type = 0>
4668#else
4669 template<typename... Args>
4670#endif
4671 explicit Removal(Args &&...args)
4672 {
4673 using namespace Zivid::Detail::TypeTraits;
4674
4675 static_assert(AllArgsDecayedAreUnique<Args...>::value,
4676 "Found duplicate types among the arguments passed to Removal(...). "
4677 "Types should be listed at most once.");
4678
4679 set(std::forward<Args>(args)...);
4680 }
4681
4693#ifndef NO_DOC
4694 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
4695#else
4696 template<typename... Args>
4697#endif
4698 void set(Args &&...args)
4699 {
4700 using namespace Zivid::Detail::TypeTraits;
4701
4702 using AllArgsAreDescendantNodes =
4703 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
4704 static_assert(AllArgsAreDescendantNodes::value,
4705 "All arguments passed to set(...) must be descendant nodes.");
4706
4707 static_assert(AllArgsDecayedAreUnique<Args...>::value,
4708 "Found duplicate types among the arguments passed to set(...). "
4709 "Types should be listed at most once.");
4710
4711 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
4712 }
4713
4726#ifndef NO_DOC
4727 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
4728#else
4729 template<typename... Args>
4730#endif
4731 Removal copyWith(Args &&...args) const
4732 {
4733 using namespace Zivid::Detail::TypeTraits;
4734
4735 using AllArgsAreDescendantNodes =
4736 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
4737 static_assert(AllArgsAreDescendantNodes::value,
4738 "All arguments passed to copyWith(...) must be descendant nodes.");
4739
4740 static_assert(AllArgsDecayedAreUnique<Args...>::value,
4741 "Found duplicate types among the arguments passed to copyWith(...). "
4742 "Types should be listed at most once.");
4743
4744 auto copy{ *this };
4745 copy.set(std::forward<Args>(args)...);
4746 return copy;
4747 }
4748
4750 const Enabled &isEnabled() const
4751 {
4752 return m_enabled;
4753 }
4754
4756 Enabled &isEnabled()
4757 {
4758 return m_enabled;
4759 }
4760
4762 Removal &set(const Enabled &value)
4763 {
4764 m_enabled = value;
4765 return *this;
4766 }
4767
4769 const Threshold &threshold() const
4770 {
4771 return m_threshold;
4772 }
4773
4775 Threshold &threshold()
4776 {
4777 return m_threshold;
4778 }
4779
4781 Removal &set(const Threshold &value)
4782 {
4783 m_threshold = value;
4784 return *this;
4785 }
4786
4787 template<typename T,
4788 typename std::enable_if<
4789 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
4790 int>::type = 0>
4791 const Settings::Processing::Filters::Noise::Removal::Enabled &get() const
4792 {
4793 return m_enabled;
4794 }
4795
4796 template<typename T,
4797 typename std::enable_if<
4798 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
4799 int>::type = 0>
4800 const Settings::Processing::Filters::Noise::Removal::Threshold &get() const
4801 {
4802 return m_threshold;
4803 }
4804
4805 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
4806 const Settings::Processing::Filters::Noise::Removal::Enabled &get() const
4807 {
4808 return m_enabled;
4809 }
4810
4811 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
4812 const Settings::Processing::Filters::Noise::Removal::Threshold &get() const
4813 {
4814 return m_threshold;
4815 }
4816
4818 template<typename F>
4819 void forEach(const F &f) const
4820 {
4821 f(m_enabled);
4822 f(m_threshold);
4823 }
4824
4826 template<typename F>
4827 void forEach(const F &f)
4828 {
4829 f(m_enabled);
4830 f(m_threshold);
4831 }
4832
4834 bool operator==(const Removal &other) const;
4835
4837 bool operator!=(const Removal &other) const;
4838
4840 std::string toString() const;
4841
4843 friend std::ostream &operator<<(std::ostream &stream, const Removal &value)
4844 {
4845 return stream << value.toString();
4846 }
4847
4848 private:
4849 void setFromString(const std::string &value);
4850
4851 void setFromString(const std::string &fullPath, const std::string &value);
4852
4853 std::string getString(const std::string &fullPath) const;
4854
4855 Enabled m_enabled;
4856 Threshold m_threshold;
4857
4858 friend struct DataModel::Detail::Befriend<Removal>;
4859 };
4860
4861 using Descendants = std::tuple<Settings::Processing::Filters::Noise::Removal,
4862 Settings::Processing::Filters::Noise::Removal::Enabled,
4863 Settings::Processing::Filters::Noise::Removal::Threshold>;
4864
4866 Noise();
4867
4881#ifndef NO_DOC
4882 template<typename... Args,
4883 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
4884 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
4885 Descendants,
4886 typename std::decay<Args>::type...>::value,
4887 int>::type = 0>
4888#else
4889 template<typename... Args>
4890#endif
4891 explicit Noise(Args &&...args)
4892 {
4893 using namespace Zivid::Detail::TypeTraits;
4894
4895 static_assert(AllArgsDecayedAreUnique<Args...>::value,
4896 "Found duplicate types among the arguments passed to Noise(...). "
4897 "Types should be listed at most once.");
4898
4899 set(std::forward<Args>(args)...);
4900 }
4901
4914#ifndef NO_DOC
4915 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
4916#else
4917 template<typename... Args>
4918#endif
4919 void set(Args &&...args)
4920 {
4921 using namespace Zivid::Detail::TypeTraits;
4922
4923 using AllArgsAreDescendantNodes =
4924 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
4925 static_assert(AllArgsAreDescendantNodes::value,
4926 "All arguments passed to set(...) must be descendant nodes.");
4927
4928 static_assert(AllArgsDecayedAreUnique<Args...>::value,
4929 "Found duplicate types among the arguments passed to set(...). "
4930 "Types should be listed at most once.");
4931
4932 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
4933 }
4934
4948#ifndef NO_DOC
4949 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
4950#else
4951 template<typename... Args>
4952#endif
4953 Noise copyWith(Args &&...args) const
4954 {
4955 using namespace Zivid::Detail::TypeTraits;
4956
4957 using AllArgsAreDescendantNodes =
4958 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
4959 static_assert(AllArgsAreDescendantNodes::value,
4960 "All arguments passed to copyWith(...) must be descendant nodes.");
4961
4962 static_assert(AllArgsDecayedAreUnique<Args...>::value,
4963 "Found duplicate types among the arguments passed to copyWith(...). "
4964 "Types should be listed at most once.");
4965
4966 auto copy{ *this };
4967 copy.set(std::forward<Args>(args)...);
4968 return copy;
4969 }
4970
4972 const Removal &removal() const
4973 {
4974 return m_removal;
4975 }
4976
4978 Removal &removal()
4979 {
4980 return m_removal;
4981 }
4982
4984 Noise &set(const Removal &value)
4985 {
4986 m_removal = value;
4987 return *this;
4988 }
4989
4991 Noise &set(const Removal::Enabled &value)
4992 {
4993 m_removal.set(value);
4994 return *this;
4995 }
4996
4998 Noise &set(const Removal::Threshold &value)
4999 {
5000 m_removal.set(value);
5001 return *this;
5002 }
5003
5004 template<
5005 typename T,
5006 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Removal>::value,
5007 int>::type = 0>
5008 const Settings::Processing::Filters::Noise::Removal &get() const
5009 {
5010 return m_removal;
5011 }
5012
5013 template<typename T,
5014 typename std::enable_if<
5015 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
5016 int>::type = 0>
5017 const Settings::Processing::Filters::Noise::Removal::Enabled &get() const
5018 {
5019 return m_removal.get<Settings::Processing::Filters::Noise::Removal::Enabled>();
5020 }
5021
5022 template<typename T,
5023 typename std::enable_if<
5024 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
5025 int>::type = 0>
5026 const Settings::Processing::Filters::Noise::Removal::Threshold &get() const
5027 {
5028 return m_removal.get<Settings::Processing::Filters::Noise::Removal::Threshold>();
5029 }
5030
5031 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
5032 const Settings::Processing::Filters::Noise::Removal &get() const
5033 {
5034 return m_removal;
5035 }
5036
5038 template<typename F>
5039 void forEach(const F &f) const
5040 {
5041 f(m_removal);
5042 }
5043
5045 template<typename F>
5046 void forEach(const F &f)
5047 {
5048 f(m_removal);
5049 }
5050
5052 bool operator==(const Noise &other) const;
5053
5055 bool operator!=(const Noise &other) const;
5056
5058 std::string toString() const;
5059
5061 friend std::ostream &operator<<(std::ostream &stream, const Noise &value)
5062 {
5063 return stream << value.toString();
5064 }
5065
5066 private:
5067 void setFromString(const std::string &value);
5068
5069 void setFromString(const std::string &fullPath, const std::string &value);
5070
5071 std::string getString(const std::string &fullPath) const;
5072
5073 Removal m_removal;
5074
5075 friend struct DataModel::Detail::Befriend<Noise>;
5076 };
5077
5079 class ZIVID_CORE_EXPORT Outlier
5080 {
5081 public:
5083 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
5084
5086 static constexpr const char *path{ "Processing/Filters/Outlier" };
5087
5089 static constexpr const char *name{ "Outlier" };
5090
5092 static constexpr const char *description{
5093 R"description(Contains a filter that removes points with large Euclidean distance to neighboring points)description"
5094 };
5095
5097 class ZIVID_CORE_EXPORT Removal
5098 {
5099 public:
5101 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
5102
5104 static constexpr const char *path{ "Processing/Filters/Outlier/Removal" };
5105
5107 static constexpr const char *name{ "Removal" };
5108
5110 static constexpr const char *description{
5111 R"description(Discard point if Euclidean distance to neighboring points is above a threshold)description"
5112 };
5113
5115 class ZIVID_CORE_EXPORT Enabled
5116 {
5117 public:
5119 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
5120
5122 static constexpr const char *path{ "Processing/Filters/Outlier/Removal/Enabled" };
5123
5125 static constexpr const char *name{ "Enabled" };
5126
5128 static constexpr const char *description{
5129 R"description(Enable or disable the outlier filter)description"
5130 };
5131
5133 using ValueType = bool;
5134 static const Enabled yes;
5135 static const Enabled no;
5136
5138 static std::set<bool> validValues()
5139 {
5140 return { false, true };
5141 }
5142
5144 Enabled() = default;
5145
5147 explicit constexpr Enabled(bool value)
5148 : m_opt{ value }
5149 {}
5150
5155 bool value() const;
5156
5158 bool hasValue() const;
5159
5161 void reset();
5162
5164 std::string toString() const;
5165
5167 bool operator==(const Enabled &other) const
5168 {
5169 return m_opt == other.m_opt;
5170 }
5171
5173 bool operator!=(const Enabled &other) const
5174 {
5175 return m_opt != other.m_opt;
5176 }
5177
5179 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
5180 {
5181 return stream << value.toString();
5182 }
5183
5184 private:
5185 void setFromString(const std::string &value);
5186
5187 Zivid::DataModel::Detail::Optional<bool> m_opt;
5188
5189 friend struct DataModel::Detail::Befriend<Enabled>;
5190 };
5191
5193 class ZIVID_CORE_EXPORT Threshold
5194 {
5195 public:
5197 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
5198
5200 static constexpr const char *path{ "Processing/Filters/Outlier/Removal/Threshold" };
5201
5203 static constexpr const char *name{ "Threshold" };
5204
5206 static constexpr const char *description{
5207 R"description(Discard point if Euclidean distance to neighboring points is above the given value)description"
5208 };
5209
5211 using ValueType = double;
5212
5214 static constexpr Range<double> validRange()
5215 {
5216 return { 0.0, 100.0 };
5217 }
5218
5220 Threshold() = default;
5221
5223 explicit constexpr Threshold(double value)
5224 : m_opt{ verifyValue(value) }
5225 {}
5226
5231 double value() const;
5232
5234 bool hasValue() const;
5235
5237 void reset();
5238
5240 std::string toString() const;
5241
5243 bool operator==(const Threshold &other) const
5244 {
5245 return m_opt == other.m_opt;
5246 }
5247
5249 bool operator!=(const Threshold &other) const
5250 {
5251 return m_opt != other.m_opt;
5252 }
5253
5255 bool operator<(const Threshold &other) const
5256 {
5257 return m_opt < other.m_opt;
5258 }
5259
5261 bool operator>(const Threshold &other) const
5262 {
5263 return m_opt > other.m_opt;
5264 }
5265
5267 friend std::ostream &operator<<(std::ostream &stream, const Threshold &value)
5268 {
5269 return stream << value.toString();
5270 }
5271
5272 private:
5273 void setFromString(const std::string &value);
5274
5275 constexpr ValueType static verifyValue(const ValueType &value)
5276 {
5277 return validRange().isInRange(value)
5278 ? value
5279 : throw std::out_of_range{ "Threshold{ " + std::to_string(value)
5280 + " } is not in range ["
5281 + std::to_string(validRange().min()) + ", "
5282 + std::to_string(validRange().max()) + "]" };
5283 }
5284
5285 Zivid::DataModel::Detail::Optional<double> m_opt;
5286
5287 friend struct DataModel::Detail::Befriend<Threshold>;
5288 };
5289
5290 using Descendants = std::tuple<Settings::Processing::Filters::Outlier::Removal::Enabled,
5291 Settings::Processing::Filters::Outlier::Removal::Threshold>;
5292
5294 Removal();
5295
5308#ifndef NO_DOC
5309 template<typename... Args,
5310 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
5311 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
5312 Descendants,
5313 typename std::decay<Args>::type...>::value,
5314 int>::type = 0>
5315#else
5316 template<typename... Args>
5317#endif
5318 explicit Removal(Args &&...args)
5319 {
5320 using namespace Zivid::Detail::TypeTraits;
5321
5322 static_assert(AllArgsDecayedAreUnique<Args...>::value,
5323 "Found duplicate types among the arguments passed to Removal(...). "
5324 "Types should be listed at most once.");
5325
5326 set(std::forward<Args>(args)...);
5327 }
5328
5340#ifndef NO_DOC
5341 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
5342#else
5343 template<typename... Args>
5344#endif
5345 void set(Args &&...args)
5346 {
5347 using namespace Zivid::Detail::TypeTraits;
5348
5349 using AllArgsAreDescendantNodes =
5350 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
5351 static_assert(AllArgsAreDescendantNodes::value,
5352 "All arguments passed to set(...) must be descendant nodes.");
5353
5354 static_assert(AllArgsDecayedAreUnique<Args...>::value,
5355 "Found duplicate types among the arguments passed to set(...). "
5356 "Types should be listed at most once.");
5357
5358 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
5359 }
5360
5373#ifndef NO_DOC
5374 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
5375#else
5376 template<typename... Args>
5377#endif
5378 Removal copyWith(Args &&...args) const
5379 {
5380 using namespace Zivid::Detail::TypeTraits;
5381
5382 using AllArgsAreDescendantNodes =
5383 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
5384 static_assert(AllArgsAreDescendantNodes::value,
5385 "All arguments passed to copyWith(...) must be descendant nodes.");
5386
5387 static_assert(AllArgsDecayedAreUnique<Args...>::value,
5388 "Found duplicate types among the arguments passed to copyWith(...). "
5389 "Types should be listed at most once.");
5390
5391 auto copy{ *this };
5392 copy.set(std::forward<Args>(args)...);
5393 return copy;
5394 }
5395
5397 const Enabled &isEnabled() const
5398 {
5399 return m_enabled;
5400 }
5401
5403 Enabled &isEnabled()
5404 {
5405 return m_enabled;
5406 }
5407
5409 Removal &set(const Enabled &value)
5410 {
5411 m_enabled = value;
5412 return *this;
5413 }
5414
5416 const Threshold &threshold() const
5417 {
5418 return m_threshold;
5419 }
5420
5422 Threshold &threshold()
5423 {
5424 return m_threshold;
5425 }
5426
5428 Removal &set(const Threshold &value)
5429 {
5430 m_threshold = value;
5431 return *this;
5432 }
5433
5434 template<typename T,
5435 typename std::enable_if<
5436 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
5437 int>::type = 0>
5438 const Settings::Processing::Filters::Outlier::Removal::Enabled &get() const
5439 {
5440 return m_enabled;
5441 }
5442
5443 template<typename T,
5444 typename std::enable_if<
5445 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
5446 int>::type = 0>
5447 const Settings::Processing::Filters::Outlier::Removal::Threshold &get() const
5448 {
5449 return m_threshold;
5450 }
5451
5452 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
5453 const Settings::Processing::Filters::Outlier::Removal::Enabled &get() const
5454 {
5455 return m_enabled;
5456 }
5457
5458 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
5459 const Settings::Processing::Filters::Outlier::Removal::Threshold &get() const
5460 {
5461 return m_threshold;
5462 }
5463
5465 template<typename F>
5466 void forEach(const F &f) const
5467 {
5468 f(m_enabled);
5469 f(m_threshold);
5470 }
5471
5473 template<typename F>
5474 void forEach(const F &f)
5475 {
5476 f(m_enabled);
5477 f(m_threshold);
5478 }
5479
5481 bool operator==(const Removal &other) const;
5482
5484 bool operator!=(const Removal &other) const;
5485
5487 std::string toString() const;
5488
5490 friend std::ostream &operator<<(std::ostream &stream, const Removal &value)
5491 {
5492 return stream << value.toString();
5493 }
5494
5495 private:
5496 void setFromString(const std::string &value);
5497
5498 void setFromString(const std::string &fullPath, const std::string &value);
5499
5500 std::string getString(const std::string &fullPath) const;
5501
5502 Enabled m_enabled;
5503 Threshold m_threshold;
5504
5505 friend struct DataModel::Detail::Befriend<Removal>;
5506 };
5507
5508 using Descendants = std::tuple<Settings::Processing::Filters::Outlier::Removal,
5509 Settings::Processing::Filters::Outlier::Removal::Enabled,
5510 Settings::Processing::Filters::Outlier::Removal::Threshold>;
5511
5513 Outlier();
5514
5528#ifndef NO_DOC
5529 template<typename... Args,
5530 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
5531 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
5532 Descendants,
5533 typename std::decay<Args>::type...>::value,
5534 int>::type = 0>
5535#else
5536 template<typename... Args>
5537#endif
5538 explicit Outlier(Args &&...args)
5539 {
5540 using namespace Zivid::Detail::TypeTraits;
5541
5542 static_assert(AllArgsDecayedAreUnique<Args...>::value,
5543 "Found duplicate types among the arguments passed to Outlier(...). "
5544 "Types should be listed at most once.");
5545
5546 set(std::forward<Args>(args)...);
5547 }
5548
5561#ifndef NO_DOC
5562 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
5563#else
5564 template<typename... Args>
5565#endif
5566 void set(Args &&...args)
5567 {
5568 using namespace Zivid::Detail::TypeTraits;
5569
5570 using AllArgsAreDescendantNodes =
5571 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
5572 static_assert(AllArgsAreDescendantNodes::value,
5573 "All arguments passed to set(...) must be descendant nodes.");
5574
5575 static_assert(AllArgsDecayedAreUnique<Args...>::value,
5576 "Found duplicate types among the arguments passed to set(...). "
5577 "Types should be listed at most once.");
5578
5579 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
5580 }
5581
5595#ifndef NO_DOC
5596 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
5597#else
5598 template<typename... Args>
5599#endif
5600 Outlier copyWith(Args &&...args) const
5601 {
5602 using namespace Zivid::Detail::TypeTraits;
5603
5604 using AllArgsAreDescendantNodes =
5605 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
5606 static_assert(AllArgsAreDescendantNodes::value,
5607 "All arguments passed to copyWith(...) must be descendant nodes.");
5608
5609 static_assert(AllArgsDecayedAreUnique<Args...>::value,
5610 "Found duplicate types among the arguments passed to copyWith(...). "
5611 "Types should be listed at most once.");
5612
5613 auto copy{ *this };
5614 copy.set(std::forward<Args>(args)...);
5615 return copy;
5616 }
5617
5619 const Removal &removal() const
5620 {
5621 return m_removal;
5622 }
5623
5625 Removal &removal()
5626 {
5627 return m_removal;
5628 }
5629
5631 Outlier &set(const Removal &value)
5632 {
5633 m_removal = value;
5634 return *this;
5635 }
5636
5638 Outlier &set(const Removal::Enabled &value)
5639 {
5640 m_removal.set(value);
5641 return *this;
5642 }
5643
5645 Outlier &set(const Removal::Threshold &value)
5646 {
5647 m_removal.set(value);
5648 return *this;
5649 }
5650
5651 template<
5652 typename T,
5653 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier::Removal>::value,
5654 int>::type = 0>
5655 const Settings::Processing::Filters::Outlier::Removal &get() const
5656 {
5657 return m_removal;
5658 }
5659
5660 template<typename T,
5661 typename std::enable_if<
5662 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
5663 int>::type = 0>
5664 const Settings::Processing::Filters::Outlier::Removal::Enabled &get() const
5665 {
5666 return m_removal.get<Settings::Processing::Filters::Outlier::Removal::Enabled>();
5667 }
5668
5669 template<typename T,
5670 typename std::enable_if<
5671 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
5672 int>::type = 0>
5673 const Settings::Processing::Filters::Outlier::Removal::Threshold &get() const
5674 {
5675 return m_removal.get<Settings::Processing::Filters::Outlier::Removal::Threshold>();
5676 }
5677
5678 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
5679 const Settings::Processing::Filters::Outlier::Removal &get() const
5680 {
5681 return m_removal;
5682 }
5683
5685 template<typename F>
5686 void forEach(const F &f) const
5687 {
5688 f(m_removal);
5689 }
5690
5692 template<typename F>
5693 void forEach(const F &f)
5694 {
5695 f(m_removal);
5696 }
5697
5699 bool operator==(const Outlier &other) const;
5700
5702 bool operator!=(const Outlier &other) const;
5703
5705 std::string toString() const;
5706
5708 friend std::ostream &operator<<(std::ostream &stream, const Outlier &value)
5709 {
5710 return stream << value.toString();
5711 }
5712
5713 private:
5714 void setFromString(const std::string &value);
5715
5716 void setFromString(const std::string &fullPath, const std::string &value);
5717
5718 std::string getString(const std::string &fullPath) const;
5719
5720 Removal m_removal;
5721
5722 friend struct DataModel::Detail::Befriend<Outlier>;
5723 };
5724
5726 class ZIVID_CORE_EXPORT Reflection
5727 {
5728 public:
5730 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
5731
5733 static constexpr const char *path{ "Processing/Filters/Reflection" };
5734
5736 static constexpr const char *name{ "Reflection" };
5737
5739 static constexpr const char *description{
5740 R"description(Contains a filter that removes points likely introduced by reflections (useful for shiny materials))description"
5741 };
5742
5744 class ZIVID_CORE_EXPORT Removal
5745 {
5746 public:
5748 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
5749
5751 static constexpr const char *path{ "Processing/Filters/Reflection/Removal" };
5752
5754 static constexpr const char *name{ "Removal" };
5755
5757 static constexpr const char *description{
5758 R"description(Discard points likely introduced by reflections (useful for shiny materials))description"
5759 };
5760
5762 class ZIVID_CORE_EXPORT Enabled
5763 {
5764 public:
5766 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
5767
5769 static constexpr const char *path{ "Processing/Filters/Reflection/Removal/Enabled" };
5770
5772 static constexpr const char *name{ "Enabled" };
5773
5775 static constexpr const char *description{
5776 R"description(Enable or disable the reflection filter. Note that this filter is computationally intensive and may affect the frame rate)description"
5777 };
5778
5780 using ValueType = bool;
5781 static const Enabled yes;
5782 static const Enabled no;
5783
5785 static std::set<bool> validValues()
5786 {
5787 return { false, true };
5788 }
5789
5791 Enabled() = default;
5792
5794 explicit constexpr Enabled(bool value)
5795 : m_opt{ value }
5796 {}
5797
5802 bool value() const;
5803
5805 bool hasValue() const;
5806
5808 void reset();
5809
5811 std::string toString() const;
5812
5814 bool operator==(const Enabled &other) const
5815 {
5816 return m_opt == other.m_opt;
5817 }
5818
5820 bool operator!=(const Enabled &other) const
5821 {
5822 return m_opt != other.m_opt;
5823 }
5824
5826 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
5827 {
5828 return stream << value.toString();
5829 }
5830
5831 private:
5832 void setFromString(const std::string &value);
5833
5834 Zivid::DataModel::Detail::Optional<bool> m_opt;
5835
5836 friend struct DataModel::Detail::Befriend<Enabled>;
5837 };
5838
5839 using Descendants = std::tuple<Settings::Processing::Filters::Reflection::Removal::Enabled>;
5840
5842 Removal();
5843
5855#ifndef NO_DOC
5856 template<typename... Args,
5857 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
5858 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
5859 Descendants,
5860 typename std::decay<Args>::type...>::value,
5861 int>::type = 0>
5862#else
5863 template<typename... Args>
5864#endif
5865 explicit Removal(Args &&...args)
5866 {
5867 using namespace Zivid::Detail::TypeTraits;
5868
5869 static_assert(AllArgsDecayedAreUnique<Args...>::value,
5870 "Found duplicate types among the arguments passed to Removal(...). "
5871 "Types should be listed at most once.");
5872
5873 set(std::forward<Args>(args)...);
5874 }
5875
5886#ifndef NO_DOC
5887 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
5888#else
5889 template<typename... Args>
5890#endif
5891 void set(Args &&...args)
5892 {
5893 using namespace Zivid::Detail::TypeTraits;
5894
5895 using AllArgsAreDescendantNodes =
5896 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
5897 static_assert(AllArgsAreDescendantNodes::value,
5898 "All arguments passed to set(...) must be descendant nodes.");
5899
5900 static_assert(AllArgsDecayedAreUnique<Args...>::value,
5901 "Found duplicate types among the arguments passed to set(...). "
5902 "Types should be listed at most once.");
5903
5904 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
5905 }
5906
5918#ifndef NO_DOC
5919 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
5920#else
5921 template<typename... Args>
5922#endif
5923 Removal copyWith(Args &&...args) const
5924 {
5925 using namespace Zivid::Detail::TypeTraits;
5926
5927 using AllArgsAreDescendantNodes =
5928 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
5929 static_assert(AllArgsAreDescendantNodes::value,
5930 "All arguments passed to copyWith(...) must be descendant nodes.");
5931
5932 static_assert(AllArgsDecayedAreUnique<Args...>::value,
5933 "Found duplicate types among the arguments passed to copyWith(...). "
5934 "Types should be listed at most once.");
5935
5936 auto copy{ *this };
5937 copy.set(std::forward<Args>(args)...);
5938 return copy;
5939 }
5940
5942 const Enabled &isEnabled() const
5943 {
5944 return m_enabled;
5945 }
5946
5948 Enabled &isEnabled()
5949 {
5950 return m_enabled;
5951 }
5952
5954 Removal &set(const Enabled &value)
5955 {
5956 m_enabled = value;
5957 return *this;
5958 }
5959
5960 template<
5961 typename T,
5962 typename std::enable_if<
5963 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
5964 int>::type = 0>
5965 const Settings::Processing::Filters::Reflection::Removal::Enabled &get() const
5966 {
5967 return m_enabled;
5968 }
5969
5970 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
5971 const Settings::Processing::Filters::Reflection::Removal::Enabled &get() const
5972 {
5973 return m_enabled;
5974 }
5975
5977 template<typename F>
5978 void forEach(const F &f) const
5979 {
5980 f(m_enabled);
5981 }
5982
5984 template<typename F>
5985 void forEach(const F &f)
5986 {
5987 f(m_enabled);
5988 }
5989
5991 bool operator==(const Removal &other) const;
5992
5994 bool operator!=(const Removal &other) const;
5995
5997 std::string toString() const;
5998
6000 friend std::ostream &operator<<(std::ostream &stream, const Removal &value)
6001 {
6002 return stream << value.toString();
6003 }
6004
6005 private:
6006 void setFromString(const std::string &value);
6007
6008 void setFromString(const std::string &fullPath, const std::string &value);
6009
6010 std::string getString(const std::string &fullPath) const;
6011
6012 Enabled m_enabled;
6013
6014 friend struct DataModel::Detail::Befriend<Removal>;
6015 };
6016
6017 using Descendants = std::tuple<Settings::Processing::Filters::Reflection::Removal,
6018 Settings::Processing::Filters::Reflection::Removal::Enabled>;
6019
6021 Reflection();
6022
6035#ifndef NO_DOC
6036 template<typename... Args,
6037 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
6038 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
6039 Descendants,
6040 typename std::decay<Args>::type...>::value,
6041 int>::type = 0>
6042#else
6043 template<typename... Args>
6044#endif
6045 explicit Reflection(Args &&...args)
6046 {
6047 using namespace Zivid::Detail::TypeTraits;
6048
6049 static_assert(AllArgsDecayedAreUnique<Args...>::value,
6050 "Found duplicate types among the arguments passed to Reflection(...). "
6051 "Types should be listed at most once.");
6052
6053 set(std::forward<Args>(args)...);
6054 }
6055
6067#ifndef NO_DOC
6068 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
6069#else
6070 template<typename... Args>
6071#endif
6072 void set(Args &&...args)
6073 {
6074 using namespace Zivid::Detail::TypeTraits;
6075
6076 using AllArgsAreDescendantNodes =
6077 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
6078 static_assert(AllArgsAreDescendantNodes::value,
6079 "All arguments passed to set(...) must be descendant nodes.");
6080
6081 static_assert(AllArgsDecayedAreUnique<Args...>::value,
6082 "Found duplicate types among the arguments passed to set(...). "
6083 "Types should be listed at most once.");
6084
6085 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
6086 }
6087
6100#ifndef NO_DOC
6101 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
6102#else
6103 template<typename... Args>
6104#endif
6105 Reflection copyWith(Args &&...args) const
6106 {
6107 using namespace Zivid::Detail::TypeTraits;
6108
6109 using AllArgsAreDescendantNodes =
6110 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
6111 static_assert(AllArgsAreDescendantNodes::value,
6112 "All arguments passed to copyWith(...) must be descendant nodes.");
6113
6114 static_assert(AllArgsDecayedAreUnique<Args...>::value,
6115 "Found duplicate types among the arguments passed to copyWith(...). "
6116 "Types should be listed at most once.");
6117
6118 auto copy{ *this };
6119 copy.set(std::forward<Args>(args)...);
6120 return copy;
6121 }
6122
6124 const Removal &removal() const
6125 {
6126 return m_removal;
6127 }
6128
6130 Removal &removal()
6131 {
6132 return m_removal;
6133 }
6134
6136 Reflection &set(const Removal &value)
6137 {
6138 m_removal = value;
6139 return *this;
6140 }
6141
6143 Reflection &set(const Removal::Enabled &value)
6144 {
6145 m_removal.set(value);
6146 return *this;
6147 }
6148
6149 template<typename T,
6150 typename std::enable_if<
6151 std::is_same<T, Settings::Processing::Filters::Reflection::Removal>::value,
6152 int>::type = 0>
6153 const Settings::Processing::Filters::Reflection::Removal &get() const
6154 {
6155 return m_removal;
6156 }
6157
6158 template<typename T,
6159 typename std::enable_if<
6160 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
6161 int>::type = 0>
6162 const Settings::Processing::Filters::Reflection::Removal::Enabled &get() const
6163 {
6164 return m_removal.get<Settings::Processing::Filters::Reflection::Removal::Enabled>();
6165 }
6166
6167 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
6168 const Settings::Processing::Filters::Reflection::Removal &get() const
6169 {
6170 return m_removal;
6171 }
6172
6174 template<typename F>
6175 void forEach(const F &f) const
6176 {
6177 f(m_removal);
6178 }
6179
6181 template<typename F>
6182 void forEach(const F &f)
6183 {
6184 f(m_removal);
6185 }
6186
6188 bool operator==(const Reflection &other) const;
6189
6191 bool operator!=(const Reflection &other) const;
6192
6194 std::string toString() const;
6195
6197 friend std::ostream &operator<<(std::ostream &stream, const Reflection &value)
6198 {
6199 return stream << value.toString();
6200 }
6201
6202 private:
6203 void setFromString(const std::string &value);
6204
6205 void setFromString(const std::string &fullPath, const std::string &value);
6206
6207 std::string getString(const std::string &fullPath) const;
6208
6209 Removal m_removal;
6210
6211 friend struct DataModel::Detail::Befriend<Reflection>;
6212 };
6213
6215 class ZIVID_CORE_EXPORT Smoothing
6216 {
6217 public:
6219 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
6220
6222 static constexpr const char *path{ "Processing/Filters/Smoothing" };
6223
6225 static constexpr const char *name{ "Smoothing" };
6226
6228 static constexpr const char *description{ R"description(Smoothing filters)description" };
6229
6231 class ZIVID_CORE_EXPORT Gaussian
6232 {
6233 public:
6235 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
6236
6238 static constexpr const char *path{ "Processing/Filters/Smoothing/Gaussian" };
6239
6241 static constexpr const char *name{ "Gaussian" };
6242
6244 static constexpr const char *description{
6245 R"description(Gaussian smoothing of the point cloud)description"
6246 };
6247
6249 class ZIVID_CORE_EXPORT Enabled
6250 {
6251 public:
6253 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
6254
6256 static constexpr const char *path{ "Processing/Filters/Smoothing/Gaussian/Enabled" };
6257
6259 static constexpr const char *name{ "Enabled" };
6260
6262 static constexpr const char *description{
6263 R"description(Enable or disable the smoothing filter)description"
6264 };
6265
6267 using ValueType = bool;
6268 static const Enabled yes;
6269 static const Enabled no;
6270
6272 static std::set<bool> validValues()
6273 {
6274 return { false, true };
6275 }
6276
6278 Enabled() = default;
6279
6281 explicit constexpr Enabled(bool value)
6282 : m_opt{ value }
6283 {}
6284
6289 bool value() const;
6290
6292 bool hasValue() const;
6293
6295 void reset();
6296
6298 std::string toString() const;
6299
6301 bool operator==(const Enabled &other) const
6302 {
6303 return m_opt == other.m_opt;
6304 }
6305
6307 bool operator!=(const Enabled &other) const
6308 {
6309 return m_opt != other.m_opt;
6310 }
6311
6313 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
6314 {
6315 return stream << value.toString();
6316 }
6317
6318 private:
6319 void setFromString(const std::string &value);
6320
6321 Zivid::DataModel::Detail::Optional<bool> m_opt;
6322
6323 friend struct DataModel::Detail::Befriend<Enabled>;
6324 };
6325
6327 class ZIVID_CORE_EXPORT Sigma
6328 {
6329 public:
6331 static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
6332
6334 static constexpr const char *path{ "Processing/Filters/Smoothing/Gaussian/Sigma" };
6335
6337 static constexpr const char *name{ "Sigma" };
6338
6340 static constexpr const char *description{
6341 R"description(Higher values result in smoother point clouds (Standard deviation of the filter coefficients))description"
6342 };
6343
6345 using ValueType = double;
6346
6348 static constexpr Range<double> validRange()
6349 {
6350 return { 0.5, 5 };
6351 }
6352
6354 Sigma() = default;
6355
6357 explicit constexpr Sigma(double value)
6358 : m_opt{ verifyValue(value) }
6359 {}
6360
6365 double value() const;
6366
6368 bool hasValue() const;
6369
6371 void reset();
6372
6374 std::string toString() const;
6375
6377 bool operator==(const Sigma &other) const
6378 {
6379 return m_opt == other.m_opt;
6380 }
6381
6383 bool operator!=(const Sigma &other) const
6384 {
6385 return m_opt != other.m_opt;
6386 }
6387
6389 bool operator<(const Sigma &other) const
6390 {
6391 return m_opt < other.m_opt;
6392 }
6393
6395 bool operator>(const Sigma &other) const
6396 {
6397 return m_opt > other.m_opt;
6398 }
6399
6401 friend std::ostream &operator<<(std::ostream &stream, const Sigma &value)
6402 {
6403 return stream << value.toString();
6404 }
6405
6406 private:
6407 void setFromString(const std::string &value);
6408
6409 constexpr ValueType static verifyValue(const ValueType &value)
6410 {
6411 return validRange().isInRange(value)
6412 ? value
6413 : throw std::out_of_range{ "Sigma{ " + std::to_string(value)
6414 + " } is not in range ["
6415 + std::to_string(validRange().min()) + ", "
6416 + std::to_string(validRange().max()) + "]" };
6417 }
6418
6419 Zivid::DataModel::Detail::Optional<double> m_opt;
6420
6421 friend struct DataModel::Detail::Befriend<Sigma>;
6422 };
6423
6424 using Descendants = std::tuple<Settings::Processing::Filters::Smoothing::Gaussian::Enabled,
6425 Settings::Processing::Filters::Smoothing::Gaussian::Sigma>;
6426
6428 Gaussian();
6429
6442#ifndef NO_DOC
6443 template<typename... Args,
6444 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
6445 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
6446 Descendants,
6447 typename std::decay<Args>::type...>::value,
6448 int>::type = 0>
6449#else
6450 template<typename... Args>
6451#endif
6452 explicit Gaussian(Args &&...args)
6453 {
6454 using namespace Zivid::Detail::TypeTraits;
6455
6456 static_assert(AllArgsDecayedAreUnique<Args...>::value,
6457 "Found duplicate types among the arguments passed to Gaussian(...). "
6458 "Types should be listed at most once.");
6459
6460 set(std::forward<Args>(args)...);
6461 }
6462
6474#ifndef NO_DOC
6475 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
6476#else
6477 template<typename... Args>
6478#endif
6479 void set(Args &&...args)
6480 {
6481 using namespace Zivid::Detail::TypeTraits;
6482
6483 using AllArgsAreDescendantNodes =
6484 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
6485 static_assert(AllArgsAreDescendantNodes::value,
6486 "All arguments passed to set(...) must be descendant nodes.");
6487
6488 static_assert(AllArgsDecayedAreUnique<Args...>::value,
6489 "Found duplicate types among the arguments passed to set(...). "
6490 "Types should be listed at most once.");
6491
6492 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
6493 }
6494
6507#ifndef NO_DOC
6508 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
6509#else
6510 template<typename... Args>
6511#endif
6512 Gaussian copyWith(Args &&...args) const
6513 {
6514 using namespace Zivid::Detail::TypeTraits;
6515
6516 using AllArgsAreDescendantNodes =
6517 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
6518 static_assert(AllArgsAreDescendantNodes::value,
6519 "All arguments passed to copyWith(...) must be descendant nodes.");
6520
6521 static_assert(AllArgsDecayedAreUnique<Args...>::value,
6522 "Found duplicate types among the arguments passed to copyWith(...). "
6523 "Types should be listed at most once.");
6524
6525 auto copy{ *this };
6526 copy.set(std::forward<Args>(args)...);
6527 return copy;
6528 }
6529
6531 const Enabled &isEnabled() const
6532 {
6533 return m_enabled;
6534 }
6535
6537 Enabled &isEnabled()
6538 {
6539 return m_enabled;
6540 }
6541
6543 Gaussian &set(const Enabled &value)
6544 {
6545 m_enabled = value;
6546 return *this;
6547 }
6548
6550 const Sigma &sigma() const
6551 {
6552 return m_sigma;
6553 }
6554
6556 Sigma &sigma()
6557 {
6558 return m_sigma;
6559 }
6560
6562 Gaussian &set(const Sigma &value)
6563 {
6564 m_sigma = value;
6565 return *this;
6566 }
6567
6568 template<
6569 typename T,
6570 typename std::enable_if<
6571 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
6572 int>::type = 0>
6573 const Settings::Processing::Filters::Smoothing::Gaussian::Enabled &get() const
6574 {
6575 return m_enabled;
6576 }
6577
6578 template<typename T,
6579 typename std::enable_if<
6580 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
6581 int>::type = 0>
6582 const Settings::Processing::Filters::Smoothing::Gaussian::Sigma &get() const
6583 {
6584 return m_sigma;
6585 }
6586
6587 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
6588 const Settings::Processing::Filters::Smoothing::Gaussian::Enabled &get() const
6589 {
6590 return m_enabled;
6591 }
6592
6593 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
6594 const Settings::Processing::Filters::Smoothing::Gaussian::Sigma &get() const
6595 {
6596 return m_sigma;
6597 }
6598
6600 template<typename F>
6601 void forEach(const F &f) const
6602 {
6603 f(m_enabled);
6604 f(m_sigma);
6605 }
6606
6608 template<typename F>
6609 void forEach(const F &f)
6610 {
6611 f(m_enabled);
6612 f(m_sigma);
6613 }
6614
6616 bool operator==(const Gaussian &other) const;
6617
6619 bool operator!=(const Gaussian &other) const;
6620
6622 std::string toString() const;
6623
6625 friend std::ostream &operator<<(std::ostream &stream, const Gaussian &value)
6626 {
6627 return stream << value.toString();
6628 }
6629
6630 private:
6631 void setFromString(const std::string &value);
6632
6633 void setFromString(const std::string &fullPath, const std::string &value);
6634
6635 std::string getString(const std::string &fullPath) const;
6636
6637 Enabled m_enabled;
6638 Sigma m_sigma;
6639
6640 friend struct DataModel::Detail::Befriend<Gaussian>;
6641 };
6642
6643 using Descendants = std::tuple<Settings::Processing::Filters::Smoothing::Gaussian,
6644 Settings::Processing::Filters::Smoothing::Gaussian::Enabled,
6645 Settings::Processing::Filters::Smoothing::Gaussian::Sigma>;
6646
6648 Smoothing();
6649
6663#ifndef NO_DOC
6664 template<typename... Args,
6665 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
6666 typename std::enable_if<Zivid::Detail::TypeTraits::AllArgsAreInTuple<
6667 Descendants,
6668 typename std::decay<Args>::type...>::value,
6669 int>::type = 0>
6670#else
6671 template<typename... Args>
6672#endif
6673 explicit Smoothing(Args &&...args)
6674 {
6675 using namespace Zivid::Detail::TypeTraits;
6676
6677 static_assert(AllArgsDecayedAreUnique<Args...>::value,
6678 "Found duplicate types among the arguments passed to Smoothing(...). "
6679 "Types should be listed at most once.");
6680
6681 set(std::forward<Args>(args)...);
6682 }
6683
6696#ifndef NO_DOC
6697 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
6698#else
6699 template<typename... Args>
6700#endif
6701 void set(Args &&...args)
6702 {
6703 using namespace Zivid::Detail::TypeTraits;
6704
6705 using AllArgsAreDescendantNodes =
6706 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
6707 static_assert(AllArgsAreDescendantNodes::value,
6708 "All arguments passed to set(...) must be descendant nodes.");
6709
6710 static_assert(AllArgsDecayedAreUnique<Args...>::value,
6711 "Found duplicate types among the arguments passed to set(...). "
6712 "Types should be listed at most once.");
6713
6714 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
6715 }
6716
6730#ifndef NO_DOC
6731 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
6732#else
6733 template<typename... Args>
6734#endif
6735 Smoothing copyWith(Args &&...args) const
6736 {
6737 using namespace Zivid::Detail::TypeTraits;
6738
6739 using AllArgsAreDescendantNodes =
6740 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
6741 static_assert(AllArgsAreDescendantNodes::value,
6742 "All arguments passed to copyWith(...) must be descendant nodes.");
6743
6744 static_assert(AllArgsDecayedAreUnique<Args...>::value,
6745 "Found duplicate types among the arguments passed to copyWith(...). "
6746 "Types should be listed at most once.");
6747
6748 auto copy{ *this };
6749 copy.set(std::forward<Args>(args)...);
6750 return copy;
6751 }
6752
6754 const Gaussian &gaussian() const
6755 {
6756 return m_gaussian;
6757 }
6758
6760 Gaussian &gaussian()
6761 {
6762 return m_gaussian;
6763 }
6764
6766 Smoothing &set(const Gaussian &value)
6767 {
6768 m_gaussian = value;
6769 return *this;
6770 }
6771
6773 Smoothing &set(const Gaussian::Enabled &value)
6774 {
6775 m_gaussian.set(value);
6776 return *this;
6777 }
6778
6780 Smoothing &set(const Gaussian::Sigma &value)
6781 {
6782 m_gaussian.set(value);
6783 return *this;
6784 }
6785
6786 template<typename T,
6787 typename std::enable_if<
6788 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian>::value,
6789 int>::type = 0>
6790 const Settings::Processing::Filters::Smoothing::Gaussian &get() const
6791 {
6792 return m_gaussian;
6793 }
6794
6795 template<typename T,
6796 typename std::enable_if<
6797 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
6798 int>::type = 0>
6799 const Settings::Processing::Filters::Smoothing::Gaussian::Enabled &get() const
6800 {
6801 return m_gaussian.get<Settings::Processing::Filters::Smoothing::Gaussian::Enabled>();
6802 }
6803
6804 template<typename T,
6805 typename std::enable_if<
6806 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
6807 int>::type = 0>
6808 const Settings::Processing::Filters::Smoothing::Gaussian::Sigma &get() const
6809 {
6810 return m_gaussian.get<Settings::Processing::Filters::Smoothing::Gaussian::Sigma>();
6811 }
6812
6813 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
6814 const Settings::Processing::Filters::Smoothing::Gaussian &get() const
6815 {
6816 return m_gaussian;
6817 }
6818
6820 template<typename F>
6821 void forEach(const F &f) const
6822 {
6823 f(m_gaussian);
6824 }
6825
6827 template<typename F>
6828 void forEach(const F &f)
6829 {
6830 f(m_gaussian);
6831 }
6832
6834 bool operator==(const Smoothing &other) const;
6835
6837 bool operator!=(const Smoothing &other) const;
6838
6840 std::string toString() const;
6841
6843 friend std::ostream &operator<<(std::ostream &stream, const Smoothing &value)
6844 {
6845 return stream << value.toString();
6846 }
6847
6848 private:
6849 void setFromString(const std::string &value);
6850
6851 void setFromString(const std::string &fullPath, const std::string &value);
6852
6853 std::string getString(const std::string &fullPath) const;
6854
6855 Gaussian m_gaussian;
6856
6857 friend struct DataModel::Detail::Befriend<Smoothing>;
6858 };
6859
6860 using Descendants =
6861 std::tuple<Settings::Processing::Filters::Experimental,
6862 Settings::Processing::Filters::Experimental::ContrastDistortion,
6863 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction,
6864 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled,
6865 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength,
6866 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal,
6867 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled,
6868 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold,
6869 Settings::Processing::Filters::Noise,
6870 Settings::Processing::Filters::Noise::Removal,
6871 Settings::Processing::Filters::Noise::Removal::Enabled,
6872 Settings::Processing::Filters::Noise::Removal::Threshold,
6873 Settings::Processing::Filters::Outlier,
6874 Settings::Processing::Filters::Outlier::Removal,
6875 Settings::Processing::Filters::Outlier::Removal::Enabled,
6876 Settings::Processing::Filters::Outlier::Removal::Threshold,
6877 Settings::Processing::Filters::Reflection,
6878 Settings::Processing::Filters::Reflection::Removal,
6879 Settings::Processing::Filters::Reflection::Removal::Enabled,
6880 Settings::Processing::Filters::Smoothing,
6881 Settings::Processing::Filters::Smoothing::Gaussian,
6882 Settings::Processing::Filters::Smoothing::Gaussian::Enabled,
6883 Settings::Processing::Filters::Smoothing::Gaussian::Sigma>;
6884
6886 Filters();
6887
6921#ifndef NO_DOC
6922 template<typename... Args,
6923 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
6924 typename std::enable_if<
6925 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants,
6926 typename std::decay<Args>::type...>::value,
6927 int>::type = 0>
6928#else
6929 template<typename... Args>
6930#endif
6931 explicit Filters(Args &&...args)
6932 {
6933 using namespace Zivid::Detail::TypeTraits;
6934
6935 static_assert(AllArgsDecayedAreUnique<Args...>::value,
6936 "Found duplicate types among the arguments passed to Filters(...). "
6937 "Types should be listed at most once.");
6938
6939 set(std::forward<Args>(args)...);
6940 }
6941
6974#ifndef NO_DOC
6975 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
6976#else
6977 template<typename... Args>
6978#endif
6979 void set(Args &&...args)
6980 {
6981 using namespace Zivid::Detail::TypeTraits;
6982
6983 using AllArgsAreDescendantNodes =
6984 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
6985 static_assert(AllArgsAreDescendantNodes::value,
6986 "All arguments passed to set(...) must be descendant nodes.");
6987
6988 static_assert(AllArgsDecayedAreUnique<Args...>::value,
6989 "Found duplicate types among the arguments passed to set(...). "
6990 "Types should be listed at most once.");
6991
6992 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
6993 }
6994
7028#ifndef NO_DOC
7029 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
7030#else
7031 template<typename... Args>
7032#endif
7033 Filters copyWith(Args &&...args) const
7034 {
7035 using namespace Zivid::Detail::TypeTraits;
7036
7037 using AllArgsAreDescendantNodes =
7038 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
7039 static_assert(AllArgsAreDescendantNodes::value,
7040 "All arguments passed to copyWith(...) must be descendant nodes.");
7041
7042 static_assert(AllArgsDecayedAreUnique<Args...>::value,
7043 "Found duplicate types among the arguments passed to copyWith(...). "
7044 "Types should be listed at most once.");
7045
7046 auto copy{ *this };
7047 copy.set(std::forward<Args>(args)...);
7048 return copy;
7049 }
7050
7052 const Experimental &experimental() const
7053 {
7054 return m_experimental;
7055 }
7056
7058 Experimental &experimental()
7059 {
7060 return m_experimental;
7061 }
7062
7064 Filters &set(const Experimental &value)
7065 {
7066 m_experimental = value;
7067 return *this;
7068 }
7069
7071 Filters &set(const Experimental::ContrastDistortion &value)
7072 {
7073 m_experimental.set(value);
7074 return *this;
7075 }
7076
7078 Filters &set(const Experimental::ContrastDistortion::Correction &value)
7079 {
7080 m_experimental.set(value);
7081 return *this;
7082 }
7083
7085 Filters &set(const Experimental::ContrastDistortion::Correction::Enabled &value)
7086 {
7087 m_experimental.set(value);
7088 return *this;
7089 }
7090
7092 Filters &set(const Experimental::ContrastDistortion::Correction::Strength &value)
7093 {
7094 m_experimental.set(value);
7095 return *this;
7096 }
7097
7099 Filters &set(const Experimental::ContrastDistortion::Removal &value)
7100 {
7101 m_experimental.set(value);
7102 return *this;
7103 }
7104
7106 Filters &set(const Experimental::ContrastDistortion::Removal::Enabled &value)
7107 {
7108 m_experimental.set(value);
7109 return *this;
7110 }
7111
7113 Filters &set(const Experimental::ContrastDistortion::Removal::Threshold &value)
7114 {
7115 m_experimental.set(value);
7116 return *this;
7117 }
7118
7120 const Noise &noise() const
7121 {
7122 return m_noise;
7123 }
7124
7126 Noise &noise()
7127 {
7128 return m_noise;
7129 }
7130
7132 Filters &set(const Noise &value)
7133 {
7134 m_noise = value;
7135 return *this;
7136 }
7137
7139 Filters &set(const Noise::Removal &value)
7140 {
7141 m_noise.set(value);
7142 return *this;
7143 }
7144
7146 Filters &set(const Noise::Removal::Enabled &value)
7147 {
7148 m_noise.set(value);
7149 return *this;
7150 }
7151
7153 Filters &set(const Noise::Removal::Threshold &value)
7154 {
7155 m_noise.set(value);
7156 return *this;
7157 }
7158
7160 const Outlier &outlier() const
7161 {
7162 return m_outlier;
7163 }
7164
7166 Outlier &outlier()
7167 {
7168 return m_outlier;
7169 }
7170
7172 Filters &set(const Outlier &value)
7173 {
7174 m_outlier = value;
7175 return *this;
7176 }
7177
7179 Filters &set(const Outlier::Removal &value)
7180 {
7181 m_outlier.set(value);
7182 return *this;
7183 }
7184
7186 Filters &set(const Outlier::Removal::Enabled &value)
7187 {
7188 m_outlier.set(value);
7189 return *this;
7190 }
7191
7193 Filters &set(const Outlier::Removal::Threshold &value)
7194 {
7195 m_outlier.set(value);
7196 return *this;
7197 }
7198
7200 const Reflection &reflection() const
7201 {
7202 return m_reflection;
7203 }
7204
7206 Reflection &reflection()
7207 {
7208 return m_reflection;
7209 }
7210
7212 Filters &set(const Reflection &value)
7213 {
7214 m_reflection = value;
7215 return *this;
7216 }
7217
7219 Filters &set(const Reflection::Removal &value)
7220 {
7221 m_reflection.set(value);
7222 return *this;
7223 }
7224
7226 Filters &set(const Reflection::Removal::Enabled &value)
7227 {
7228 m_reflection.set(value);
7229 return *this;
7230 }
7231
7233 const Smoothing &smoothing() const
7234 {
7235 return m_smoothing;
7236 }
7237
7239 Smoothing &smoothing()
7240 {
7241 return m_smoothing;
7242 }
7243
7245 Filters &set(const Smoothing &value)
7246 {
7247 m_smoothing = value;
7248 return *this;
7249 }
7250
7252 Filters &set(const Smoothing::Gaussian &value)
7253 {
7254 m_smoothing.set(value);
7255 return *this;
7256 }
7257
7259 Filters &set(const Smoothing::Gaussian::Enabled &value)
7260 {
7261 m_smoothing.set(value);
7262 return *this;
7263 }
7264
7266 Filters &set(const Smoothing::Gaussian::Sigma &value)
7267 {
7268 m_smoothing.set(value);
7269 return *this;
7270 }
7271
7272 template<typename T,
7273 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Experimental>::value,
7274 int>::type = 0>
7275 const Settings::Processing::Filters::Experimental &get() const
7276 {
7277 return m_experimental;
7278 }
7279
7280 template<typename T,
7281 typename std::enable_if<
7282 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
7283 int>::type = 0>
7284 const Settings::Processing::Filters::Experimental::ContrastDistortion &get() const
7285 {
7286 return m_experimental.get<Settings::Processing::Filters::Experimental::ContrastDistortion>();
7287 }
7288
7289 template<
7290 typename T,
7291 typename std::enable_if<
7292 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::
7293 value,
7294 int>::type = 0>
7295 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction &get() const
7296 {
7297 return m_experimental
7298 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>();
7299 }
7300
7301 template<typename T,
7302 typename std::enable_if<std::is_same<T,
7303 Settings::Processing::Filters::Experimental::
7304 ContrastDistortion::Correction::Enabled>::value,
7305 int>::type = 0>
7306 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &get() const
7307 {
7308 return m_experimental
7309 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>();
7310 }
7311
7312 template<typename T,
7313 typename std::enable_if<std::is_same<T,
7314 Settings::Processing::Filters::Experimental::
7315 ContrastDistortion::Correction::Strength>::value,
7316 int>::type = 0>
7317 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &get() const
7318 {
7319 return m_experimental
7320 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>();
7321 }
7322
7323 template<typename T,
7324 typename std::enable_if<
7325 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::
7326 value,
7327 int>::type = 0>
7328 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal &get() const
7329 {
7330 return m_experimental
7331 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>();
7332 }
7333
7334 template<typename T,
7335 typename std::enable_if<std::is_same<T,
7336 Settings::Processing::Filters::Experimental::
7337 ContrastDistortion::Removal::Enabled>::value,
7338 int>::type = 0>
7339 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &get() const
7340 {
7341 return m_experimental
7342 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>();
7343 }
7344
7345 template<typename T,
7346 typename std::enable_if<std::is_same<T,
7347 Settings::Processing::Filters::Experimental::
7348 ContrastDistortion::Removal::Threshold>::value,
7349 int>::type = 0>
7350 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &get() const
7351 {
7352 return m_experimental
7353 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>();
7354 }
7355
7356 template<typename T,
7357 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise>::value,
7358 int>::type = 0>
7359 const Settings::Processing::Filters::Noise &get() const
7360 {
7361 return m_noise;
7362 }
7363
7364 template<typename T,
7365 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Removal>::value,
7366 int>::type = 0>
7367 const Settings::Processing::Filters::Noise::Removal &get() const
7368 {
7369 return m_noise.get<Settings::Processing::Filters::Noise::Removal>();
7370 }
7371
7372 template<typename T,
7373 typename std::enable_if<
7374 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
7375 int>::type = 0>
7376 const Settings::Processing::Filters::Noise::Removal::Enabled &get() const
7377 {
7378 return m_noise.get<Settings::Processing::Filters::Noise::Removal::Enabled>();
7379 }
7380
7381 template<typename T,
7382 typename std::enable_if<
7383 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
7384 int>::type = 0>
7385 const Settings::Processing::Filters::Noise::Removal::Threshold &get() const
7386 {
7387 return m_noise.get<Settings::Processing::Filters::Noise::Removal::Threshold>();
7388 }
7389
7390 template<typename T,
7391 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier>::value,
7392 int>::type = 0>
7393 const Settings::Processing::Filters::Outlier &get() const
7394 {
7395 return m_outlier;
7396 }
7397
7398 template<
7399 typename T,
7400 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier::Removal>::value,
7401 int>::type = 0>
7402 const Settings::Processing::Filters::Outlier::Removal &get() const
7403 {
7404 return m_outlier.get<Settings::Processing::Filters::Outlier::Removal>();
7405 }
7406
7407 template<typename T,
7408 typename std::enable_if<
7409 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
7410 int>::type = 0>
7411 const Settings::Processing::Filters::Outlier::Removal::Enabled &get() const
7412 {
7413 return m_outlier.get<Settings::Processing::Filters::Outlier::Removal::Enabled>();
7414 }
7415
7416 template<typename T,
7417 typename std::enable_if<
7418 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
7419 int>::type = 0>
7420 const Settings::Processing::Filters::Outlier::Removal::Threshold &get() const
7421 {
7422 return m_outlier.get<Settings::Processing::Filters::Outlier::Removal::Threshold>();
7423 }
7424
7425 template<typename T,
7426 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection>::value,
7427 int>::type = 0>
7428 const Settings::Processing::Filters::Reflection &get() const
7429 {
7430 return m_reflection;
7431 }
7432
7433 template<
7434 typename T,
7435 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection::Removal>::value,
7436 int>::type = 0>
7437 const Settings::Processing::Filters::Reflection::Removal &get() const
7438 {
7439 return m_reflection.get<Settings::Processing::Filters::Reflection::Removal>();
7440 }
7441
7442 template<typename T,
7443 typename std::enable_if<
7444 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
7445 int>::type = 0>
7446 const Settings::Processing::Filters::Reflection::Removal::Enabled &get() const
7447 {
7448 return m_reflection.get<Settings::Processing::Filters::Reflection::Removal::Enabled>();
7449 }
7450
7451 template<typename T,
7452 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing>::value,
7453 int>::type = 0>
7454 const Settings::Processing::Filters::Smoothing &get() const
7455 {
7456 return m_smoothing;
7457 }
7458
7459 template<
7460 typename T,
7461 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian>::value,
7462 int>::type = 0>
7463 const Settings::Processing::Filters::Smoothing::Gaussian &get() const
7464 {
7465 return m_smoothing.get<Settings::Processing::Filters::Smoothing::Gaussian>();
7466 }
7467
7468 template<typename T,
7469 typename std::enable_if<
7470 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
7471 int>::type = 0>
7472 const Settings::Processing::Filters::Smoothing::Gaussian::Enabled &get() const
7473 {
7474 return m_smoothing.get<Settings::Processing::Filters::Smoothing::Gaussian::Enabled>();
7475 }
7476
7477 template<typename T,
7478 typename std::enable_if<
7479 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
7480 int>::type = 0>
7481 const Settings::Processing::Filters::Smoothing::Gaussian::Sigma &get() const
7482 {
7483 return m_smoothing.get<Settings::Processing::Filters::Smoothing::Gaussian::Sigma>();
7484 }
7485
7486 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
7487 const Settings::Processing::Filters::Experimental &get() const
7488 {
7489 return m_experimental;
7490 }
7491
7492 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
7493 const Settings::Processing::Filters::Noise &get() const
7494 {
7495 return m_noise;
7496 }
7497
7498 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
7499 const Settings::Processing::Filters::Outlier &get() const
7500 {
7501 return m_outlier;
7502 }
7503
7504 template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
7505 const Settings::Processing::Filters::Reflection &get() const
7506 {
7507 return m_reflection;
7508 }
7509
7510 template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
7511 const Settings::Processing::Filters::Smoothing &get() const
7512 {
7513 return m_smoothing;
7514 }
7515
7517 template<typename F>
7518 void forEach(const F &f) const
7519 {
7520 f(m_experimental);
7521 f(m_noise);
7522 f(m_outlier);
7523 f(m_reflection);
7524 f(m_smoothing);
7525 }
7526
7528 template<typename F>
7529 void forEach(const F &f)
7530 {
7531 f(m_experimental);
7532 f(m_noise);
7533 f(m_outlier);
7534 f(m_reflection);
7535 f(m_smoothing);
7536 }
7537
7539 bool operator==(const Filters &other) const;
7540
7542 bool operator!=(const Filters &other) const;
7543
7545 std::string toString() const;
7546
7548 friend std::ostream &operator<<(std::ostream &stream, const Filters &value)
7549 {
7550 return stream << value.toString();
7551 }
7552
7553 private:
7554 void setFromString(const std::string &value);
7555
7556 void setFromString(const std::string &fullPath, const std::string &value);
7557
7558 std::string getString(const std::string &fullPath) const;
7559
7560 Experimental m_experimental;
7561 Noise m_noise;
7562 Outlier m_outlier;
7563 Reflection m_reflection;
7564 Smoothing m_smoothing;
7565
7566 friend struct DataModel::Detail::Befriend<Filters>;
7567 };
7568
7569 using Descendants =
7570 std::tuple<Settings::Processing::Color,
7571 Settings::Processing::Color::Balance,
7572 Settings::Processing::Color::Balance::Blue,
7573 Settings::Processing::Color::Balance::Green,
7574 Settings::Processing::Color::Balance::Red,
7575 Settings::Processing::Color::Experimental,
7576 Settings::Processing::Color::Experimental::ToneMapping,
7577 Settings::Processing::Color::Experimental::ToneMapping::Enabled,
7578 Settings::Processing::Color::Gamma,
7579 Settings::Processing::Filters,
7580 Settings::Processing::Filters::Experimental,
7581 Settings::Processing::Filters::Experimental::ContrastDistortion,
7582 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction,
7583 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled,
7584 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength,
7585 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal,
7586 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled,
7587 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold,
7588 Settings::Processing::Filters::Noise,
7589 Settings::Processing::Filters::Noise::Removal,
7590 Settings::Processing::Filters::Noise::Removal::Enabled,
7591 Settings::Processing::Filters::Noise::Removal::Threshold,
7592 Settings::Processing::Filters::Outlier,
7593 Settings::Processing::Filters::Outlier::Removal,
7594 Settings::Processing::Filters::Outlier::Removal::Enabled,
7595 Settings::Processing::Filters::Outlier::Removal::Threshold,
7596 Settings::Processing::Filters::Reflection,
7597 Settings::Processing::Filters::Reflection::Removal,
7598 Settings::Processing::Filters::Reflection::Removal::Enabled,
7599 Settings::Processing::Filters::Smoothing,
7600 Settings::Processing::Filters::Smoothing::Gaussian,
7601 Settings::Processing::Filters::Smoothing::Gaussian::Enabled,
7602 Settings::Processing::Filters::Smoothing::Gaussian::Sigma>;
7603
7605 Processing();
7606
7650#ifndef NO_DOC
7651 template<typename... Args,
7652 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
7653 typename std::enable_if<
7654 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants,
7655 typename std::decay<Args>::type...>::value,
7656 int>::type = 0>
7657#else
7658 template<typename... Args>
7659#endif
7660 explicit Processing(Args &&...args)
7661 {
7662 using namespace Zivid::Detail::TypeTraits;
7663
7664 static_assert(AllArgsDecayedAreUnique<Args...>::value,
7665 "Found duplicate types among the arguments passed to Processing(...). "
7666 "Types should be listed at most once.");
7667
7668 set(std::forward<Args>(args)...);
7669 }
7670
7713#ifndef NO_DOC
7714 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
7715#else
7716 template<typename... Args>
7717#endif
7718 void set(Args &&...args)
7719 {
7720 using namespace Zivid::Detail::TypeTraits;
7721
7722 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
7723 static_assert(AllArgsAreDescendantNodes::value,
7724 "All arguments passed to set(...) must be descendant nodes.");
7725
7726 static_assert(AllArgsDecayedAreUnique<Args...>::value,
7727 "Found duplicate types among the arguments passed to set(...). "
7728 "Types should be listed at most once.");
7729
7730 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
7731 }
7732
7776#ifndef NO_DOC
7777 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
7778#else
7779 template<typename... Args>
7780#endif
7781 Processing copyWith(Args &&...args) const
7782 {
7783 using namespace Zivid::Detail::TypeTraits;
7784
7785 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
7786 static_assert(AllArgsAreDescendantNodes::value,
7787 "All arguments passed to copyWith(...) must be descendant nodes.");
7788
7789 static_assert(AllArgsDecayedAreUnique<Args...>::value,
7790 "Found duplicate types among the arguments passed to copyWith(...). "
7791 "Types should be listed at most once.");
7792
7793 auto copy{ *this };
7794 copy.set(std::forward<Args>(args)...);
7795 return copy;
7796 }
7797
7799 const Color &color() const
7800 {
7801 return m_color;
7802 }
7803
7805 Color &color()
7806 {
7807 return m_color;
7808 }
7809
7811 Processing &set(const Color &value)
7812 {
7813 m_color = value;
7814 return *this;
7815 }
7816
7818 Processing &set(const Color::Balance &value)
7819 {
7820 m_color.set(value);
7821 return *this;
7822 }
7823
7825 Processing &set(const Color::Balance::Blue &value)
7826 {
7827 m_color.set(value);
7828 return *this;
7829 }
7830
7832 Processing &set(const Color::Balance::Green &value)
7833 {
7834 m_color.set(value);
7835 return *this;
7836 }
7837
7839 Processing &set(const Color::Balance::Red &value)
7840 {
7841 m_color.set(value);
7842 return *this;
7843 }
7844
7846 Processing &set(const Color::Experimental &value)
7847 {
7848 m_color.set(value);
7849 return *this;
7850 }
7851
7853 Processing &set(const Color::Experimental::ToneMapping &value)
7854 {
7855 m_color.set(value);
7856 return *this;
7857 }
7858
7860 Processing &set(const Color::Experimental::ToneMapping::Enabled &value)
7861 {
7862 m_color.set(value);
7863 return *this;
7864 }
7865
7867 Processing &set(const Color::Gamma &value)
7868 {
7869 m_color.set(value);
7870 return *this;
7871 }
7872
7874 const Filters &filters() const
7875 {
7876 return m_filters;
7877 }
7878
7880 Filters &filters()
7881 {
7882 return m_filters;
7883 }
7884
7886 Processing &set(const Filters &value)
7887 {
7888 m_filters = value;
7889 return *this;
7890 }
7891
7893 Processing &set(const Filters::Experimental &value)
7894 {
7895 m_filters.set(value);
7896 return *this;
7897 }
7898
7900 Processing &set(const Filters::Experimental::ContrastDistortion &value)
7901 {
7902 m_filters.set(value);
7903 return *this;
7904 }
7905
7907 Processing &set(const Filters::Experimental::ContrastDistortion::Correction &value)
7908 {
7909 m_filters.set(value);
7910 return *this;
7911 }
7912
7914 Processing &set(const Filters::Experimental::ContrastDistortion::Correction::Enabled &value)
7915 {
7916 m_filters.set(value);
7917 return *this;
7918 }
7919
7921 Processing &set(const Filters::Experimental::ContrastDistortion::Correction::Strength &value)
7922 {
7923 m_filters.set(value);
7924 return *this;
7925 }
7926
7928 Processing &set(const Filters::Experimental::ContrastDistortion::Removal &value)
7929 {
7930 m_filters.set(value);
7931 return *this;
7932 }
7933
7935 Processing &set(const Filters::Experimental::ContrastDistortion::Removal::Enabled &value)
7936 {
7937 m_filters.set(value);
7938 return *this;
7939 }
7940
7942 Processing &set(const Filters::Experimental::ContrastDistortion::Removal::Threshold &value)
7943 {
7944 m_filters.set(value);
7945 return *this;
7946 }
7947
7949 Processing &set(const Filters::Noise &value)
7950 {
7951 m_filters.set(value);
7952 return *this;
7953 }
7954
7956 Processing &set(const Filters::Noise::Removal &value)
7957 {
7958 m_filters.set(value);
7959 return *this;
7960 }
7961
7963 Processing &set(const Filters::Noise::Removal::Enabled &value)
7964 {
7965 m_filters.set(value);
7966 return *this;
7967 }
7968
7970 Processing &set(const Filters::Noise::Removal::Threshold &value)
7971 {
7972 m_filters.set(value);
7973 return *this;
7974 }
7975
7977 Processing &set(const Filters::Outlier &value)
7978 {
7979 m_filters.set(value);
7980 return *this;
7981 }
7982
7984 Processing &set(const Filters::Outlier::Removal &value)
7985 {
7986 m_filters.set(value);
7987 return *this;
7988 }
7989
7991 Processing &set(const Filters::Outlier::Removal::Enabled &value)
7992 {
7993 m_filters.set(value);
7994 return *this;
7995 }
7996
7998 Processing &set(const Filters::Outlier::Removal::Threshold &value)
7999 {
8000 m_filters.set(value);
8001 return *this;
8002 }
8003
8005 Processing &set(const Filters::Reflection &value)
8006 {
8007 m_filters.set(value);
8008 return *this;
8009 }
8010
8012 Processing &set(const Filters::Reflection::Removal &value)
8013 {
8014 m_filters.set(value);
8015 return *this;
8016 }
8017
8019 Processing &set(const Filters::Reflection::Removal::Enabled &value)
8020 {
8021 m_filters.set(value);
8022 return *this;
8023 }
8024
8026 Processing &set(const Filters::Smoothing &value)
8027 {
8028 m_filters.set(value);
8029 return *this;
8030 }
8031
8033 Processing &set(const Filters::Smoothing::Gaussian &value)
8034 {
8035 m_filters.set(value);
8036 return *this;
8037 }
8038
8040 Processing &set(const Filters::Smoothing::Gaussian::Enabled &value)
8041 {
8042 m_filters.set(value);
8043 return *this;
8044 }
8045
8047 Processing &set(const Filters::Smoothing::Gaussian::Sigma &value)
8048 {
8049 m_filters.set(value);
8050 return *this;
8051 }
8052
8053 template<typename T,
8054 typename std::enable_if<std::is_same<T, Settings::Processing::Color>::value, int>::type = 0>
8055 const Settings::Processing::Color &get() const
8056 {
8057 return m_color;
8058 }
8059
8060 template<
8061 typename T,
8062 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance>::value, int>::type = 0>
8063 const Settings::Processing::Color::Balance &get() const
8064 {
8065 return m_color.get<Settings::Processing::Color::Balance>();
8066 }
8067
8068 template<typename T,
8069 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Blue>::value,
8070 int>::type = 0>
8071 const Settings::Processing::Color::Balance::Blue &get() const
8072 {
8073 return m_color.get<Settings::Processing::Color::Balance::Blue>();
8074 }
8075
8076 template<typename T,
8077 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Green>::value,
8078 int>::type = 0>
8079 const Settings::Processing::Color::Balance::Green &get() const
8080 {
8081 return m_color.get<Settings::Processing::Color::Balance::Green>();
8082 }
8083
8084 template<typename T,
8085 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Red>::value,
8086 int>::type = 0>
8087 const Settings::Processing::Color::Balance::Red &get() const
8088 {
8089 return m_color.get<Settings::Processing::Color::Balance::Red>();
8090 }
8091
8092 template<typename T,
8093 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental>::value,
8094 int>::type = 0>
8095 const Settings::Processing::Color::Experimental &get() const
8096 {
8097 return m_color.get<Settings::Processing::Color::Experimental>();
8098 }
8099
8100 template<
8101 typename T,
8102 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental::ToneMapping>::value,
8103 int>::type = 0>
8104 const Settings::Processing::Color::Experimental::ToneMapping &get() const
8105 {
8106 return m_color.get<Settings::Processing::Color::Experimental::ToneMapping>();
8107 }
8108
8109 template<typename T,
8110 typename std::enable_if<
8111 std::is_same<T, Settings::Processing::Color::Experimental::ToneMapping::Enabled>::value,
8112 int>::type = 0>
8113 const Settings::Processing::Color::Experimental::ToneMapping::Enabled &get() const
8114 {
8115 return m_color.get<Settings::Processing::Color::Experimental::ToneMapping::Enabled>();
8116 }
8117
8118 template<typename T,
8119 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Gamma>::value, int>::type = 0>
8120 const Settings::Processing::Color::Gamma &get() const
8121 {
8122 return m_color.get<Settings::Processing::Color::Gamma>();
8123 }
8124
8125 template<typename T,
8126 typename std::enable_if<std::is_same<T, Settings::Processing::Filters>::value, int>::type = 0>
8127 const Settings::Processing::Filters &get() const
8128 {
8129 return m_filters;
8130 }
8131
8132 template<typename T,
8133 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Experimental>::value,
8134 int>::type = 0>
8135 const Settings::Processing::Filters::Experimental &get() const
8136 {
8137 return m_filters.get<Settings::Processing::Filters::Experimental>();
8138 }
8139
8140 template<typename T,
8141 typename std::enable_if<
8142 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
8143 int>::type = 0>
8144 const Settings::Processing::Filters::Experimental::ContrastDistortion &get() const
8145 {
8146 return m_filters.get<Settings::Processing::Filters::Experimental::ContrastDistortion>();
8147 }
8148
8149 template<
8150 typename T,
8151 typename std::enable_if<
8152 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::value,
8153 int>::type = 0>
8154 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction &get() const
8155 {
8156 return m_filters.get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>();
8157 }
8158
8159 template<typename T,
8160 typename std::enable_if<std::is_same<T,
8161 Settings::Processing::Filters::Experimental::
8162 ContrastDistortion::Correction::Enabled>::value,
8163 int>::type = 0>
8164 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &get() const
8165 {
8166 return m_filters
8167 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>();
8168 }
8169
8170 template<typename T,
8171 typename std::enable_if<std::is_same<T,
8172 Settings::Processing::Filters::Experimental::
8173 ContrastDistortion::Correction::Strength>::value,
8174 int>::type = 0>
8175 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &get() const
8176 {
8177 return m_filters
8178 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>();
8179 }
8180
8181 template<
8182 typename T,
8183 typename std::enable_if<
8184 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::value,
8185 int>::type = 0>
8186 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal &get() const
8187 {
8188 return m_filters.get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>();
8189 }
8190
8191 template<
8192 typename T,
8193 typename std::enable_if<
8194 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>::
8195 value,
8196 int>::type = 0>
8197 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &get() const
8198 {
8199 return m_filters
8200 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>();
8201 }
8202
8203 template<typename T,
8204 typename std::enable_if<std::is_same<T,
8205 Settings::Processing::Filters::Experimental::
8206 ContrastDistortion::Removal::Threshold>::value,
8207 int>::type = 0>
8208 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &get() const
8209 {
8210 return m_filters
8211 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>();
8212 }
8213
8214 template<
8215 typename T,
8216 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise>::value, int>::type = 0>
8217 const Settings::Processing::Filters::Noise &get() const
8218 {
8219 return m_filters.get<Settings::Processing::Filters::Noise>();
8220 }
8221
8222 template<typename T,
8223 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Removal>::value,
8224 int>::type = 0>
8225 const Settings::Processing::Filters::Noise::Removal &get() const
8226 {
8227 return m_filters.get<Settings::Processing::Filters::Noise::Removal>();
8228 }
8229
8230 template<
8231 typename T,
8232 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
8233 int>::type = 0>
8234 const Settings::Processing::Filters::Noise::Removal::Enabled &get() const
8235 {
8236 return m_filters.get<Settings::Processing::Filters::Noise::Removal::Enabled>();
8237 }
8238
8239 template<typename T,
8240 typename std::enable_if<
8241 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
8242 int>::type = 0>
8243 const Settings::Processing::Filters::Noise::Removal::Threshold &get() const
8244 {
8245 return m_filters.get<Settings::Processing::Filters::Noise::Removal::Threshold>();
8246 }
8247
8248 template<
8249 typename T,
8250 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier>::value, int>::type = 0>
8251 const Settings::Processing::Filters::Outlier &get() const
8252 {
8253 return m_filters.get<Settings::Processing::Filters::Outlier>();
8254 }
8255
8256 template<typename T,
8257 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier::Removal>::value,
8258 int>::type = 0>
8259 const Settings::Processing::Filters::Outlier::Removal &get() const
8260 {
8261 return m_filters.get<Settings::Processing::Filters::Outlier::Removal>();
8262 }
8263
8264 template<typename T,
8265 typename std::enable_if<
8266 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
8267 int>::type = 0>
8268 const Settings::Processing::Filters::Outlier::Removal::Enabled &get() const
8269 {
8270 return m_filters.get<Settings::Processing::Filters::Outlier::Removal::Enabled>();
8271 }
8272
8273 template<typename T,
8274 typename std::enable_if<
8275 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
8276 int>::type = 0>
8277 const Settings::Processing::Filters::Outlier::Removal::Threshold &get() const
8278 {
8279 return m_filters.get<Settings::Processing::Filters::Outlier::Removal::Threshold>();
8280 }
8281
8282 template<typename T,
8283 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection>::value,
8284 int>::type = 0>
8285 const Settings::Processing::Filters::Reflection &get() const
8286 {
8287 return m_filters.get<Settings::Processing::Filters::Reflection>();
8288 }
8289
8290 template<typename T,
8291 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection::Removal>::value,
8292 int>::type = 0>
8293 const Settings::Processing::Filters::Reflection::Removal &get() const
8294 {
8295 return m_filters.get<Settings::Processing::Filters::Reflection::Removal>();
8296 }
8297
8298 template<typename T,
8299 typename std::enable_if<
8300 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
8301 int>::type = 0>
8302 const Settings::Processing::Filters::Reflection::Removal::Enabled &get() const
8303 {
8304 return m_filters.get<Settings::Processing::Filters::Reflection::Removal::Enabled>();
8305 }
8306
8307 template<typename T,
8308 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing>::value,
8309 int>::type = 0>
8310 const Settings::Processing::Filters::Smoothing &get() const
8311 {
8312 return m_filters.get<Settings::Processing::Filters::Smoothing>();
8313 }
8314
8315 template<typename T,
8316 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian>::value,
8317 int>::type = 0>
8318 const Settings::Processing::Filters::Smoothing::Gaussian &get() const
8319 {
8320 return m_filters.get<Settings::Processing::Filters::Smoothing::Gaussian>();
8321 }
8322
8323 template<typename T,
8324 typename std::enable_if<
8325 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
8326 int>::type = 0>
8327 const Settings::Processing::Filters::Smoothing::Gaussian::Enabled &get() const
8328 {
8329 return m_filters.get<Settings::Processing::Filters::Smoothing::Gaussian::Enabled>();
8330 }
8331
8332 template<typename T,
8333 typename std::enable_if<
8334 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
8335 int>::type = 0>
8336 const Settings::Processing::Filters::Smoothing::Gaussian::Sigma &get() const
8337 {
8338 return m_filters.get<Settings::Processing::Filters::Smoothing::Gaussian::Sigma>();
8339 }
8340
8341 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
8342 const Settings::Processing::Color &get() const
8343 {
8344 return m_color;
8345 }
8346
8347 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
8348 const Settings::Processing::Filters &get() const
8349 {
8350 return m_filters;
8351 }
8352
8354 template<typename F>
8355 void forEach(const F &f) const
8356 {
8357 f(m_color);
8358 f(m_filters);
8359 }
8360
8362 template<typename F>
8363 void forEach(const F &f)
8364 {
8365 f(m_color);
8366 f(m_filters);
8367 }
8368
8370 bool operator==(const Processing &other) const;
8371
8373 bool operator!=(const Processing &other) const;
8374
8376 std::string toString() const;
8377
8379 friend std::ostream &operator<<(std::ostream &stream, const Processing &value)
8380 {
8381 return stream << value.toString();
8382 }
8383
8384 private:
8385 void setFromString(const std::string &value);
8386
8387 void setFromString(const std::string &fullPath, const std::string &value);
8388
8389 std::string getString(const std::string &fullPath) const;
8390
8391 Color m_color;
8392 Filters m_filters;
8393
8394 friend struct DataModel::Detail::Befriend<Processing>;
8395 };
8396
8397 using Descendants =
8398 std::tuple<Settings::Acquisitions,
8399 Settings::Experimental,
8400 Settings::Experimental::Engine,
8401 Settings::Processing,
8402 Settings::Processing::Color,
8403 Settings::Processing::Color::Balance,
8404 Settings::Processing::Color::Balance::Blue,
8405 Settings::Processing::Color::Balance::Green,
8406 Settings::Processing::Color::Balance::Red,
8407 Settings::Processing::Color::Experimental,
8408 Settings::Processing::Color::Experimental::ToneMapping,
8409 Settings::Processing::Color::Experimental::ToneMapping::Enabled,
8410 Settings::Processing::Color::Gamma,
8411 Settings::Processing::Filters,
8412 Settings::Processing::Filters::Experimental,
8413 Settings::Processing::Filters::Experimental::ContrastDistortion,
8414 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction,
8415 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled,
8416 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength,
8417 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal,
8418 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled,
8419 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold,
8420 Settings::Processing::Filters::Noise,
8421 Settings::Processing::Filters::Noise::Removal,
8422 Settings::Processing::Filters::Noise::Removal::Enabled,
8423 Settings::Processing::Filters::Noise::Removal::Threshold,
8424 Settings::Processing::Filters::Outlier,
8425 Settings::Processing::Filters::Outlier::Removal,
8426 Settings::Processing::Filters::Outlier::Removal::Enabled,
8427 Settings::Processing::Filters::Outlier::Removal::Threshold,
8428 Settings::Processing::Filters::Reflection,
8429 Settings::Processing::Filters::Reflection::Removal,
8430 Settings::Processing::Filters::Reflection::Removal::Enabled,
8431 Settings::Processing::Filters::Smoothing,
8432 Settings::Processing::Filters::Smoothing::Gaussian,
8433 Settings::Processing::Filters::Smoothing::Gaussian::Enabled,
8434 Settings::Processing::Filters::Smoothing::Gaussian::Sigma>;
8435
8437 Settings();
8438
8440 explicit Settings(const std::string &fileName);
8441
8489#ifndef NO_DOC
8490 template<
8491 typename... Args,
8492 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
8493 typename std::enable_if<
8494 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
8495 int>::type = 0>
8496#else
8497 template<typename... Args>
8498#endif
8499 explicit Settings(Args &&...args)
8500 {
8501 using namespace Zivid::Detail::TypeTraits;
8502
8503 static_assert(AllArgsDecayedAreUnique<Args...>::value,
8504 "Found duplicate types among the arguments passed to Settings(...). "
8505 "Types should be listed at most once.");
8506
8507 set(std::forward<Args>(args)...);
8508 }
8509
8556#ifndef NO_DOC
8557 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
8558#else
8559 template<typename... Args>
8560#endif
8561 void set(Args &&...args)
8562 {
8563 using namespace Zivid::Detail::TypeTraits;
8564
8565 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
8566 static_assert(AllArgsAreDescendantNodes::value,
8567 "All arguments passed to set(...) must be descendant nodes.");
8568
8569 static_assert(AllArgsDecayedAreUnique<Args...>::value,
8570 "Found duplicate types among the arguments passed to set(...). "
8571 "Types should be listed at most once.");
8572
8573 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
8574 }
8575
8623#ifndef NO_DOC
8624 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
8625#else
8626 template<typename... Args>
8627#endif
8628 Settings copyWith(Args &&...args) const
8629 {
8630 using namespace Zivid::Detail::TypeTraits;
8631
8632 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
8633 static_assert(AllArgsAreDescendantNodes::value,
8634 "All arguments passed to copyWith(...) must be descendant nodes.");
8635
8636 static_assert(AllArgsDecayedAreUnique<Args...>::value,
8637 "Found duplicate types among the arguments passed to copyWith(...). "
8638 "Types should be listed at most once.");
8639
8640 auto copy{ *this };
8641 copy.set(std::forward<Args>(args)...);
8642 return copy;
8643 }
8644
8646 const Acquisitions &acquisitions() const
8647 {
8648 return m_acquisitions;
8649 }
8650
8652 Acquisitions &acquisitions()
8653 {
8654 return m_acquisitions;
8655 }
8656
8658 Settings &set(const Acquisitions &value)
8659 {
8660 m_acquisitions = value;
8661 return *this;
8662 }
8663
8665 const Experimental &experimental() const
8666 {
8667 return m_experimental;
8668 }
8669
8671 Experimental &experimental()
8672 {
8673 return m_experimental;
8674 }
8675
8677 Settings &set(const Experimental &value)
8678 {
8679 m_experimental = value;
8680 return *this;
8681 }
8682
8684 Settings &set(const Experimental::Engine &value)
8685 {
8686 m_experimental.set(value);
8687 return *this;
8688 }
8689
8691 const Processing &processing() const
8692 {
8693 return m_processing;
8694 }
8695
8697 Processing &processing()
8698 {
8699 return m_processing;
8700 }
8701
8703 Settings &set(const Processing &value)
8704 {
8705 m_processing = value;
8706 return *this;
8707 }
8708
8710 Settings &set(const Processing::Color &value)
8711 {
8712 m_processing.set(value);
8713 return *this;
8714 }
8715
8717 Settings &set(const Processing::Color::Balance &value)
8718 {
8719 m_processing.set(value);
8720 return *this;
8721 }
8722
8724 Settings &set(const Processing::Color::Balance::Blue &value)
8725 {
8726 m_processing.set(value);
8727 return *this;
8728 }
8729
8731 Settings &set(const Processing::Color::Balance::Green &value)
8732 {
8733 m_processing.set(value);
8734 return *this;
8735 }
8736
8738 Settings &set(const Processing::Color::Balance::Red &value)
8739 {
8740 m_processing.set(value);
8741 return *this;
8742 }
8743
8745 Settings &set(const Processing::Color::Experimental &value)
8746 {
8747 m_processing.set(value);
8748 return *this;
8749 }
8750
8752 Settings &set(const Processing::Color::Experimental::ToneMapping &value)
8753 {
8754 m_processing.set(value);
8755 return *this;
8756 }
8757
8759 Settings &set(const Processing::Color::Experimental::ToneMapping::Enabled &value)
8760 {
8761 m_processing.set(value);
8762 return *this;
8763 }
8764
8766 Settings &set(const Processing::Color::Gamma &value)
8767 {
8768 m_processing.set(value);
8769 return *this;
8770 }
8771
8773 Settings &set(const Processing::Filters &value)
8774 {
8775 m_processing.set(value);
8776 return *this;
8777 }
8778
8780 Settings &set(const Processing::Filters::Experimental &value)
8781 {
8782 m_processing.set(value);
8783 return *this;
8784 }
8785
8787 Settings &set(const Processing::Filters::Experimental::ContrastDistortion &value)
8788 {
8789 m_processing.set(value);
8790 return *this;
8791 }
8792
8794 Settings &set(const Processing::Filters::Experimental::ContrastDistortion::Correction &value)
8795 {
8796 m_processing.set(value);
8797 return *this;
8798 }
8799
8801 Settings &set(const Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &value)
8802 {
8803 m_processing.set(value);
8804 return *this;
8805 }
8806
8808 Settings &set(const Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &value)
8809 {
8810 m_processing.set(value);
8811 return *this;
8812 }
8813
8815 Settings &set(const Processing::Filters::Experimental::ContrastDistortion::Removal &value)
8816 {
8817 m_processing.set(value);
8818 return *this;
8819 }
8820
8822 Settings &set(const Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &value)
8823 {
8824 m_processing.set(value);
8825 return *this;
8826 }
8827
8829 Settings &set(const Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &value)
8830 {
8831 m_processing.set(value);
8832 return *this;
8833 }
8834
8836 Settings &set(const Processing::Filters::Noise &value)
8837 {
8838 m_processing.set(value);
8839 return *this;
8840 }
8841
8843 Settings &set(const Processing::Filters::Noise::Removal &value)
8844 {
8845 m_processing.set(value);
8846 return *this;
8847 }
8848
8850 Settings &set(const Processing::Filters::Noise::Removal::Enabled &value)
8851 {
8852 m_processing.set(value);
8853 return *this;
8854 }
8855
8857 Settings &set(const Processing::Filters::Noise::Removal::Threshold &value)
8858 {
8859 m_processing.set(value);
8860 return *this;
8861 }
8862
8864 Settings &set(const Processing::Filters::Outlier &value)
8865 {
8866 m_processing.set(value);
8867 return *this;
8868 }
8869
8871 Settings &set(const Processing::Filters::Outlier::Removal &value)
8872 {
8873 m_processing.set(value);
8874 return *this;
8875 }
8876
8878 Settings &set(const Processing::Filters::Outlier::Removal::Enabled &value)
8879 {
8880 m_processing.set(value);
8881 return *this;
8882 }
8883
8885 Settings &set(const Processing::Filters::Outlier::Removal::Threshold &value)
8886 {
8887 m_processing.set(value);
8888 return *this;
8889 }
8890
8892 Settings &set(const Processing::Filters::Reflection &value)
8893 {
8894 m_processing.set(value);
8895 return *this;
8896 }
8897
8899 Settings &set(const Processing::Filters::Reflection::Removal &value)
8900 {
8901 m_processing.set(value);
8902 return *this;
8903 }
8904
8906 Settings &set(const Processing::Filters::Reflection::Removal::Enabled &value)
8907 {
8908 m_processing.set(value);
8909 return *this;
8910 }
8911
8913 Settings &set(const Processing::Filters::Smoothing &value)
8914 {
8915 m_processing.set(value);
8916 return *this;
8917 }
8918
8920 Settings &set(const Processing::Filters::Smoothing::Gaussian &value)
8921 {
8922 m_processing.set(value);
8923 return *this;
8924 }
8925
8927 Settings &set(const Processing::Filters::Smoothing::Gaussian::Enabled &value)
8928 {
8929 m_processing.set(value);
8930 return *this;
8931 }
8932
8934 Settings &set(const Processing::Filters::Smoothing::Gaussian::Sigma &value)
8935 {
8936 m_processing.set(value);
8937 return *this;
8938 }
8939
8940 template<typename T, typename std::enable_if<std::is_same<T, Settings::Acquisitions>::value, int>::type = 0>
8941 const Settings::Acquisitions &get() const
8942 {
8943 return m_acquisitions;
8944 }
8945
8946 template<typename T, typename std::enable_if<std::is_same<T, Settings::Experimental>::value, int>::type = 0>
8947 const Settings::Experimental &get() const
8948 {
8949 return m_experimental;
8950 }
8951
8952 template<typename T,
8953 typename std::enable_if<std::is_same<T, Settings::Experimental::Engine>::value, int>::type = 0>
8954 const Settings::Experimental::Engine &get() const
8955 {
8956 return m_experimental.get<Settings::Experimental::Engine>();
8957 }
8958
8959 template<typename T, typename std::enable_if<std::is_same<T, Settings::Processing>::value, int>::type = 0>
8960 const Settings::Processing &get() const
8961 {
8962 return m_processing;
8963 }
8964
8965 template<typename T,
8966 typename std::enable_if<std::is_same<T, Settings::Processing::Color>::value, int>::type = 0>
8967 const Settings::Processing::Color &get() const
8968 {
8969 return m_processing.get<Settings::Processing::Color>();
8970 }
8971
8972 template<typename T,
8973 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance>::value, int>::type = 0>
8974 const Settings::Processing::Color::Balance &get() const
8975 {
8976 return m_processing.get<Settings::Processing::Color::Balance>();
8977 }
8978
8979 template<
8980 typename T,
8981 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Blue>::value, int>::type = 0>
8982 const Settings::Processing::Color::Balance::Blue &get() const
8983 {
8984 return m_processing.get<Settings::Processing::Color::Balance::Blue>();
8985 }
8986
8987 template<
8988 typename T,
8989 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Green>::value, int>::type = 0>
8990 const Settings::Processing::Color::Balance::Green &get() const
8991 {
8992 return m_processing.get<Settings::Processing::Color::Balance::Green>();
8993 }
8994
8995 template<
8996 typename T,
8997 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Red>::value, int>::type = 0>
8998 const Settings::Processing::Color::Balance::Red &get() const
8999 {
9000 return m_processing.get<Settings::Processing::Color::Balance::Red>();
9001 }
9002
9003 template<
9004 typename T,
9005 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental>::value, int>::type = 0>
9006 const Settings::Processing::Color::Experimental &get() const
9007 {
9008 return m_processing.get<Settings::Processing::Color::Experimental>();
9009 }
9010
9011 template<typename T,
9012 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental::ToneMapping>::value,
9013 int>::type = 0>
9014 const Settings::Processing::Color::Experimental::ToneMapping &get() const
9015 {
9016 return m_processing.get<Settings::Processing::Color::Experimental::ToneMapping>();
9017 }
9018
9019 template<typename T,
9020 typename std::enable_if<
9021 std::is_same<T, Settings::Processing::Color::Experimental::ToneMapping::Enabled>::value,
9022 int>::type = 0>
9023 const Settings::Processing::Color::Experimental::ToneMapping::Enabled &get() const
9024 {
9025 return m_processing.get<Settings::Processing::Color::Experimental::ToneMapping::Enabled>();
9026 }
9027
9028 template<typename T,
9029 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Gamma>::value, int>::type = 0>
9030 const Settings::Processing::Color::Gamma &get() const
9031 {
9032 return m_processing.get<Settings::Processing::Color::Gamma>();
9033 }
9034
9035 template<typename T,
9036 typename std::enable_if<std::is_same<T, Settings::Processing::Filters>::value, int>::type = 0>
9037 const Settings::Processing::Filters &get() const
9038 {
9039 return m_processing.get<Settings::Processing::Filters>();
9040 }
9041
9042 template<
9043 typename T,
9044 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Experimental>::value, int>::type = 0>
9045 const Settings::Processing::Filters::Experimental &get() const
9046 {
9047 return m_processing.get<Settings::Processing::Filters::Experimental>();
9048 }
9049
9050 template<typename T,
9051 typename std::enable_if<
9052 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
9053 int>::type = 0>
9054 const Settings::Processing::Filters::Experimental::ContrastDistortion &get() const
9055 {
9056 return m_processing.get<Settings::Processing::Filters::Experimental::ContrastDistortion>();
9057 }
9058
9059 template<
9060 typename T,
9061 typename std::enable_if<
9062 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::value,
9063 int>::type = 0>
9064 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction &get() const
9065 {
9066 return m_processing.get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>();
9067 }
9068
9069 template<
9070 typename T,
9071 typename std::enable_if<
9072 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>::
9073 value,
9074 int>::type = 0>
9075 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &get() const
9076 {
9077 return m_processing
9078 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>();
9079 }
9080
9081 template<
9082 typename T,
9083 typename std::enable_if<
9084 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>::
9085 value,
9086 int>::type = 0>
9087 const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &get() const
9088 {
9089 return m_processing
9090 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>();
9091 }
9092
9093 template<typename T,
9094 typename std::enable_if<
9095 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::value,
9096 int>::type = 0>
9097 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal &get() const
9098 {
9099 return m_processing.get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>();
9100 }
9101
9102 template<
9103 typename T,
9104 typename std::enable_if<
9105 std::is_same<T,
9106 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>::value,
9107 int>::type = 0>
9108 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &get() const
9109 {
9110 return m_processing
9111 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>();
9112 }
9113
9114 template<
9115 typename T,
9116 typename std::enable_if<
9117 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>::
9118 value,
9119 int>::type = 0>
9120 const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &get() const
9121 {
9122 return m_processing
9123 .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>();
9124 }
9125
9126 template<typename T,
9127 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise>::value, int>::type = 0>
9128 const Settings::Processing::Filters::Noise &get() const
9129 {
9130 return m_processing.get<Settings::Processing::Filters::Noise>();
9131 }
9132
9133 template<typename T,
9134 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Removal>::value,
9135 int>::type = 0>
9136 const Settings::Processing::Filters::Noise::Removal &get() const
9137 {
9138 return m_processing.get<Settings::Processing::Filters::Noise::Removal>();
9139 }
9140
9141 template<typename T,
9142 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
9143 int>::type = 0>
9144 const Settings::Processing::Filters::Noise::Removal::Enabled &get() const
9145 {
9146 return m_processing.get<Settings::Processing::Filters::Noise::Removal::Enabled>();
9147 }
9148
9149 template<
9150 typename T,
9151 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
9152 int>::type = 0>
9153 const Settings::Processing::Filters::Noise::Removal::Threshold &get() const
9154 {
9155 return m_processing.get<Settings::Processing::Filters::Noise::Removal::Threshold>();
9156 }
9157
9158 template<typename T,
9159 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier>::value, int>::type = 0>
9160 const Settings::Processing::Filters::Outlier &get() const
9161 {
9162 return m_processing.get<Settings::Processing::Filters::Outlier>();
9163 }
9164
9165 template<typename T,
9166 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier::Removal>::value,
9167 int>::type = 0>
9168 const Settings::Processing::Filters::Outlier::Removal &get() const
9169 {
9170 return m_processing.get<Settings::Processing::Filters::Outlier::Removal>();
9171 }
9172
9173 template<
9174 typename T,
9175 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
9176 int>::type = 0>
9177 const Settings::Processing::Filters::Outlier::Removal::Enabled &get() const
9178 {
9179 return m_processing.get<Settings::Processing::Filters::Outlier::Removal::Enabled>();
9180 }
9181
9182 template<
9183 typename T,
9184 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
9185 int>::type = 0>
9186 const Settings::Processing::Filters::Outlier::Removal::Threshold &get() const
9187 {
9188 return m_processing.get<Settings::Processing::Filters::Outlier::Removal::Threshold>();
9189 }
9190
9191 template<
9192 typename T,
9193 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection>::value, int>::type = 0>
9194 const Settings::Processing::Filters::Reflection &get() const
9195 {
9196 return m_processing.get<Settings::Processing::Filters::Reflection>();
9197 }
9198
9199 template<typename T,
9200 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection::Removal>::value,
9201 int>::type = 0>
9202 const Settings::Processing::Filters::Reflection::Removal &get() const
9203 {
9204 return m_processing.get<Settings::Processing::Filters::Reflection::Removal>();
9205 }
9206
9207 template<
9208 typename T,
9209 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
9210 int>::type = 0>
9211 const Settings::Processing::Filters::Reflection::Removal::Enabled &get() const
9212 {
9213 return m_processing.get<Settings::Processing::Filters::Reflection::Removal::Enabled>();
9214 }
9215
9216 template<
9217 typename T,
9218 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing>::value, int>::type = 0>
9219 const Settings::Processing::Filters::Smoothing &get() const
9220 {
9221 return m_processing.get<Settings::Processing::Filters::Smoothing>();
9222 }
9223
9224 template<typename T,
9225 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian>::value,
9226 int>::type = 0>
9227 const Settings::Processing::Filters::Smoothing::Gaussian &get() const
9228 {
9229 return m_processing.get<Settings::Processing::Filters::Smoothing::Gaussian>();
9230 }
9231
9232 template<
9233 typename T,
9234 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
9235 int>::type = 0>
9236 const Settings::Processing::Filters::Smoothing::Gaussian::Enabled &get() const
9237 {
9238 return m_processing.get<Settings::Processing::Filters::Smoothing::Gaussian::Enabled>();
9239 }
9240
9241 template<
9242 typename T,
9243 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
9244 int>::type = 0>
9245 const Settings::Processing::Filters::Smoothing::Gaussian::Sigma &get() const
9246 {
9247 return m_processing.get<Settings::Processing::Filters::Smoothing::Gaussian::Sigma>();
9248 }
9249
9250 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
9251 const Settings::Acquisitions &get() const
9252 {
9253 return m_acquisitions;
9254 }
9255
9256 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
9257 const Settings::Experimental &get() const
9258 {
9259 return m_experimental;
9260 }
9261
9262 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
9263 const Settings::Processing &get() const
9264 {
9265 return m_processing;
9266 }
9267
9269 template<typename F>
9270 void forEach(const F &f) const
9271 {
9272 f(m_acquisitions);
9273 f(m_experimental);
9274 f(m_processing);
9275 }
9276
9278 template<typename F>
9279 void forEach(const F &f)
9280 {
9281 f(m_acquisitions);
9282 f(m_experimental);
9283 f(m_processing);
9284 }
9285
9287 bool operator==(const Settings &other) const;
9288
9290 bool operator!=(const Settings &other) const;
9291
9293 std::string toString() const;
9294
9296 friend std::ostream &operator<<(std::ostream &stream, const Settings &value)
9297 {
9298 return stream << value.toString();
9299 }
9300
9302 void save(const std::string &fileName) const;
9303
9305 void load(const std::string &fileName);
9306
9307 private:
9308 void setFromString(const std::string &value);
9309
9310 void setFromString(const std::string &fullPath, const std::string &value);
9311
9312 std::string getString(const std::string &fullPath) const;
9313
9314 Acquisitions m_acquisitions;
9315 Experimental m_experimental;
9316 Processing m_processing;
9317
9318 friend struct DataModel::Detail::Befriend<Settings>;
9319 };
9320
9321#ifndef NO_DOC
9322 template<>
9323 struct Settings::Version<8>
9324 {
9325 using Type = Settings;
9326 };
9327#endif
9328
9329} // namespace Zivid
9330
9331#ifdef _MSC_VER
9332# pragma warning(pop)
9333#endif
9334
9335#ifndef NO_DOC
9336# if !(defined(_MSC_VER) && (_MSC_VER <= 1900))
9337namespace std // NOLINT
9338{
9339 template<>
9340 struct tuple_size<Zivid::Settings::Experimental> : integral_constant<size_t, 1>
9341 {};
9342
9343 template<size_t i>
9344 struct tuple_element<i, Zivid::Settings::Experimental>
9345 {
9346 static_assert(i < tuple_size<Zivid::Settings::Experimental>::value, "Index must be less than 1");
9347
9348 using type // NOLINT
9349 = decltype(declval<Zivid::Settings::Experimental>().get<i>());
9350 };
9351
9352 template<>
9353 struct tuple_size<Zivid::Settings::Processing> : integral_constant<size_t, 2>
9354 {};
9355
9356 template<size_t i>
9357 struct tuple_element<i, Zivid::Settings::Processing>
9358 {
9359 static_assert(i < tuple_size<Zivid::Settings::Processing>::value, "Index must be less than 2");
9360
9361 using type // NOLINT
9362 = decltype(declval<Zivid::Settings::Processing>().get<i>());
9363 };
9364
9365 template<>
9366 struct tuple_size<Zivid::Settings::Processing::Color> : integral_constant<size_t, 3>
9367 {};
9368
9369 template<size_t i>
9370 struct tuple_element<i, Zivid::Settings::Processing::Color>
9371 {
9372 static_assert(i < tuple_size<Zivid::Settings::Processing::Color>::value, "Index must be less than 3");
9373
9374 using type // NOLINT
9375 = decltype(declval<Zivid::Settings::Processing::Color>().get<i>());
9376 };
9377
9378 template<>
9379 struct tuple_size<Zivid::Settings::Processing::Color::Balance> : integral_constant<size_t, 3>
9380 {};
9381
9382 template<size_t i>
9383 struct tuple_element<i, Zivid::Settings::Processing::Color::Balance>
9384 {
9385 static_assert(i < tuple_size<Zivid::Settings::Processing::Color::Balance>::value, "Index must be less than 3");
9386
9387 using type // NOLINT
9388 = decltype(declval<Zivid::Settings::Processing::Color::Balance>().get<i>());
9389 };
9390
9391 template<>
9392 struct tuple_size<Zivid::Settings::Processing::Color::Experimental> : integral_constant<size_t, 1>
9393 {};
9394
9395 template<size_t i>
9396 struct tuple_element<i, Zivid::Settings::Processing::Color::Experimental>
9397 {
9398 static_assert(i < tuple_size<Zivid::Settings::Processing::Color::Experimental>::value,
9399 "Index must be less than 1");
9400
9401 using type // NOLINT
9402 = decltype(declval<Zivid::Settings::Processing::Color::Experimental>().get<i>());
9403 };
9404
9405 template<>
9406 struct tuple_size<Zivid::Settings::Processing::Color::Experimental::ToneMapping> : integral_constant<size_t, 1>
9407 {};
9408
9409 template<size_t i>
9410 struct tuple_element<i, Zivid::Settings::Processing::Color::Experimental::ToneMapping>
9411 {
9412 static_assert(i < tuple_size<Zivid::Settings::Processing::Color::Experimental::ToneMapping>::value,
9413 "Index must be less than 1");
9414
9415 using type // NOLINT
9416 = decltype(declval<Zivid::Settings::Processing::Color::Experimental::ToneMapping>().get<i>());
9417 };
9418
9419 template<>
9420 struct tuple_size<Zivid::Settings::Processing::Filters> : integral_constant<size_t, 5>
9421 {};
9422
9423 template<size_t i>
9424 struct tuple_element<i, Zivid::Settings::Processing::Filters>
9425 {
9426 static_assert(i < tuple_size<Zivid::Settings::Processing::Filters>::value, "Index must be less than 5");
9427
9428 using type // NOLINT
9429 = decltype(declval<Zivid::Settings::Processing::Filters>().get<i>());
9430 };
9431
9432 template<>
9433 struct tuple_size<Zivid::Settings::Processing::Filters::Experimental> : integral_constant<size_t, 1>
9434 {};
9435
9436 template<size_t i>
9437 struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental>
9438 {
9439 static_assert(i < tuple_size<Zivid::Settings::Processing::Filters::Experimental>::value,
9440 "Index must be less than 1");
9441
9442 using type // NOLINT
9443 = decltype(declval<Zivid::Settings::Processing::Filters::Experimental>().get<i>());
9444 };
9445
9446 template<>
9447 struct tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion>
9448 : integral_constant<size_t, 2>
9449 {};
9450
9451 template<size_t i>
9452 struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion>
9453 {
9454 static_assert(i < tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
9455 "Index must be less than 2");
9456
9457 using type // NOLINT
9458 = decltype(declval<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion>().get<i>());
9459 };
9460
9461 template<>
9462 struct tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>
9463 : integral_constant<size_t, 2>
9464 {};
9465
9466 template<size_t i>
9467 struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>
9468 {
9469 static_assert(
9470 i < tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::value,
9471 "Index must be less than 2");
9472
9473 using type // NOLINT
9474 = decltype(declval<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>()
9475 .get<i>());
9476 };
9477
9478 template<>
9479 struct tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>
9480 : integral_constant<size_t, 2>
9481 {};
9482
9483 template<size_t i>
9484 struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>
9485 {
9486 static_assert(
9487 i < tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::value,
9488 "Index must be less than 2");
9489
9490 using type // NOLINT
9491 = decltype(declval<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>()
9492 .get<i>());
9493 };
9494
9495 template<>
9496 struct tuple_size<Zivid::Settings::Processing::Filters::Noise> : integral_constant<size_t, 1>
9497 {};
9498
9499 template<size_t i>
9500 struct tuple_element<i, Zivid::Settings::Processing::Filters::Noise>
9501 {
9502 static_assert(i < tuple_size<Zivid::Settings::Processing::Filters::Noise>::value, "Index must be less than 1");
9503
9504 using type // NOLINT
9505 = decltype(declval<Zivid::Settings::Processing::Filters::Noise>().get<i>());
9506 };
9507
9508 template<>
9509 struct tuple_size<Zivid::Settings::Processing::Filters::Noise::Removal> : integral_constant<size_t, 2>
9510 {};
9511
9512 template<size_t i>
9513 struct tuple_element<i, Zivid::Settings::Processing::Filters::Noise::Removal>
9514 {
9515 static_assert(i < tuple_size<Zivid::Settings::Processing::Filters::Noise::Removal>::value,
9516 "Index must be less than 2");
9517
9518 using type // NOLINT
9519 = decltype(declval<Zivid::Settings::Processing::Filters::Noise::Removal>().get<i>());
9520 };
9521
9522 template<>
9523 struct tuple_size<Zivid::Settings::Processing::Filters::Outlier> : integral_constant<size_t, 1>
9524 {};
9525
9526 template<size_t i>
9527 struct tuple_element<i, Zivid::Settings::Processing::Filters::Outlier>
9528 {
9529 static_assert(i < tuple_size<Zivid::Settings::Processing::Filters::Outlier>::value,
9530 "Index must be less than 1");
9531
9532 using type // NOLINT
9533 = decltype(declval<Zivid::Settings::Processing::Filters::Outlier>().get<i>());
9534 };
9535
9536 template<>
9537 struct tuple_size<Zivid::Settings::Processing::Filters::Outlier::Removal> : integral_constant<size_t, 2>
9538 {};
9539
9540 template<size_t i>
9541 struct tuple_element<i, Zivid::Settings::Processing::Filters::Outlier::Removal>
9542 {
9543 static_assert(i < tuple_size<Zivid::Settings::Processing::Filters::Outlier::Removal>::value,
9544 "Index must be less than 2");
9545
9546 using type // NOLINT
9547 = decltype(declval<Zivid::Settings::Processing::Filters::Outlier::Removal>().get<i>());
9548 };
9549
9550 template<>
9551 struct tuple_size<Zivid::Settings::Processing::Filters::Reflection> : integral_constant<size_t, 1>
9552 {};
9553
9554 template<size_t i>
9555 struct tuple_element<i, Zivid::Settings::Processing::Filters::Reflection>
9556 {
9557 static_assert(i < tuple_size<Zivid::Settings::Processing::Filters::Reflection>::value,
9558 "Index must be less than 1");
9559
9560 using type // NOLINT
9561 = decltype(declval<Zivid::Settings::Processing::Filters::Reflection>().get<i>());
9562 };
9563
9564 template<>
9565 struct tuple_size<Zivid::Settings::Processing::Filters::Reflection::Removal> : integral_constant<size_t, 1>
9566 {};
9567
9568 template<size_t i>
9569 struct tuple_element<i, Zivid::Settings::Processing::Filters::Reflection::Removal>
9570 {
9571 static_assert(i < tuple_size<Zivid::Settings::Processing::Filters::Reflection::Removal>::value,
9572 "Index must be less than 1");
9573
9574 using type // NOLINT
9575 = decltype(declval<Zivid::Settings::Processing::Filters::Reflection::Removal>().get<i>());
9576 };
9577
9578 template<>
9579 struct tuple_size<Zivid::Settings::Processing::Filters::Smoothing> : integral_constant<size_t, 1>
9580 {};
9581
9582 template<size_t i>
9583 struct tuple_element<i, Zivid::Settings::Processing::Filters::Smoothing>
9584 {
9585 static_assert(i < tuple_size<Zivid::Settings::Processing::Filters::Smoothing>::value,
9586 "Index must be less than 1");
9587
9588 using type // NOLINT
9589 = decltype(declval<Zivid::Settings::Processing::Filters::Smoothing>().get<i>());
9590 };
9591
9592 template<>
9593 struct tuple_size<Zivid::Settings::Processing::Filters::Smoothing::Gaussian> : integral_constant<size_t, 2>
9594 {};
9595
9596 template<size_t i>
9597 struct tuple_element<i, Zivid::Settings::Processing::Filters::Smoothing::Gaussian>
9598 {
9599 static_assert(i < tuple_size<Zivid::Settings::Processing::Filters::Smoothing::Gaussian>::value,
9600 "Index must be less than 2");
9601
9602 using type // NOLINT
9603 = decltype(declval<Zivid::Settings::Processing::Filters::Smoothing::Gaussian>().get<i>());
9604 };
9605
9606 template<>
9607 struct tuple_size<Zivid::Settings> : integral_constant<size_t, 3>
9608 {};
9609
9610 template<size_t i>
9611 struct tuple_element<i, Zivid::Settings>
9612 {
9613 static_assert(i < tuple_size<Zivid::Settings>::value, "Index must be less than 3");
9614
9615 using type // NOLINT
9616 = decltype(declval<Zivid::Settings>().get<i>());
9617 };
9618
9619} // namespace std
9620# endif
9621#endif
ZIVID_CORE_EXPORT
#define ZIVID_CORE_EXPORT
Definition: CoreExport.h:101
Zivid::Range
Class describing a range of values for a given type T
Definition: Range.h:102
Zivid::Settings::Acquisition::Aperture
Aperture setting for the camera. Specified as an f-number (the ratio of lens focal length to the effe...
Definition: Settings.h:170
Zivid::Settings::Acquisition::Aperture::operator<
bool operator<(const Aperture &other) const
Comparison operator
Definition: Settings.h:233
Zivid::Settings::Acquisition::Aperture::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Aperture &value)
Operator to serialize the value to a stream
Definition: Settings.h:245
Zivid::Settings::Acquisition::Aperture::value
double value() const
Get the value
Zivid::Settings::Acquisition::Aperture::toString
std::string toString() const
Get the value as string
Zivid::Settings::Acquisition::Aperture::operator>
bool operator>(const Aperture &other) const
Comparison operator
Definition: Settings.h:239
Zivid::Settings::Acquisition::Aperture::operator==
bool operator==(const Aperture &other) const
Comparison operator
Definition: Settings.h:221
Zivid::Settings::Acquisition::Aperture::operator!=
bool operator!=(const Aperture &other) const
Comparison operator
Definition: Settings.h:227
Zivid::Settings::Acquisition::Aperture::Aperture
Aperture()=default
Default constructor
Zivid::Settings::Acquisition::Aperture::Aperture
constexpr Aperture(double value)
Constructor
Definition: Settings.h:201
Zivid::Settings::Acquisition::Aperture::ValueType
double ValueType
The type of the underlying value
Definition: Settings.h:189
Zivid::Settings::Acquisition::Aperture::reset
void reset()
Reset the node to unset state
Zivid::Settings::Acquisition::Aperture::validRange
static constexpr Range< double > validRange()
The range of valid values for Aperture
Definition: Settings.h:192
Zivid::Settings::Acquisition::Aperture::hasValue
bool hasValue() const
Check if the value is set
Zivid::Settings::Acquisition::Brightness
Brightness controls the light output from the projector.
Definition: Settings.h:281
Zivid::Settings::Acquisition::Brightness::operator!=
bool operator!=(const Brightness &other) const
Comparison operator
Definition: Settings.h:348
Zivid::Settings::Acquisition::Brightness::operator<
bool operator<(const Brightness &other) const
Comparison operator
Definition: Settings.h:354
Zivid::Settings::Acquisition::Brightness::operator>
bool operator>(const Brightness &other) const
Comparison operator
Definition: Settings.h:360
Zivid::Settings::Acquisition::Brightness::reset
void reset()
Reset the node to unset state
Zivid::Settings::Acquisition::Brightness::validRange
static constexpr Range< double > validRange()
The range of valid values for Brightness
Definition: Settings.h:313
Zivid::Settings::Acquisition::Brightness::toString
std::string toString() const
Get the value as string
Zivid::Settings::Acquisition::Brightness::value
double value() const
Get the value
Zivid::Settings::Acquisition::Brightness::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Brightness &value)
Operator to serialize the value to a stream
Definition: Settings.h:366
Zivid::Settings::Acquisition::Brightness::Brightness
constexpr Brightness(double value)
Constructor
Definition: Settings.h:322
Zivid::Settings::Acquisition::Brightness::hasValue
bool hasValue() const
Check if the value is set
Zivid::Settings::Acquisition::Brightness::Brightness
Brightness()=default
Default constructor
Zivid::Settings::Acquisition::Brightness::ValueType
double ValueType
The type of the underlying value
Definition: Settings.h:310
Zivid::Settings::Acquisition::Brightness::operator==
bool operator==(const Brightness &other) const
Comparison operator
Definition: Settings.h:342
Zivid::Settings::Acquisition::ExposureTime
Exposure time for each single image in the measurement. Affects frame rate.
Definition: Settings.h:390
Zivid::Settings::Acquisition::ExposureTime::operator<
bool operator<(const ExposureTime &other) const
Comparison operator
Definition: Settings.h:451
Zivid::Settings::Acquisition::ExposureTime::ExposureTime
ExposureTime()=default
Default constructor
Zivid::Settings::Acquisition::ExposureTime::hasValue
bool hasValue() const
Check if the value is set
Zivid::Settings::Acquisition::ExposureTime::reset
void reset()
Reset the node to unset state
Zivid::Settings::Acquisition::ExposureTime::toString
std::string toString() const
Get the value as string
Zivid::Settings::Acquisition::ExposureTime::operator>
bool operator>(const ExposureTime &other) const
Comparison operator
Definition: Settings.h:457
Zivid::Settings::Acquisition::ExposureTime::ValueType
std::chrono::microseconds ValueType
The type of the underlying value
Definition: Settings.h:407
Zivid::Settings::Acquisition::ExposureTime::operator==
bool operator==(const ExposureTime &other) const
Comparison operator
Definition: Settings.h:439
Zivid::Settings::Acquisition::ExposureTime::operator!=
bool operator!=(const ExposureTime &other) const
Comparison operator
Definition: Settings.h:445
Zivid::Settings::Acquisition::ExposureTime::value
std::chrono::microseconds value() const
Get the value
Zivid::Settings::Acquisition::ExposureTime::validRange
static constexpr Range< std::chrono::microseconds > validRange()
The range of valid values for ExposureTime
Definition: Settings.h:410
Zivid::Settings::Acquisition::ExposureTime::ExposureTime
constexpr ExposureTime(std::chrono::microseconds value)
Constructor
Definition: Settings.h:419
Zivid::Settings::Acquisition::ExposureTime::operator<<
friend std::ostream & operator<<(std::ostream &stream, const ExposureTime &value)
Operator to serialize the value to a stream
Definition: Settings.h:463
Zivid::Settings::Acquisition::Gain
Analog gain in the camera
Definition: Settings.h:488
Zivid::Settings::Acquisition::Gain::operator==
bool operator==(const Gain &other) const
Comparison operator
Definition: Settings.h:535
Zivid::Settings::Acquisition::Gain::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Gain &value)
Operator to serialize the value to a stream
Definition: Settings.h:559
Zivid::Settings::Acquisition::Gain::Gain
constexpr Gain(double value)
Constructor
Definition: Settings.h:515
Zivid::Settings::Acquisition::Gain::reset
void reset()
Reset the node to unset state
Zivid::Settings::Acquisition::Gain::validRange
static constexpr Range< double > validRange()
The range of valid values for Gain
Definition: Settings.h:506
Zivid::Settings::Acquisition::Gain::value
double value() const
Get the value
Zivid::Settings::Acquisition::Gain::Gain
Gain()=default
Default constructor
Zivid::Settings::Acquisition::Gain::hasValue
bool hasValue() const
Check if the value is set
Zivid::Settings::Acquisition::Gain::ValueType
double ValueType
The type of the underlying value
Definition: Settings.h:503
Zivid::Settings::Acquisition::Gain::toString
std::string toString() const
Get the value as string
Zivid::Settings::Acquisition::Gain::operator!=
bool operator!=(const Gain &other) const
Comparison operator
Definition: Settings.h:541
Zivid::Settings::Acquisition::Gain::operator>
bool operator>(const Gain &other) const
Comparison operator
Definition: Settings.h:553
Zivid::Settings::Acquisition::Gain::operator<
bool operator<(const Gain &other) const
Comparison operator
Definition: Settings.h:547
Zivid::Settings::Acquisition
Settings for a single acquisition
Definition: Settings.h:152
Zivid::Settings::Acquisition::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:824
Zivid::Settings::Acquisition::set
Acquisition & set(const Aperture &value)
Set Aperture
Definition: Settings.h:706
Zivid::Settings::Acquisition::aperture
const Aperture & aperture() const
Get Aperture
Definition: Settings.h:694
Zivid::Settings::Acquisition::gain
Gain & gain()
Get Gain
Definition: Settings.h:757
Zivid::Settings::Acquisition::get
const Settings::Acquisition::Aperture & get() const
Definition: Settings.h:771
Zivid::Settings::Acquisition::brightness
Brightness & brightness()
Get Brightness
Definition: Settings.h:719
Zivid::Settings::Acquisition::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Acquisition &value)
Operator to send the value as string to a stream
Definition: Settings.h:852
Zivid::Settings::Acquisition::operator==
bool operator==(const Acquisition &other) const
Equality operator
Zivid::Settings::Acquisition::get
const Settings::Acquisition::ExposureTime & get() const
Definition: Settings.h:786
Zivid::Settings::Acquisition::operator!=
bool operator!=(const Acquisition &other) const
Inequality operator
Zivid::Settings::Acquisition::exposureTime
const ExposureTime & exposureTime() const
Get ExposureTime
Definition: Settings.h:732
Zivid::Settings::Acquisition::set
Acquisition & set(const Brightness &value)
Set Brightness
Definition: Settings.h:725
Zivid::Settings::Acquisition::set
Acquisition & set(const ExposureTime &value)
Set ExposureTime
Definition: Settings.h:744
Zivid::Settings::Acquisition::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:642
Zivid::Settings::Acquisition::brightness
const Brightness & brightness() const
Get Brightness
Definition: Settings.h:713
Zivid::Settings::Acquisition::get
const Settings::Acquisition::Gain & get() const
Definition: Settings.h:793
Zivid::Settings::Acquisition::set
Acquisition & set(const Gain &value)
Set Gain
Definition: Settings.h:763
Zivid::Settings::Acquisition::copyWith
Acquisition copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:676
Zivid::Settings::Acquisition::aperture
Aperture & aperture()
Get Aperture
Definition: Settings.h:700
Zivid::Settings::Acquisition::get
const Settings::Acquisition::Brightness & get() const
Definition: Settings.h:778
Zivid::Settings::Acquisition::Acquisition
Acquisition(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:613
Zivid::Settings::Acquisition::exposureTime
ExposureTime & exposureTime()
Get ExposureTime
Definition: Settings.h:738
Zivid::Settings::Acquisition::gain
const Gain & gain() const
Get Gain
Definition: Settings.h:751
Zivid::Settings::Acquisition::Acquisition
Acquisition()
Default constructor
Zivid::Settings::Acquisition::Descendants
std::tuple< Settings::Acquisition::Aperture, Settings::Acquisition::Brightness, Settings::Acquisition::ExposureTime, Settings::Acquisition::Gain > Descendants
Definition: Settings.h:584
Zivid::Settings::Acquisition::toString
std::string toString() const
Get the value as string
Zivid::Settings::Acquisition::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:834
Zivid::Settings::Acquisitions
List of Acquisition objects
Definition: Settings.h:874
Zivid::Settings::Acquisitions::operator!=
bool operator!=(const Acquisitions &other) const
Comparison operator
Definition: Settings.h:988
Zivid::Settings::Acquisitions::value
const std::vector< Settings::Acquisition > & value() const
Get the value
Zivid::Settings::Acquisitions::toString
std::string toString() const
Get the value as string
Zivid::Settings::Acquisitions::forEach
void forEach(const F &f) const
Run the given function on each element in the list
Definition: Settings.h:973
Zivid::Settings::Acquisitions::at
const Settings::Acquisition & at(std::size_t pos) const
Returns a const reference to the element at position pos in the list
Zivid::Settings::Acquisitions::operator==
bool operator==(const Acquisitions &other) const
Comparison operator
Definition: Settings.h:982
Zivid::Settings::Acquisitions::Acquisitions
Acquisitions()=default
Default constructor
Zivid::Settings::Acquisitions::Acquisitions
Acquisitions(std::initializer_list< Settings::Acquisition > value)
Constructor
Definition: Settings.h:906
Zivid::Settings::Acquisitions::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Acquisitions &value)
Operator to serialize the value to a stream
Definition: Settings.h:994
Zivid::Settings::Acquisitions::forEach
void forEach(const F &f)
Run the given function on each element in the list
Definition: Settings.h:963
Zivid::Settings::Acquisitions::Acquisitions
Acquisitions(std::vector< Settings::Acquisition > value)
Constructor
Definition: Settings.h:901
Zivid::Settings::Acquisitions::ValueType
std::vector< Settings::Acquisition > ValueType
The type of the underlying value
Definition: Settings.h:889
Zivid::Settings::Acquisitions::validSize
static constexpr Range< ValueType::size_type > validSize()
The valid sizes for Acquisitions
Definition: Settings.h:892
Zivid::Settings::Acquisitions::operator[]
const Settings::Acquisition & operator[](std::size_t pos) const
Returns a const reference to the element at position pos in the list
Zivid::Settings::Acquisitions::at
Settings::Acquisition & at(std::size_t pos)
Returns a reference to the element at position pos in the list
Zivid::Settings::Acquisitions::size
std::size_t size() const noexcept
Get the size of the list
Zivid::Settings::Acquisitions::operator[]
Settings::Acquisition & operator[](std::size_t pos)
Returns a reference to the element at position pos in the list
Zivid::Settings::Experimental::Engine
Set the Zivid Vision Engine to use.
Definition: Settings.h:1035
Zivid::Settings::Experimental::Engine::value
ValueType value() const
Get the value
Zivid::Settings::Experimental::Engine::phase
static const Engine phase
phase
Definition: Settings.h:1063
Zivid::Settings::Experimental::Engine::hasValue
bool hasValue() const
Check if the value is set
Zivid::Settings::Experimental::Engine::ValueType
ValueType
The type of the underlying value
Definition: Settings.h:1059
Zivid::Settings::Experimental::Engine::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Engine &value)
Operator to serialize the value to a stream
Definition: Settings.h:1114
Zivid::Settings::Experimental::Engine::validValues
static std::set< ValueType > validValues()
All valid values of Engine
Definition: Settings.h:1067
Zivid::Settings::Experimental::Engine::toString
std::string toString() const
Get the value as string
Zivid::Settings::Experimental::Engine::operator==
bool operator==(const Engine &other) const
Comparison operator
Definition: Settings.h:1102
Zivid::Settings::Experimental::Engine::Engine
Engine()=default
Default constructor
Zivid::Settings::Experimental::Engine::operator!=
bool operator!=(const Engine &other) const
Comparison operator
Definition: Settings.h:1108
Zivid::Settings::Experimental::Engine::Engine
constexpr Engine(ValueType value)
Constructor
Definition: Settings.h:1076
Zivid::Settings::Experimental::Engine::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Engine::ValueType &value)
Operator to serialize ValueType to a stream
Definition: Settings.h:1096
Zivid::Settings::Experimental::Engine::stripe
static const Engine stripe
stripe
Definition: Settings.h:1064
Zivid::Settings::Experimental::Engine::reset
void reset()
Reset the node to unset state
Zivid::Settings::Experimental
Experimental features. These settings may be changed, renamed, moved or deleted in the future.
Definition: Settings.h:1009
Zivid::Settings::Experimental::engine
Engine & engine()
Get Engine
Definition: Settings.h:1244
Zivid::Settings::Experimental::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:1189
Zivid::Settings::Experimental::copyWith
Experimental copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:1220
Zivid::Settings::Experimental::toString
std::string toString() const
Get the value as string
Zivid::Settings::Experimental::operator!=
bool operator!=(const Experimental &other) const
Inequality operator
Zivid::Settings::Experimental::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Experimental &value)
Operator to send the value as string to a stream
Definition: Settings.h:1293
Zivid::Settings::Experimental::get
const Settings::Experimental::Engine & get() const
Definition: Settings.h:1258
Zivid::Settings::Experimental::Descendants
std::tuple< Settings::Experimental::Engine > Descendants
Definition: Settings.h:1137
Zivid::Settings::Experimental::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:1271
Zivid::Settings::Experimental::operator==
bool operator==(const Experimental &other) const
Equality operator
Zivid::Settings::Experimental::Experimental
Experimental(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:1163
Zivid::Settings::Experimental::Experimental
Experimental()
Default constructor
Zivid::Settings::Experimental::set
Experimental & set(const Engine &value)
Set Engine
Definition: Settings.h:1250
Zivid::Settings::Experimental::engine
const Engine & engine() const
Get Engine
Definition: Settings.h:1238
Zivid::Settings::Experimental::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:1278
Zivid::Settings::Processing::Color::Balance::Blue
Digital gain applied to blue channel
Definition: Settings.h:1362
Zivid::Settings::Processing::Color::Balance::Blue::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Blue &value)
Operator to serialize the value to a stream
Definition: Settings.h:1435
Zivid::Settings::Processing::Color::Balance::Blue::reset
void reset()
Reset the node to unset state
Zivid::Settings::Processing::Color::Balance::Blue::operator==
bool operator==(const Blue &other) const
Comparison operator
Definition: Settings.h:1411
Zivid::Settings::Processing::Color::Balance::Blue::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Color::Balance::Blue::operator<
bool operator<(const Blue &other) const
Comparison operator
Definition: Settings.h:1423
Zivid::Settings::Processing::Color::Balance::Blue::Blue
constexpr Blue(double value)
Constructor
Definition: Settings.h:1391
Zivid::Settings::Processing::Color::Balance::Blue::operator!=
bool operator!=(const Blue &other) const
Comparison operator
Definition: Settings.h:1417
Zivid::Settings::Processing::Color::Balance::Blue::hasValue
bool hasValue() const
Check if the value is set
Zivid::Settings::Processing::Color::Balance::Blue::ValueType
double ValueType
The type of the underlying value
Definition: Settings.h:1379
Zivid::Settings::Processing::Color::Balance::Blue::operator>
bool operator>(const Blue &other) const
Comparison operator
Definition: Settings.h:1429
Zivid::Settings::Processing::Color::Balance::Blue::validRange
static constexpr Range< double > validRange()
The range of valid values for Blue
Definition: Settings.h:1382
Zivid::Settings::Processing::Color::Balance::Green
Digital gain applied to green channel
Definition: Settings.h:1460
Zivid::Settings::Processing::Color::Balance::Green::reset
void reset()
Reset the node to unset state
Zivid::Settings::Processing::Color::Balance::Green::operator>
bool operator>(const Green &other) const
Comparison operator
Definition: Settings.h:1527
Zivid::Settings::Processing::Color::Balance::Green::hasValue
bool hasValue() const
Check if the value is set
Zivid::Settings::Processing::Color::Balance::Green::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Green &value)
Operator to serialize the value to a stream
Definition: Settings.h:1533
Zivid::Settings::Processing::Color::Balance::Green::ValueType
double ValueType
The type of the underlying value
Definition: Settings.h:1477
Zivid::Settings::Processing::Color::Balance::Green::Green
constexpr Green(double value)
Constructor
Definition: Settings.h:1489
Zivid::Settings::Processing::Color::Balance::Green::operator==
bool operator==(const Green &other) const
Comparison operator
Definition: Settings.h:1509
Zivid::Settings::Processing::Color::Balance::Green::operator!=
bool operator!=(const Green &other) const
Comparison operator
Definition: Settings.h:1515
Zivid::Settings::Processing::Color::Balance::Green::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Color::Balance::Green::operator<
bool operator<(const Green &other) const
Comparison operator
Definition: Settings.h:1521
Zivid::Settings::Processing::Color::Balance::Green::validRange
static constexpr Range< double > validRange()
The range of valid values for Green
Definition: Settings.h:1480
Zivid::Settings::Processing::Color::Balance::Red
Digital gain applied to red channel
Definition: Settings.h:1558
Zivid::Settings::Processing::Color::Balance::Red::operator!=
bool operator!=(const Red &other) const
Comparison operator
Definition: Settings.h:1613
Zivid::Settings::Processing::Color::Balance::Red::Red
constexpr Red(double value)
Constructor
Definition: Settings.h:1587
Zivid::Settings::Processing::Color::Balance::Red::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Red &value)
Operator to serialize the value to a stream
Definition: Settings.h:1631
Zivid::Settings::Processing::Color::Balance::Red::ValueType
double ValueType
The type of the underlying value
Definition: Settings.h:1575
Zivid::Settings::Processing::Color::Balance::Red::validRange
static constexpr Range< double > validRange()
The range of valid values for Red
Definition: Settings.h:1578
Zivid::Settings::Processing::Color::Balance::Red::operator==
bool operator==(const Red &other) const
Comparison operator
Definition: Settings.h:1607
Zivid::Settings::Processing::Color::Balance::Red::operator<
bool operator<(const Red &other) const
Comparison operator
Definition: Settings.h:1619
Zivid::Settings::Processing::Color::Balance::Red::reset
void reset()
Reset the node to unset state
Zivid::Settings::Processing::Color::Balance::Red::operator>
bool operator>(const Red &other) const
Comparison operator
Definition: Settings.h:1625
Zivid::Settings::Processing::Color::Balance::Red::hasValue
bool hasValue() const
Check if the value is set
Zivid::Settings::Processing::Color::Balance::Red::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Color::Balance
Color balance settings
Definition: Settings.h:1346
Zivid::Settings::Processing::Color::Balance::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:1712
Zivid::Settings::Processing::Color::Balance::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:1866
Zivid::Settings::Processing::Color::Balance::operator!=
bool operator!=(const Balance &other) const
Inequality operator
Zivid::Settings::Processing::Color::Balance::set
Balance & set(const Red &value)
Set Red
Definition: Settings.h:1815
Zivid::Settings::Processing::Color::Balance::green
Green & green()
Get Green
Definition: Settings.h:1790
Zivid::Settings::Processing::Color::Balance::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Color::Balance::Balance
Balance(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:1684
Zivid::Settings::Processing::Color::Balance::red
Red & red()
Get Red
Definition: Settings.h:1809
Zivid::Settings::Processing::Color::Balance::operator==
bool operator==(const Balance &other) const
Equality operator
Zivid::Settings::Processing::Color::Balance::copyWith
Balance copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:1746
Zivid::Settings::Processing::Color::Balance::set
Balance & set(const Blue &value)
Set Blue
Definition: Settings.h:1777
Zivid::Settings::Processing::Color::Balance::blue
Blue & blue()
Get Blue
Definition: Settings.h:1771
Zivid::Settings::Processing::Color::Balance::red
const Red & red() const
Get Red
Definition: Settings.h:1803
Zivid::Settings::Processing::Color::Balance::Descendants
std::tuple< Settings::Processing::Color::Balance::Blue, Settings::Processing::Color::Balance::Green, Settings::Processing::Color::Balance::Red > Descendants
Definition: Settings.h:1656
Zivid::Settings::Processing::Color::Balance::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:1875
Zivid::Settings::Processing::Color::Balance::get
const Settings::Processing::Color::Balance::Green & get() const
Definition: Settings.h:1833
Zivid::Settings::Processing::Color::Balance::get
const Settings::Processing::Color::Balance::Red & get() const
Definition: Settings.h:1841
Zivid::Settings::Processing::Color::Balance::set
Balance & set(const Green &value)
Set Green
Definition: Settings.h:1796
Zivid::Settings::Processing::Color::Balance::green
const Green & green() const
Get Green
Definition: Settings.h:1784
Zivid::Settings::Processing::Color::Balance::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Balance &value)
Operator to send the value as string to a stream
Definition: Settings.h:1892
Zivid::Settings::Processing::Color::Balance::get
const Settings::Processing::Color::Balance::Blue & get() const
Definition: Settings.h:1824
Zivid::Settings::Processing::Color::Balance::blue
const Blue & blue() const
Get Blue
Definition: Settings.h:1765
Zivid::Settings::Processing::Color::Experimental::ToneMapping::Enabled
This setting controls when tone mapping of colors is performed. Tone mapping will normalize the captu...
Definition: Settings.h:1955
Zivid::Settings::Processing::Color::Experimental::ToneMapping::Enabled::ValueType
ValueType
The type of the underlying value
Definition: Settings.h:1981
Zivid::Settings::Processing::Color::Experimental::ToneMapping::Enabled::operator==
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:2024
Zivid::Settings::Processing::Color::Experimental::ToneMapping::Enabled::operator!=
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:2030
Zivid::Settings::Processing::Color::Experimental::ToneMapping::Enabled::always
static const Enabled always
always
Definition: Settings.h:1985
Zivid::Settings::Processing::Color::Experimental::ToneMapping::Enabled::validValues
static std::set< ValueType > validValues()
All valid values of Enabled
Definition: Settings.h:1989
Zivid::Settings::Processing::Color::Experimental::ToneMapping::Enabled::hdrOnly
static const Enabled hdrOnly
hdrOnly
Definition: Settings.h:1986
Zivid::Settings::Processing::Color::Experimental::ToneMapping::Enabled::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:2036
Zivid::Settings::Processing::Color::Experimental::ToneMapping::Enabled::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Enabled::ValueType &value)
Operator to serialize ValueType to a stream
Definition: Settings.h:2018
Zivid::Settings::Processing::Color::Experimental::ToneMapping::Enabled::Enabled
constexpr Enabled(ValueType value)
Constructor
Definition: Settings.h:1998
Zivid::Settings::Processing::Color::Experimental::ToneMapping
Tonemapping settings.
Definition: Settings.h:1931
Zivid::Settings::Processing::Color::Experimental::ToneMapping::operator<<
friend std::ostream & operator<<(std::ostream &stream, const ToneMapping &value)
Operator to send the value as string to a stream
Definition: Settings.h:2222
Zivid::Settings::Processing::Color::Experimental::ToneMapping::set
ToneMapping & set(const Enabled &value)
Set Enabled
Definition: Settings.h:2176
Zivid::Settings::Processing::Color::Experimental::ToneMapping::ToneMapping
ToneMapping(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:2087
Zivid::Settings::Processing::Color::Experimental::ToneMapping::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Color::Experimental::ToneMapping::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:2207
Zivid::Settings::Processing::Color::Experimental::ToneMapping::isEnabled
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:2164
Zivid::Settings::Processing::Color::Experimental::ToneMapping::operator==
bool operator==(const ToneMapping &other) const
Equality operator
Zivid::Settings::Processing::Color::Experimental::ToneMapping::Descendants
std::tuple< Settings::Processing::Color::Experimental::ToneMapping::Enabled > Descendants
Definition: Settings.h:2061
Zivid::Settings::Processing::Color::Experimental::ToneMapping::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:2200
Zivid::Settings::Processing::Color::Experimental::ToneMapping::get
const Settings::Processing::Color::Experimental::ToneMapping::Enabled & get() const
Definition: Settings.h:2187
Zivid::Settings::Processing::Color::Experimental::ToneMapping::isEnabled
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:2170
Zivid::Settings::Processing::Color::Experimental::ToneMapping::operator!=
bool operator!=(const ToneMapping &other) const
Inequality operator
Zivid::Settings::Processing::Color::Experimental::ToneMapping::copyWith
ToneMapping copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:2145
Zivid::Settings::Processing::Color::Experimental::ToneMapping::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:2113
Zivid::Settings::Processing::Color::Experimental
Experimental color settings. These may be renamed, moved or deleted in the future.
Definition: Settings.h:1913
Zivid::Settings::Processing::Color::Experimental::get
const Settings::Processing::Color::Experimental::ToneMapping::Enabled & get() const
Definition: Settings.h:2385
Zivid::Settings::Processing::Color::Experimental::set
Experimental & set(const ToneMapping &value)
Set ToneMapping
Definition: Settings.h:2358
Zivid::Settings::Processing::Color::Experimental::toneMapping
const ToneMapping & toneMapping() const
Get ToneMapping
Definition: Settings.h:2346
Zivid::Settings::Processing::Color::Experimental::set
Experimental & set(const ToneMapping::Enabled &value)
Set ToneMapping::Enabled
Definition: Settings.h:2365
Zivid::Settings::Processing::Color::Experimental::operator!=
bool operator!=(const Experimental &other) const
Inequality operator
Zivid::Settings::Processing::Color::Experimental::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Experimental &value)
Operator to send the value as string to a stream
Definition: Settings.h:2420
Zivid::Settings::Processing::Color::Experimental::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:2405
Zivid::Settings::Processing::Color::Experimental::Experimental
Experimental(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:2267
Zivid::Settings::Processing::Color::Experimental::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:2294
Zivid::Settings::Processing::Color::Experimental::Descendants
std::tuple< Settings::Processing::Color::Experimental::ToneMapping, Settings::Processing::Color::Experimental::ToneMapping::Enabled > Descendants
Definition: Settings.h:2240
Zivid::Settings::Processing::Color::Experimental::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Color::Experimental::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:2398
Zivid::Settings::Processing::Color::Experimental::operator==
bool operator==(const Experimental &other) const
Equality operator
Zivid::Settings::Processing::Color::Experimental::toneMapping
ToneMapping & toneMapping()
Get ToneMapping
Definition: Settings.h:2352
Zivid::Settings::Processing::Color::Experimental::copyWith
Experimental copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:2327
Zivid::Settings::Processing::Color::Experimental::get
const Settings::Processing::Color::Experimental::ToneMapping & get() const
Definition: Settings.h:2375
Zivid::Settings::Processing::Color::Gamma
Gamma applied to the color values. Gamma less than 1 makes the colors brighter, while gamma greater t...
Definition: Settings.h:2441
Zivid::Settings::Processing::Color::Gamma::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Gamma &value)
Operator to serialize the value to a stream
Definition: Settings.h:2516
Zivid::Settings::Processing::Color::Gamma::value
double value() const
Get the value
Zivid::Settings::Processing::Color::Gamma::operator>
bool operator>(const Gamma &other) const
Comparison operator
Definition: Settings.h:2510
Zivid::Settings::Processing::Color::Gamma::reset
void reset()
Reset the node to unset state
Zivid::Settings::Processing::Color::Gamma::validRange
static constexpr Range< double > validRange()
The range of valid values for Gamma
Definition: Settings.h:2463
Zivid::Settings::Processing::Color::Gamma::Gamma
Gamma()=default
Default constructor
Zivid::Settings::Processing::Color::Gamma::ValueType
double ValueType
The type of the underlying value
Definition: Settings.h:2460
Zivid::Settings::Processing::Color::Gamma::hasValue
bool hasValue() const
Check if the value is set
Zivid::Settings::Processing::Color::Gamma::Gamma
constexpr Gamma(double value)
Constructor
Definition: Settings.h:2472
Zivid::Settings::Processing::Color::Gamma::operator!=
bool operator!=(const Gamma &other) const
Comparison operator
Definition: Settings.h:2498
Zivid::Settings::Processing::Color::Gamma::operator<
bool operator<(const Gamma &other) const
Comparison operator
Definition: Settings.h:2504
Zivid::Settings::Processing::Color::Gamma::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Color::Gamma::operator==
bool operator==(const Gamma &other) const
Comparison operator
Definition: Settings.h:2492
Zivid::Settings::Processing::Color
Color settings
Definition: Settings.h:1330
Zivid::Settings::Processing::Color::set
Color & set(const Gamma &value)
Set Gamma
Definition: Settings.h:2754
Zivid::Settings::Processing::Color::get
const Settings::Processing::Color::Gamma & get() const
Definition: Settings.h:2821
Zivid::Settings::Processing::Color::get
const Settings::Processing::Color::Balance::Red & get() const
Definition: Settings.h:2787
Zivid::Settings::Processing::Color::operator==
bool operator==(const Color &other) const
Equality operator
Zivid::Settings::Processing::Color::get
const Settings::Processing::Color::Balance::Green & get() const
Definition: Settings.h:2779
Zivid::Settings::Processing::Color::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:2611
Zivid::Settings::Processing::Color::set
Color & set(const Experimental::ToneMapping &value)
Set Experimental::ToneMapping
Definition: Settings.h:2728
Zivid::Settings::Processing::Color::set
Color & set(const Experimental &value)
Set Experimental
Definition: Settings.h:2721
Zivid::Settings::Processing::Color::set
Color & set(const Experimental::ToneMapping::Enabled &value)
Set Experimental::ToneMapping::Enabled
Definition: Settings.h:2735
Zivid::Settings::Processing::Color::set
Color & set(const Balance &value)
Set Balance
Definition: Settings.h:2681
Zivid::Settings::Processing::Color::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Color &value)
Operator to send the value as string to a stream
Definition: Settings.h:2872
Zivid::Settings::Processing::Color::balance
const Balance & balance() const
Get Balance
Definition: Settings.h:2669
Zivid::Settings::Processing::Color::experimental
const Experimental & experimental() const
Get Experimental
Definition: Settings.h:2709
Zivid::Settings::Processing::Color::get
const Settings::Processing::Color::Experimental::ToneMapping::Enabled & get() const
Definition: Settings.h:2813
Zivid::Settings::Processing::Color::Descendants
std::tuple< Settings::Processing::Color::Balance, Settings::Processing::Color::Balance::Blue, Settings::Processing::Color::Balance::Green, Settings::Processing::Color::Balance::Red, Settings::Processing::Color::Experimental, Settings::Processing::Color::Experimental::ToneMapping, Settings::Processing::Color::Experimental::ToneMapping::Enabled, Settings::Processing::Color::Gamma > Descendants
Definition: Settings.h:2545
Zivid::Settings::Processing::Color::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:2855
Zivid::Settings::Processing::Color::get
const Settings::Processing::Color::Experimental & get() const
Definition: Settings.h:2795
Zivid::Settings::Processing::Color::set
Color & set(const Balance::Green &value)
Set Balance::Green
Definition: Settings.h:2695
Zivid::Settings::Processing::Color::experimental
Experimental & experimental()
Get Experimental
Definition: Settings.h:2715
Zivid::Settings::Processing::Color::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Color::operator!=
bool operator!=(const Color &other) const
Inequality operator
Zivid::Settings::Processing::Color::set
Color & set(const Balance::Blue &value)
Set Balance::Blue
Definition: Settings.h:2688
Zivid::Settings::Processing::Color::gamma
Gamma & gamma()
Get Gamma
Definition: Settings.h:2748
Zivid::Settings::Processing::Color::copyWith
Color copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:2650
Zivid::Settings::Processing::Color::set
Color & set(const Balance::Red &value)
Set Balance::Red
Definition: Settings.h:2702
Zivid::Settings::Processing::Color::gamma
const Gamma & gamma() const
Get Gamma
Definition: Settings.h:2742
Zivid::Settings::Processing::Color::Color
Color(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:2578
Zivid::Settings::Processing::Color::get
const Settings::Processing::Color::Balance & get() const
Definition: Settings.h:2763
Zivid::Settings::Processing::Color::balance
Balance & balance()
Get Balance
Definition: Settings.h:2675
Zivid::Settings::Processing::Color::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:2846
Zivid::Settings::Processing::Color::get
const Settings::Processing::Color::Experimental::ToneMapping & get() const
Definition: Settings.h:2804
Zivid::Settings::Processing::Color::get
const Settings::Processing::Color::Balance::Blue & get() const
Definition: Settings.h:2771
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled::ValueType
bool ValueType
The type of the underlying value
Definition: Settings.h:2988
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled::validValues
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:2993
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled::Enabled
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:3002
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:3034
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled::operator==
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:3022
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled::operator!=
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:3028
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength
Higher values gives more correction.
Definition: Settings.h:3049
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength::ValueType
double ValueType
The type of the underlying value
Definition: Settings.h:3068
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength::operator>
bool operator>(const Strength &other) const
Comparison operator
Definition: Settings.h:3118
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength::operator!=
bool operator!=(const Strength &other) const
Comparison operator
Definition: Settings.h:3106
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength::Strength
constexpr Strength(double value)
Constructor
Definition: Settings.h:3080
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength::validRange
static constexpr Range< double > validRange()
The range of valid values for Strength
Definition: Settings.h:3071
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Strength &value)
Operator to serialize the value to a stream
Definition: Settings.h:3124
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength::operator<
bool operator<(const Strength &other) const
Comparison operator
Definition: Settings.h:3112
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength::operator==
bool operator==(const Strength &other) const
Comparison operator
Definition: Settings.h:3100
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::operator==
bool operator==(const Correction &other) const
Equality operator
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:3334
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::isEnabled
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:3255
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength & get() const
Definition: Settings.h:3312
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Descendants
std::tuple< Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength > Descendants
Definition: Settings.h:3149
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::copyWith
Correction copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:3236
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled & get() const
Definition: Settings.h:3299
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::operator!=
bool operator!=(const Correction &other) const
Inequality operator
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Correction &value)
Operator to send the value as string to a stream
Definition: Settings.h:3358
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:3203
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::set
Correction & set(const Enabled &value)
Set Enabled
Definition: Settings.h:3267
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:3342
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::set
Correction & set(const Strength &value)
Set Strength
Definition: Settings.h:3286
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::strength
const Strength & strength() const
Get Strength
Definition: Settings.h:3274
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Correction
Correction(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:3176
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled::yes
static const Enabled yes
On/enabled.
Definition: Settings.h:3414
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled::Enabled
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:3427
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled::operator!=
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:3453
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled::ValueType
bool ValueType
The type of the underlying value
Definition: Settings.h:3413
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled::validValues
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:3418
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:3459
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled::operator==
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:3447
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled::no
static const Enabled no
Off/disabled.
Definition: Settings.h:3415
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold
Higher values remove more points.
Definition: Settings.h:3474
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold::Threshold
constexpr Threshold(double value)
Constructor
Definition: Settings.h:3505
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold::operator!=
bool operator!=(const Threshold &other) const
Comparison operator
Definition: Settings.h:3531
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold::operator<
bool operator<(const Threshold &other) const
Comparison operator
Definition: Settings.h:3537
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold::validRange
static constexpr Range< double > validRange()
The range of valid values for Threshold
Definition: Settings.h:3496
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold::operator==
bool operator==(const Threshold &other) const
Comparison operator
Definition: Settings.h:3525
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold::operator>
bool operator>(const Threshold &other) const
Comparison operator
Definition: Settings.h:3543
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Threshold &value)
Operator to serialize the value to a stream
Definition: Settings.h:3549
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold::ValueType
double ValueType
The type of the underlying value
Definition: Settings.h:3493
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:3757
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:3628
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Removal &value)
Operator to send the value as string to a stream
Definition: Settings.h:3781
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::threshold
const Threshold & threshold() const
Get Threshold
Definition: Settings.h:3699
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::set
Removal & set(const Threshold &value)
Set Threshold
Definition: Settings.h:3711
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Removal
Removal(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:3601
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::operator!=
bool operator!=(const Removal &other) const
Inequality operator
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::copyWith
Removal copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:3661
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::threshold
Threshold & threshold()
Get Threshold
Definition: Settings.h:3705
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::set
Removal & set(const Enabled &value)
Set Enabled
Definition: Settings.h:3692
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled & get() const
Definition: Settings.h:3724
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Descendants
std::tuple< Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold > Descendants
Definition: Settings.h:3574
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::isEnabled
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:3680
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold & get() const
Definition: Settings.h:3736
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:3765
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion
Corrects artifacts that appear when imaging scenes with large texture gradients or high contrast....
Definition: Settings.h:2931
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::set
ContrastDistortion & set(const Removal::Enabled &value)
Set Removal::Enabled
Definition: Settings.h:3976
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::set
ContrastDistortion & set(const Correction::Enabled &value)
Set Correction::Enabled
Definition: Settings.h:3943
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::set
ContrastDistortion & set(const Correction &value)
Set Correction
Definition: Settings.h:3936
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:4074
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::operator!=
bool operator!=(const ContrastDistortion &other) const
Inequality operator
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::operator<<
friend std::ostream & operator<<(std::ostream &stream, const ContrastDistortion &value)
Operator to send the value as string to a stream
Definition: Settings.h:4098
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::copyWith
ContrastDistortion copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:3905
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Descendants
std::tuple< Settings::Processing::Filters::Experimental::ContrastDistortion::Correction, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold > Descendants
Definition: Settings.h:3805
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::set
ContrastDistortion & set(const Correction::Strength &value)
Set Correction::Strength
Definition: Settings.h:3950
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:3868
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:4082
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::set
ContrastDistortion & set(const Removal &value)
Set Removal
Definition: Settings.h:3969
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold & get() const
Definition: Settings.h:4053
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal & get() const
Definition: Settings.h:4030
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::removal
const Removal & removal() const
Get Removal
Definition: Settings.h:3957
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled & get() const
Definition: Settings.h:4006
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction & get() const
Definition: Settings.h:3994
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength & get() const
Definition: Settings.h:4019
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::removal
Removal & removal()
Get Removal
Definition: Settings.h:3963
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::operator==
bool operator==(const ContrastDistortion &other) const
Equality operator
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::set
ContrastDistortion & set(const Removal::Threshold &value)
Set Removal::Threshold
Definition: Settings.h:3983
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::correction
const Correction & correction() const
Get Correction
Definition: Settings.h:3924
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::ContrastDistortion
ContrastDistortion(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:3836
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled & get() const
Definition: Settings.h:4040
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::correction
Correction & correction()
Get Correction
Definition: Settings.h:3930
Zivid::Settings::Processing::Filters::Experimental
Experimental filters. These may be renamed, moved or deleted in the future.
Definition: Settings.h:2909
Zivid::Settings::Processing::Filters::Experimental::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:4399
Zivid::Settings::Processing::Filters::Experimental::contrastDistortion
ContrastDistortion & contrastDistortion()
Get ContrastDistortion
Definition: Settings.h:4250
Zivid::Settings::Processing::Filters::Experimental::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal & get() const
Definition: Settings.h:4355
Zivid::Settings::Processing::Filters::Experimental::copyWith
Experimental copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:4225
Zivid::Settings::Processing::Filters::Experimental::Experimental
Experimental(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:4155
Zivid::Settings::Processing::Filters::Experimental::set
Experimental & set(const ContrastDistortion &value)
Set ContrastDistortion
Definition: Settings.h:4256
Zivid::Settings::Processing::Filters::Experimental::set
Experimental & set(const ContrastDistortion::Removal::Threshold &value)
Set ContrastDistortion::Removal::Threshold
Definition: Settings.h:4298
Zivid::Settings::Processing::Filters::Experimental::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:4187
Zivid::Settings::Processing::Filters::Experimental::set
Experimental & set(const ContrastDistortion::Correction::Strength &value)
Set ContrastDistortion::Correction::Strength
Definition: Settings.h:4277
Zivid::Settings::Processing::Filters::Experimental::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Experimental &value)
Operator to send the value as string to a stream
Definition: Settings.h:4414
Zivid::Settings::Processing::Filters::Experimental::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength & get() const
Definition: Settings.h:4342
Zivid::Settings::Processing::Filters::Experimental::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:4392
Zivid::Settings::Processing::Filters::Experimental::set
Experimental & set(const ContrastDistortion::Removal &value)
Set ContrastDistortion::Removal
Definition: Settings.h:4284
Zivid::Settings::Processing::Filters::Experimental::get
const Settings::Processing::Filters::Experimental::ContrastDistortion & get() const
Definition: Settings.h:4309
Zivid::Settings::Processing::Filters::Experimental::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction & get() const
Definition: Settings.h:4319
Zivid::Settings::Processing::Filters::Experimental::operator!=
bool operator!=(const Experimental &other) const
Inequality operator
Zivid::Settings::Processing::Filters::Experimental::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold & get() const
Definition: Settings.h:4377
Zivid::Settings::Processing::Filters::Experimental::set
Experimental & set(const ContrastDistortion::Correction::Enabled &value)
Set ContrastDistortion::Correction::Enabled
Definition: Settings.h:4270
Zivid::Settings::Processing::Filters::Experimental::contrastDistortion
const ContrastDistortion & contrastDistortion() const
Get ContrastDistortion
Definition: Settings.h:4244
Zivid::Settings::Processing::Filters::Experimental::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Experimental::operator==
bool operator==(const Experimental &other) const
Equality operator
Zivid::Settings::Processing::Filters::Experimental::Descendants
std::tuple< Settings::Processing::Filters::Experimental::ContrastDistortion, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold > Descendants
Definition: Settings.h:4123
Zivid::Settings::Processing::Filters::Experimental::set
Experimental & set(const ContrastDistortion::Correction &value)
Set ContrastDistortion::Correction
Definition: Settings.h:4263
Zivid::Settings::Processing::Filters::Experimental::set
Experimental & set(const ContrastDistortion::Removal::Enabled &value)
Set ContrastDistortion::Removal::Enabled
Definition: Settings.h:4291
Zivid::Settings::Processing::Filters::Experimental::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled & get() const
Definition: Settings.h:4330
Zivid::Settings::Processing::Filters::Experimental::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled & get() const
Definition: Settings.h:4366
Zivid::Settings::Processing::Filters::Noise::Removal::Enabled
Enable or disable the SNR filter
Definition: Settings.h:4469
Zivid::Settings::Processing::Filters::Noise::Removal::Enabled::yes
static const Enabled yes
On/enabled.
Definition: Settings.h:4487
Zivid::Settings::Processing::Filters::Noise::Removal::Enabled::operator!=
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:4526
Zivid::Settings::Processing::Filters::Noise::Removal::Enabled::operator==
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:4520
Zivid::Settings::Processing::Filters::Noise::Removal::Enabled::validValues
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:4491
Zivid::Settings::Processing::Filters::Noise::Removal::Enabled::Enabled
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:4500
Zivid::Settings::Processing::Filters::Noise::Removal::Enabled::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:4532
Zivid::Settings::Processing::Filters::Noise::Removal::Enabled::no
static const Enabled no
Off/disabled.
Definition: Settings.h:4488
Zivid::Settings::Processing::Filters::Noise::Removal::Enabled::ValueType
bool ValueType
The type of the underlying value
Definition: Settings.h:4486
Zivid::Settings::Processing::Filters::Noise::Removal::Enabled::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Noise::Removal::Threshold
Discard points with signal-to-noise ratio (SNR) below the given value
Definition: Settings.h:4547
Zivid::Settings::Processing::Filters::Noise::Removal::Threshold::Threshold
constexpr Threshold(double value)
Constructor
Definition: Settings.h:4576
Zivid::Settings::Processing::Filters::Noise::Removal::Threshold::operator==
bool operator==(const Threshold &other) const
Comparison operator
Definition: Settings.h:4596
Zivid::Settings::Processing::Filters::Noise::Removal::Threshold::validRange
static constexpr Range< double > validRange()
The range of valid values for Threshold
Definition: Settings.h:4567
Zivid::Settings::Processing::Filters::Noise::Removal::Threshold::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Threshold &value)
Operator to serialize the value to a stream
Definition: Settings.h:4620
Zivid::Settings::Processing::Filters::Noise::Removal::Threshold::operator>
bool operator>(const Threshold &other) const
Comparison operator
Definition: Settings.h:4614
Zivid::Settings::Processing::Filters::Noise::Removal::Threshold::operator<
bool operator<(const Threshold &other) const
Comparison operator
Definition: Settings.h:4608
Zivid::Settings::Processing::Filters::Noise::Removal::Threshold::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Noise::Removal::Threshold::ValueType
double ValueType
The type of the underlying value
Definition: Settings.h:4564
Zivid::Settings::Processing::Filters::Noise::Removal::Threshold::operator!=
bool operator!=(const Threshold &other) const
Comparison operator
Definition: Settings.h:4602
Zivid::Settings::Processing::Filters::Noise::Removal
Discard points with signal-to-noise ratio (SNR) values below a threshold
Definition: Settings.h:4451
Zivid::Settings::Processing::Filters::Noise::Removal::Removal
Removal(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:4671
Zivid::Settings::Processing::Filters::Noise::Removal::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Removal &value)
Operator to send the value as string to a stream
Definition: Settings.h:4843
Zivid::Settings::Processing::Filters::Noise::Removal::Descendants
std::tuple< Settings::Processing::Filters::Noise::Removal::Enabled, Settings::Processing::Filters::Noise::Removal::Threshold > Descendants
Definition: Settings.h:4644
Zivid::Settings::Processing::Filters::Noise::Removal::isEnabled
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:4750
Zivid::Settings::Processing::Filters::Noise::Removal::threshold
const Threshold & threshold() const
Get Threshold
Definition: Settings.h:4769
Zivid::Settings::Processing::Filters::Noise::Removal::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:4827
Zivid::Settings::Processing::Filters::Noise::Removal::set
Removal & set(const Enabled &value)
Set Enabled
Definition: Settings.h:4762
Zivid::Settings::Processing::Filters::Noise::Removal::set
Removal & set(const Threshold &value)
Set Threshold
Definition: Settings.h:4781
Zivid::Settings::Processing::Filters::Noise::Removal::operator==
bool operator==(const Removal &other) const
Equality operator
Zivid::Settings::Processing::Filters::Noise::Removal::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:4698
Zivid::Settings::Processing::Filters::Noise::Removal::operator!=
bool operator!=(const Removal &other) const
Inequality operator
Zivid::Settings::Processing::Filters::Noise::Removal::get
const Settings::Processing::Filters::Noise::Removal::Threshold & get() const
Definition: Settings.h:4800
Zivid::Settings::Processing::Filters::Noise::Removal::threshold
Threshold & threshold()
Get Threshold
Definition: Settings.h:4775
Zivid::Settings::Processing::Filters::Noise::Removal::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:4819
Zivid::Settings::Processing::Filters::Noise::Removal::copyWith
Removal copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:4731
Zivid::Settings::Processing::Filters::Noise::Removal::isEnabled
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:4756
Zivid::Settings::Processing::Filters::Noise::Removal::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Noise::Removal::get
const Settings::Processing::Filters::Noise::Removal::Enabled & get() const
Definition: Settings.h:4791
Zivid::Settings::Processing::Filters::Noise
Contains a filter that removes points with low signal-to-noise ratio (SNR)
Definition: Settings.h:4433
Zivid::Settings::Processing::Filters::Noise::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:5039
Zivid::Settings::Processing::Filters::Noise::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Noise::removal
Removal & removal()
Get Removal
Definition: Settings.h:4978
Zivid::Settings::Processing::Filters::Noise::Noise
Noise(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:4891
Zivid::Settings::Processing::Filters::Noise::set
Noise & set(const Removal::Threshold &value)
Set Removal::Threshold
Definition: Settings.h:4998
Zivid::Settings::Processing::Filters::Noise::copyWith
Noise copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:4953
Zivid::Settings::Processing::Filters::Noise::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:5046
Zivid::Settings::Processing::Filters::Noise::get
const Settings::Processing::Filters::Noise::Removal::Threshold & get() const
Definition: Settings.h:5026
Zivid::Settings::Processing::Filters::Noise::set
Noise & set(const Removal::Enabled &value)
Set Removal::Enabled
Definition: Settings.h:4991
Zivid::Settings::Processing::Filters::Noise::Descendants
std::tuple< Settings::Processing::Filters::Noise::Removal, Settings::Processing::Filters::Noise::Removal::Enabled, Settings::Processing::Filters::Noise::Removal::Threshold > Descendants
Definition: Settings.h:4863
Zivid::Settings::Processing::Filters::Noise::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:4919
Zivid::Settings::Processing::Filters::Noise::operator!=
bool operator!=(const Noise &other) const
Inequality operator
Zivid::Settings::Processing::Filters::Noise::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Noise &value)
Operator to send the value as string to a stream
Definition: Settings.h:5061
Zivid::Settings::Processing::Filters::Noise::removal
const Removal & removal() const
Get Removal
Definition: Settings.h:4972
Zivid::Settings::Processing::Filters::Noise::get
const Settings::Processing::Filters::Noise::Removal::Enabled & get() const
Definition: Settings.h:5017
Zivid::Settings::Processing::Filters::Noise::operator==
bool operator==(const Noise &other) const
Equality operator
Zivid::Settings::Processing::Filters::Noise::get
const Settings::Processing::Filters::Noise::Removal & get() const
Definition: Settings.h:5008
Zivid::Settings::Processing::Filters::Noise::set
Noise & set(const Removal &value)
Set Removal
Definition: Settings.h:4984
Zivid::Settings::Processing::Filters::Outlier::Removal::Enabled
Enable or disable the outlier filter
Definition: Settings.h:5116
Zivid::Settings::Processing::Filters::Outlier::Removal::Enabled::ValueType
bool ValueType
The type of the underlying value
Definition: Settings.h:5133
Zivid::Settings::Processing::Filters::Outlier::Removal::Enabled::operator!=
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:5173
Zivid::Settings::Processing::Filters::Outlier::Removal::Enabled::Enabled
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:5147
Zivid::Settings::Processing::Filters::Outlier::Removal::Enabled::no
static const Enabled no
Off/disabled.
Definition: Settings.h:5135
Zivid::Settings::Processing::Filters::Outlier::Removal::Enabled::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Outlier::Removal::Enabled::yes
static const Enabled yes
On/enabled.
Definition: Settings.h:5134
Zivid::Settings::Processing::Filters::Outlier::Removal::Enabled::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:5179
Zivid::Settings::Processing::Filters::Outlier::Removal::Enabled::validValues
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:5138
Zivid::Settings::Processing::Filters::Outlier::Removal::Enabled::operator==
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:5167
Zivid::Settings::Processing::Filters::Outlier::Removal::Threshold
Discard point if Euclidean distance to neighboring points is above the given value
Definition: Settings.h:5194
Zivid::Settings::Processing::Filters::Outlier::Removal::Threshold::validRange
static constexpr Range< double > validRange()
The range of valid values for Threshold
Definition: Settings.h:5214
Zivid::Settings::Processing::Filters::Outlier::Removal::Threshold::Threshold
constexpr Threshold(double value)
Constructor
Definition: Settings.h:5223
Zivid::Settings::Processing::Filters::Outlier::Removal::Threshold::operator<
bool operator<(const Threshold &other) const
Comparison operator
Definition: Settings.h:5255
Zivid::Settings::Processing::Filters::Outlier::Removal::Threshold::operator==
bool operator==(const Threshold &other) const
Comparison operator
Definition: Settings.h:5243
Zivid::Settings::Processing::Filters::Outlier::Removal::Threshold::operator!=
bool operator!=(const Threshold &other) const
Comparison operator
Definition: Settings.h:5249
Zivid::Settings::Processing::Filters::Outlier::Removal::Threshold::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Threshold &value)
Operator to serialize the value to a stream
Definition: Settings.h:5267
Zivid::Settings::Processing::Filters::Outlier::Removal::Threshold::operator>
bool operator>(const Threshold &other) const
Comparison operator
Definition: Settings.h:5261
Zivid::Settings::Processing::Filters::Outlier::Removal::Threshold::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Outlier::Removal::Threshold::ValueType
double ValueType
The type of the underlying value
Definition: Settings.h:5211
Zivid::Settings::Processing::Filters::Outlier::Removal
Discard point if Euclidean distance to neighboring points is above a threshold
Definition: Settings.h:5098
Zivid::Settings::Processing::Filters::Outlier::Removal::operator!=
bool operator!=(const Removal &other) const
Inequality operator
Zivid::Settings::Processing::Filters::Outlier::Removal::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Removal &value)
Operator to send the value as string to a stream
Definition: Settings.h:5490
Zivid::Settings::Processing::Filters::Outlier::Removal::isEnabled
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:5397
Zivid::Settings::Processing::Filters::Outlier::Removal::copyWith
Removal copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:5378
Zivid::Settings::Processing::Filters::Outlier::Removal::set
Removal & set(const Enabled &value)
Set Enabled
Definition: Settings.h:5409
Zivid::Settings::Processing::Filters::Outlier::Removal::isEnabled
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:5403
Zivid::Settings::Processing::Filters::Outlier::Removal::set
Removal & set(const Threshold &value)
Set Threshold
Definition: Settings.h:5428
Zivid::Settings::Processing::Filters::Outlier::Removal::Descendants
std::tuple< Settings::Processing::Filters::Outlier::Removal::Enabled, Settings::Processing::Filters::Outlier::Removal::Threshold > Descendants
Definition: Settings.h:5291
Zivid::Settings::Processing::Filters::Outlier::Removal::get
const Settings::Processing::Filters::Outlier::Removal::Enabled & get() const
Definition: Settings.h:5438
Zivid::Settings::Processing::Filters::Outlier::Removal::Removal
Removal(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:5318
Zivid::Settings::Processing::Filters::Outlier::Removal::get
const Settings::Processing::Filters::Outlier::Removal::Threshold & get() const
Definition: Settings.h:5447
Zivid::Settings::Processing::Filters::Outlier::Removal::threshold
const Threshold & threshold() const
Get Threshold
Definition: Settings.h:5416
Zivid::Settings::Processing::Filters::Outlier::Removal::threshold
Threshold & threshold()
Get Threshold
Definition: Settings.h:5422
Zivid::Settings::Processing::Filters::Outlier::Removal::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Outlier::Removal::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:5466
Zivid::Settings::Processing::Filters::Outlier::Removal::operator==
bool operator==(const Removal &other) const
Equality operator
Zivid::Settings::Processing::Filters::Outlier::Removal::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:5345
Zivid::Settings::Processing::Filters::Outlier::Removal::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:5474
Zivid::Settings::Processing::Filters::Outlier
Contains a filter that removes points with large Euclidean distance to neighboring points
Definition: Settings.h:5080
Zivid::Settings::Processing::Filters::Outlier::removal
const Removal & removal() const
Get Removal
Definition: Settings.h:5619
Zivid::Settings::Processing::Filters::Outlier::Outlier
Outlier(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:5538
Zivid::Settings::Processing::Filters::Outlier::set
Outlier & set(const Removal &value)
Set Removal
Definition: Settings.h:5631
Zivid::Settings::Processing::Filters::Outlier::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:5693
Zivid::Settings::Processing::Filters::Outlier::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Outlier::Descendants
std::tuple< Settings::Processing::Filters::Outlier::Removal, Settings::Processing::Filters::Outlier::Removal::Enabled, Settings::Processing::Filters::Outlier::Removal::Threshold > Descendants
Definition: Settings.h:5510
Zivid::Settings::Processing::Filters::Outlier::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:5686
Zivid::Settings::Processing::Filters::Outlier::operator!=
bool operator!=(const Outlier &other) const
Inequality operator
Zivid::Settings::Processing::Filters::Outlier::set
Outlier & set(const Removal::Threshold &value)
Set Removal::Threshold
Definition: Settings.h:5645
Zivid::Settings::Processing::Filters::Outlier::set
Outlier & set(const Removal::Enabled &value)
Set Removal::Enabled
Definition: Settings.h:5638
Zivid::Settings::Processing::Filters::Outlier::removal
Removal & removal()
Get Removal
Definition: Settings.h:5625
Zivid::Settings::Processing::Filters::Outlier::copyWith
Outlier copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:5600
Zivid::Settings::Processing::Filters::Outlier::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Outlier &value)
Operator to send the value as string to a stream
Definition: Settings.h:5708
Zivid::Settings::Processing::Filters::Outlier::operator==
bool operator==(const Outlier &other) const
Equality operator
Zivid::Settings::Processing::Filters::Outlier::get
const Settings::Processing::Filters::Outlier::Removal::Threshold & get() const
Definition: Settings.h:5673
Zivid::Settings::Processing::Filters::Outlier::get
const Settings::Processing::Filters::Outlier::Removal & get() const
Definition: Settings.h:5655
Zivid::Settings::Processing::Filters::Outlier::get
const Settings::Processing::Filters::Outlier::Removal::Enabled & get() const
Definition: Settings.h:5664
Zivid::Settings::Processing::Filters::Outlier::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:5566
Zivid::Settings::Processing::Filters::Reflection::Removal::Enabled
Enable or disable the reflection filter. Note that this filter is computationally intensive and may a...
Definition: Settings.h:5763
Zivid::Settings::Processing::Filters::Reflection::Removal::Enabled::ValueType
bool ValueType
The type of the underlying value
Definition: Settings.h:5780
Zivid::Settings::Processing::Filters::Reflection::Removal::Enabled::yes
static const Enabled yes
On/enabled.
Definition: Settings.h:5781
Zivid::Settings::Processing::Filters::Reflection::Removal::Enabled::operator!=
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:5820
Zivid::Settings::Processing::Filters::Reflection::Removal::Enabled::Enabled
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:5794
Zivid::Settings::Processing::Filters::Reflection::Removal::Enabled::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Reflection::Removal::Enabled::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:5826
Zivid::Settings::Processing::Filters::Reflection::Removal::Enabled::no
static const Enabled no
Off/disabled.
Definition: Settings.h:5782
Zivid::Settings::Processing::Filters::Reflection::Removal::Enabled::operator==
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:5814
Zivid::Settings::Processing::Filters::Reflection::Removal::Enabled::validValues
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:5785
Zivid::Settings::Processing::Filters::Reflection::Removal
Discard points likely introduced by reflections (useful for shiny materials)
Definition: Settings.h:5745
Zivid::Settings::Processing::Filters::Reflection::Removal::Descendants
std::tuple< Settings::Processing::Filters::Reflection::Removal::Enabled > Descendants
Definition: Settings.h:5839
Zivid::Settings::Processing::Filters::Reflection::Removal::isEnabled
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:5948
Zivid::Settings::Processing::Filters::Reflection::Removal::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Removal &value)
Operator to send the value as string to a stream
Definition: Settings.h:6000
Zivid::Settings::Processing::Filters::Reflection::Removal::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Reflection::Removal::operator==
bool operator==(const Removal &other) const
Equality operator
Zivid::Settings::Processing::Filters::Reflection::Removal::get
const Settings::Processing::Filters::Reflection::Removal::Enabled & get() const
Definition: Settings.h:5965
Zivid::Settings::Processing::Filters::Reflection::Removal::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:5891
Zivid::Settings::Processing::Filters::Reflection::Removal::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:5978
Zivid::Settings::Processing::Filters::Reflection::Removal::copyWith
Removal copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:5923
Zivid::Settings::Processing::Filters::Reflection::Removal::Removal
Removal(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:5865
Zivid::Settings::Processing::Filters::Reflection::Removal::set
Removal & set(const Enabled &value)
Set Enabled
Definition: Settings.h:5954
Zivid::Settings::Processing::Filters::Reflection::Removal::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:5985
Zivid::Settings::Processing::Filters::Reflection::Removal::isEnabled
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:5942
Zivid::Settings::Processing::Filters::Reflection::Removal::operator!=
bool operator!=(const Removal &other) const
Inequality operator
Zivid::Settings::Processing::Filters::Reflection
Contains a filter that removes points likely introduced by reflections (useful for shiny materials)
Definition: Settings.h:5727
Zivid::Settings::Processing::Filters::Reflection::operator!=
bool operator!=(const Reflection &other) const
Inequality operator
Zivid::Settings::Processing::Filters::Reflection::operator==
bool operator==(const Reflection &other) const
Equality operator
Zivid::Settings::Processing::Filters::Reflection::removal
Removal & removal()
Get Removal
Definition: Settings.h:6130
Zivid::Settings::Processing::Filters::Reflection::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:6072
Zivid::Settings::Processing::Filters::Reflection::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Reflection &value)
Operator to send the value as string to a stream
Definition: Settings.h:6197
Zivid::Settings::Processing::Filters::Reflection::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:6182
Zivid::Settings::Processing::Filters::Reflection::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:6175
Zivid::Settings::Processing::Filters::Reflection::set
Reflection & set(const Removal::Enabled &value)
Set Removal::Enabled
Definition: Settings.h:6143
Zivid::Settings::Processing::Filters::Reflection::Descendants
std::tuple< Settings::Processing::Filters::Reflection::Removal, Settings::Processing::Filters::Reflection::Removal::Enabled > Descendants
Definition: Settings.h:6018
Zivid::Settings::Processing::Filters::Reflection::get
const Settings::Processing::Filters::Reflection::Removal::Enabled & get() const
Definition: Settings.h:6162
Zivid::Settings::Processing::Filters::Reflection::Reflection
Reflection(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:6045
Zivid::Settings::Processing::Filters::Reflection::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Reflection::removal
const Removal & removal() const
Get Removal
Definition: Settings.h:6124
Zivid::Settings::Processing::Filters::Reflection::get
const Settings::Processing::Filters::Reflection::Removal & get() const
Definition: Settings.h:6153
Zivid::Settings::Processing::Filters::Reflection::set
Reflection & set(const Removal &value)
Set Removal
Definition: Settings.h:6136
Zivid::Settings::Processing::Filters::Reflection::copyWith
Reflection copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:6105
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Enabled
Enable or disable the smoothing filter
Definition: Settings.h:6250
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Enabled::ValueType
bool ValueType
The type of the underlying value
Definition: Settings.h:6267
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Enabled::validValues
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:6272
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Enabled::operator!=
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:6307
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Enabled::yes
static const Enabled yes
On/enabled.
Definition: Settings.h:6268
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Enabled::operator==
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:6301
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Enabled::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:6313
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Enabled::no
static const Enabled no
Off/disabled.
Definition: Settings.h:6269
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Enabled::Enabled
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:6281
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Enabled::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Sigma
Higher values result in smoother point clouds (Standard deviation of the filter coefficients)
Definition: Settings.h:6328
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Sigma::ValueType
double ValueType
The type of the underlying value
Definition: Settings.h:6345
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Sigma::operator!=
bool operator!=(const Sigma &other) const
Comparison operator
Definition: Settings.h:6383
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Sigma::operator>
bool operator>(const Sigma &other) const
Comparison operator
Definition: Settings.h:6395
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Sigma::Sigma
constexpr Sigma(double value)
Constructor
Definition: Settings.h:6357
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Sigma::validRange
static constexpr Range< double > validRange()
The range of valid values for Sigma
Definition: Settings.h:6348
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Sigma::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Sigma &value)
Operator to serialize the value to a stream
Definition: Settings.h:6401
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Sigma::operator==
bool operator==(const Sigma &other) const
Comparison operator
Definition: Settings.h:6377
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Sigma::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Sigma::operator<
bool operator<(const Sigma &other) const
Comparison operator
Definition: Settings.h:6389
Zivid::Settings::Processing::Filters::Smoothing::Gaussian
Gaussian smoothing of the point cloud
Definition: Settings.h:6232
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Gaussian
Gaussian(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:6452
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::isEnabled
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:6537
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:6601
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::get
const Settings::Processing::Filters::Smoothing::Gaussian::Sigma & get() const
Definition: Settings.h:6582
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::set
Gaussian & set(const Enabled &value)
Set Enabled
Definition: Settings.h:6543
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Descendants
std::tuple< Settings::Processing::Filters::Smoothing::Gaussian::Enabled, Settings::Processing::Filters::Smoothing::Gaussian::Sigma > Descendants
Definition: Settings.h:6425
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Gaussian &value)
Operator to send the value as string to a stream
Definition: Settings.h:6625
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::sigma
const Sigma & sigma() const
Get Sigma
Definition: Settings.h:6550
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::operator==
bool operator==(const Gaussian &other) const
Equality operator
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::isEnabled
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:6531
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::operator!=
bool operator!=(const Gaussian &other) const
Inequality operator
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::get
const Settings::Processing::Filters::Smoothing::Gaussian::Enabled & get() const
Definition: Settings.h:6573
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::copyWith
Gaussian copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:6512
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::set
Gaussian & set(const Sigma &value)
Set Sigma
Definition: Settings.h:6562
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::sigma
Sigma & sigma()
Get Sigma
Definition: Settings.h:6556
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:6479
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:6609
Zivid::Settings::Processing::Filters::Smoothing
Smoothing filters
Definition: Settings.h:6216
Zivid::Settings::Processing::Filters::Smoothing::copyWith
Smoothing copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:6735
Zivid::Settings::Processing::Filters::Smoothing::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:6701
Zivid::Settings::Processing::Filters::Smoothing::set
Smoothing & set(const Gaussian &value)
Set Gaussian
Definition: Settings.h:6766
Zivid::Settings::Processing::Filters::Smoothing::get
const Settings::Processing::Filters::Smoothing::Gaussian::Enabled & get() const
Definition: Settings.h:6799
Zivid::Settings::Processing::Filters::Smoothing::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:6828
Zivid::Settings::Processing::Filters::Smoothing::set
Smoothing & set(const Gaussian::Sigma &value)
Set Gaussian::Sigma
Definition: Settings.h:6780
Zivid::Settings::Processing::Filters::Smoothing::set
Smoothing & set(const Gaussian::Enabled &value)
Set Gaussian::Enabled
Definition: Settings.h:6773
Zivid::Settings::Processing::Filters::Smoothing::operator!=
bool operator!=(const Smoothing &other) const
Inequality operator
Zivid::Settings::Processing::Filters::Smoothing::gaussian
const Gaussian & gaussian() const
Get Gaussian
Definition: Settings.h:6754
Zivid::Settings::Processing::Filters::Smoothing::Smoothing
Smoothing(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:6673
Zivid::Settings::Processing::Filters::Smoothing::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::Smoothing::operator==
bool operator==(const Smoothing &other) const
Equality operator
Zivid::Settings::Processing::Filters::Smoothing::get
const Settings::Processing::Filters::Smoothing::Gaussian & get() const
Definition: Settings.h:6790
Zivid::Settings::Processing::Filters::Smoothing::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:6821
Zivid::Settings::Processing::Filters::Smoothing::get
const Settings::Processing::Filters::Smoothing::Gaussian::Sigma & get() const
Definition: Settings.h:6808
Zivid::Settings::Processing::Filters::Smoothing::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Smoothing &value)
Operator to send the value as string to a stream
Definition: Settings.h:6843
Zivid::Settings::Processing::Filters::Smoothing::gaussian
Gaussian & gaussian()
Get Gaussian
Definition: Settings.h:6760
Zivid::Settings::Processing::Filters::Smoothing::Descendants
std::tuple< Settings::Processing::Filters::Smoothing::Gaussian, Settings::Processing::Filters::Smoothing::Gaussian::Enabled, Settings::Processing::Filters::Smoothing::Gaussian::Sigma > Descendants
Definition: Settings.h:6645
Zivid::Settings::Processing::Filters
Filters
Definition: Settings.h:2893
Zivid::Settings::Processing::Filters::operator!=
bool operator!=(const Filters &other) const
Inequality operator
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Outlier::Removal & get() const
Definition: Settings.h:7402
Zivid::Settings::Processing::Filters::set
Filters & set(const Reflection::Removal::Enabled &value)
Set Reflection::Removal::Enabled
Definition: Settings.h:7226
Zivid::Settings::Processing::Filters::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:7529
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Outlier::Removal::Enabled & get() const
Definition: Settings.h:7411
Zivid::Settings::Processing::Filters::copyWith
Filters copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:7033
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold & get() const
Definition: Settings.h:7350
Zivid::Settings::Processing::Filters::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Noise::Removal::Enabled & get() const
Definition: Settings.h:7376
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Smoothing & get() const
Definition: Settings.h:7454
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Reflection::Removal & get() const
Definition: Settings.h:7437
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Reflection & get() const
Definition: Settings.h:7428
Zivid::Settings::Processing::Filters::set
Filters & set(const Outlier::Removal::Threshold &value)
Set Outlier::Removal::Threshold
Definition: Settings.h:7193
Zivid::Settings::Processing::Filters::set
Filters & set(const Experimental::ContrastDistortion::Correction::Strength &value)
Set Experimental::ContrastDistortion::Correction::Strength
Definition: Settings.h:7092
Zivid::Settings::Processing::Filters::Descendants
std::tuple< Settings::Processing::Filters::Experimental, Settings::Processing::Filters::Experimental::ContrastDistortion, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold, Settings::Processing::Filters::Noise, Settings::Processing::Filters::Noise::Removal, Settings::Processing::Filters::Noise::Removal::Enabled, Settings::Processing::Filters::Noise::Removal::Threshold, Settings::Processing::Filters::Outlier, Settings::Processing::Filters::Outlier::Removal, Settings::Processing::Filters::Outlier::Removal::Enabled, Settings::Processing::Filters::Outlier::Removal::Threshold, Settings::Processing::Filters::Reflection, Settings::Processing::Filters::Reflection::Removal, Settings::Processing::Filters::Reflection::Removal::Enabled, Settings::Processing::Filters::Smoothing, Settings::Processing::Filters::Smoothing::Gaussian, Settings::Processing::Filters::Smoothing::Gaussian::Enabled, Settings::Processing::Filters::Smoothing::Gaussian::Sigma > Descendants
Definition: Settings.h:6883
Zivid::Settings::Processing::Filters::set
Filters & set(const Experimental &value)
Set Experimental
Definition: Settings.h:7064
Zivid::Settings::Processing::Filters::outlier
Outlier & outlier()
Get Outlier
Definition: Settings.h:7166
Zivid::Settings::Processing::Filters::set
Filters & set(const Outlier::Removal &value)
Set Outlier::Removal
Definition: Settings.h:7179
Zivid::Settings::Processing::Filters::experimental
const Experimental & experimental() const
Get Experimental
Definition: Settings.h:7052
Zivid::Settings::Processing::Filters::set
Filters & set(const Experimental::ContrastDistortion &value)
Set Experimental::ContrastDistortion
Definition: Settings.h:7071
Zivid::Settings::Processing::Filters::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Filters &value)
Operator to send the value as string to a stream
Definition: Settings.h:7548
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Reflection::Removal::Enabled & get() const
Definition: Settings.h:7446
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Outlier & get() const
Definition: Settings.h:7393
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Experimental::ContrastDistortion & get() const
Definition: Settings.h:7284
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Smoothing::Gaussian::Sigma & get() const
Definition: Settings.h:7481
Zivid::Settings::Processing::Filters::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:6979
Zivid::Settings::Processing::Filters::reflection
const Reflection & reflection() const
Get Reflection
Definition: Settings.h:7200
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Experimental & get() const
Definition: Settings.h:7275
Zivid::Settings::Processing::Filters::set
Filters & set(const Noise::Removal::Threshold &value)
Set Noise::Removal::Threshold
Definition: Settings.h:7153
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Smoothing::Gaussian::Enabled & get() const
Definition: Settings.h:7472
Zivid::Settings::Processing::Filters::set
Filters & set(const Reflection &value)
Set Reflection
Definition: Settings.h:7212
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength & get() const
Definition: Settings.h:7317
Zivid::Settings::Processing::Filters::set
Filters & set(const Experimental::ContrastDistortion::Removal &value)
Set Experimental::ContrastDistortion::Removal
Definition: Settings.h:7099
Zivid::Settings::Processing::Filters::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:7518
Zivid::Settings::Processing::Filters::set
Filters & set(const Outlier &value)
Set Outlier
Definition: Settings.h:7172
Zivid::Settings::Processing::Filters::noise
const Noise & noise() const
Get Noise
Definition: Settings.h:7120
Zivid::Settings::Processing::Filters::set
Filters & set(const Experimental::ContrastDistortion::Correction &value)
Set Experimental::ContrastDistortion::Correction
Definition: Settings.h:7078
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled & get() const
Definition: Settings.h:7306
Zivid::Settings::Processing::Filters::set
Filters & set(const Reflection::Removal &value)
Set Reflection::Removal
Definition: Settings.h:7219
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Noise::Removal & get() const
Definition: Settings.h:7367
Zivid::Settings::Processing::Filters::set
Filters & set(const Noise::Removal::Enabled &value)
Set Noise::Removal::Enabled
Definition: Settings.h:7146
Zivid::Settings::Processing::Filters::set
Filters & set(const Smoothing::Gaussian::Enabled &value)
Set Smoothing::Gaussian::Enabled
Definition: Settings.h:7259
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Noise & get() const
Definition: Settings.h:7359
Zivid::Settings::Processing::Filters::set
Filters & set(const Experimental::ContrastDistortion::Removal::Threshold &value)
Set Experimental::ContrastDistortion::Removal::Threshold
Definition: Settings.h:7113
Zivid::Settings::Processing::Filters::set
Filters & set(const Smoothing::Gaussian &value)
Set Smoothing::Gaussian
Definition: Settings.h:7252
Zivid::Settings::Processing::Filters::operator==
bool operator==(const Filters &other) const
Equality operator
Zivid::Settings::Processing::Filters::set
Filters & set(const Outlier::Removal::Enabled &value)
Set Outlier::Removal::Enabled
Definition: Settings.h:7186
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled & get() const
Definition: Settings.h:7339
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal & get() const
Definition: Settings.h:7328
Zivid::Settings::Processing::Filters::Filters
Filters(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:6931
Zivid::Settings::Processing::Filters::noise
Noise & noise()
Get Noise
Definition: Settings.h:7126
Zivid::Settings::Processing::Filters::set
Filters & set(const Smoothing &value)
Set Smoothing
Definition: Settings.h:7245
Zivid::Settings::Processing::Filters::set
Filters & set(const Experimental::ContrastDistortion::Correction::Enabled &value)
Set Experimental::ContrastDistortion::Correction::Enabled
Definition: Settings.h:7085
Zivid::Settings::Processing::Filters::set
Filters & set(const Noise::Removal &value)
Set Noise::Removal
Definition: Settings.h:7139
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Outlier::Removal::Threshold & get() const
Definition: Settings.h:7420
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Noise::Removal::Threshold & get() const
Definition: Settings.h:7385
Zivid::Settings::Processing::Filters::smoothing
Smoothing & smoothing()
Get Smoothing
Definition: Settings.h:7239
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Smoothing::Gaussian & get() const
Definition: Settings.h:7463
Zivid::Settings::Processing::Filters::set
Filters & set(const Experimental::ContrastDistortion::Removal::Enabled &value)
Set Experimental::ContrastDistortion::Removal::Enabled
Definition: Settings.h:7106
Zivid::Settings::Processing::Filters::outlier
const Outlier & outlier() const
Get Outlier
Definition: Settings.h:7160
Zivid::Settings::Processing::Filters::reflection
Reflection & reflection()
Get Reflection
Definition: Settings.h:7206
Zivid::Settings::Processing::Filters::set
Filters & set(const Noise &value)
Set Noise
Definition: Settings.h:7132
Zivid::Settings::Processing::Filters::set
Filters & set(const Smoothing::Gaussian::Sigma &value)
Set Smoothing::Gaussian::Sigma
Definition: Settings.h:7266
Zivid::Settings::Processing::Filters::smoothing
const Smoothing & smoothing() const
Get Smoothing
Definition: Settings.h:7233
Zivid::Settings::Processing::Filters::experimental
Experimental & experimental()
Get Experimental
Definition: Settings.h:7058
Zivid::Settings::Processing::Filters::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction & get() const
Definition: Settings.h:7295
Zivid::Settings::Processing
Settings related to processing of a capture, including filters and color balance
Definition: Settings.h:1312
Zivid::Settings::Processing::get
const Settings::Processing::Color::Experimental::ToneMapping::Enabled & get() const
Definition: Settings.h:8113
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal & get() const
Definition: Settings.h:8186
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Smoothing::Gaussian & get() const
Definition: Settings.h:8318
Zivid::Settings::Processing::Descendants
std::tuple< Settings::Processing::Color, Settings::Processing::Color::Balance, Settings::Processing::Color::Balance::Blue, Settings::Processing::Color::Balance::Green, Settings::Processing::Color::Balance::Red, Settings::Processing::Color::Experimental, Settings::Processing::Color::Experimental::ToneMapping, Settings::Processing::Color::Experimental::ToneMapping::Enabled, Settings::Processing::Color::Gamma, Settings::Processing::Filters, Settings::Processing::Filters::Experimental, Settings::Processing::Filters::Experimental::ContrastDistortion, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold, Settings::Processing::Filters::Noise, Settings::Processing::Filters::Noise::Removal, Settings::Processing::Filters::Noise::Removal::Enabled, Settings::Processing::Filters::Noise::Removal::Threshold, Settings::Processing::Filters::Outlier, Settings::Processing::Filters::Outlier::Removal, Settings::Processing::Filters::Outlier::Removal::Enabled, Settings::Processing::Filters::Outlier::Removal::Threshold, Settings::Processing::Filters::Reflection, Settings::Processing::Filters::Reflection::Removal, Settings::Processing::Filters::Reflection::Removal::Enabled, Settings::Processing::Filters::Smoothing, Settings::Processing::Filters::Smoothing::Gaussian, Settings::Processing::Filters::Smoothing::Gaussian::Enabled, Settings::Processing::Filters::Smoothing::Gaussian::Sigma > Descendants
Definition: Settings.h:7602
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Reflection::Removal::Enabled & get() const
Definition: Settings.h:8302
Zivid::Settings::Processing::set
Processing & set(const Color::Experimental &value)
Set Color::Experimental
Definition: Settings.h:7846
Zivid::Settings::Processing::set
Processing & set(const Color &value)
Set Color
Definition: Settings.h:7811
Zivid::Settings::Processing::get
const Settings::Processing::Color::Balance::Red & get() const
Definition: Settings.h:8087
Zivid::Settings::Processing::set
Processing & set(const Color::Experimental::ToneMapping::Enabled &value)
Set Color::Experimental::ToneMapping::Enabled
Definition: Settings.h:7860
Zivid::Settings::Processing::set
Processing & set(const Color::Balance &value)
Set Color::Balance
Definition: Settings.h:7818
Zivid::Settings::Processing::set
Processing & set(const Filters::Smoothing::Gaussian &value)
Set Filters::Smoothing::Gaussian
Definition: Settings.h:8033
Zivid::Settings::Processing::copyWith
Processing copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:7781
Zivid::Settings::Processing::filters
Filters & filters()
Get Filters
Definition: Settings.h:7880
Zivid::Settings::Processing::set
Processing & set(const Filters::Smoothing::Gaussian::Enabled &value)
Set Filters::Smoothing::Gaussian::Enabled
Definition: Settings.h:8040
Zivid::Settings::Processing::get
const Settings::Processing::Color::Gamma & get() const
Definition: Settings.h:8120
Zivid::Settings::Processing::set
Processing & set(const Filters::Experimental::ContrastDistortion::Removal &value)
Set Filters::Experimental::ContrastDistortion::Removal
Definition: Settings.h:7928
Zivid::Settings::Processing::Processing
Processing()
Default constructor
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Smoothing & get() const
Definition: Settings.h:8310
Zivid::Settings::Processing::set
Processing & set(const Filters::Experimental::ContrastDistortion::Removal::Threshold &value)
Set Filters::Experimental::ContrastDistortion::Removal::Threshold
Definition: Settings.h:7942
Zivid::Settings::Processing::get
const Settings::Processing::Color::Balance::Green & get() const
Definition: Settings.h:8079
Zivid::Settings::Processing::set
Processing & set(const Filters::Outlier::Removal &value)
Set Filters::Outlier::Removal
Definition: Settings.h:7984
Zivid::Settings::Processing::set
Processing & set(const Filters::Experimental::ContrastDistortion::Removal::Enabled &value)
Set Filters::Experimental::ContrastDistortion::Removal::Enabled
Definition: Settings.h:7935
Zivid::Settings::Processing::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Processing &value)
Operator to send the value as string to a stream
Definition: Settings.h:8379
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled & get() const
Definition: Settings.h:8197
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Reflection::Removal & get() const
Definition: Settings.h:8293
Zivid::Settings::Processing::toString
std::string toString() const
Get the value as string
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Noise::Removal::Threshold & get() const
Definition: Settings.h:8243
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Smoothing::Gaussian::Sigma & get() const
Definition: Settings.h:8336
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Noise::Removal::Enabled & get() const
Definition: Settings.h:8234
Zivid::Settings::Processing::set
Processing & set(const Color::Balance::Blue &value)
Set Color::Balance::Blue
Definition: Settings.h:7825
Zivid::Settings::Processing::color
Color & color()
Get Color
Definition: Settings.h:7805
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Smoothing::Gaussian::Enabled & get() const
Definition: Settings.h:8327
Zivid::Settings::Processing::set
Processing & set(const Filters::Reflection &value)
Set Filters::Reflection
Definition: Settings.h:8005
Zivid::Settings::Processing::set
Processing & set(const Filters::Noise &value)
Set Filters::Noise
Definition: Settings.h:7949
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Outlier & get() const
Definition: Settings.h:8251
Zivid::Settings::Processing::get
const Settings::Processing::Filters & get() const
Definition: Settings.h:8127
Zivid::Settings::Processing::set
Processing & set(const Filters::Experimental::ContrastDistortion::Correction::Strength &value)
Set Filters::Experimental::ContrastDistortion::Correction::Strength
Definition: Settings.h:7921
Zivid::Settings::Processing::set
Processing & set(const Filters::Noise::Removal::Enabled &value)
Set Filters::Noise::Removal::Enabled
Definition: Settings.h:7963
Zivid::Settings::Processing::set
Processing & set(const Filters::Smoothing &value)
Set Filters::Smoothing
Definition: Settings.h:8026
Zivid::Settings::Processing::get
const Settings::Processing::Color::Balance & get() const
Definition: Settings.h:8063
Zivid::Settings::Processing::filters
const Filters & filters() const
Get Filters
Definition: Settings.h:7874
Zivid::Settings::Processing::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:8363
Zivid::Settings::Processing::set
Processing & set(const Filters::Smoothing::Gaussian::Sigma &value)
Set Filters::Smoothing::Gaussian::Sigma
Definition: Settings.h:8047
Zivid::Settings::Processing::set
Processing & set(const Filters::Noise::Removal &value)
Set Filters::Noise::Removal
Definition: Settings.h:7956
Zivid::Settings::Processing::set
Processing & set(const Filters::Outlier::Removal::Enabled &value)
Set Filters::Outlier::Removal::Enabled
Definition: Settings.h:7991
Zivid::Settings::Processing::set
Processing & set(const Filters::Noise::Removal::Threshold &value)
Set Filters::Noise::Removal::Threshold
Definition: Settings.h:7970
Zivid::Settings::Processing::get
const Settings::Processing::Color::Balance::Blue & get() const
Definition: Settings.h:8071
Zivid::Settings::Processing::set
Processing & set(const Filters::Experimental &value)
Set Filters::Experimental
Definition: Settings.h:7893
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Noise::Removal & get() const
Definition: Settings.h:8225
Zivid::Settings::Processing::set
Processing & set(const Filters::Outlier::Removal::Threshold &value)
Set Filters::Outlier::Removal::Threshold
Definition: Settings.h:7998
Zivid::Settings::Processing::set
Processing & set(const Color::Balance::Green &value)
Set Color::Balance::Green
Definition: Settings.h:7832
Zivid::Settings::Processing::get
const Settings::Processing::Color::Experimental & get() const
Definition: Settings.h:8095
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength & get() const
Definition: Settings.h:8175
Zivid::Settings::Processing::set
Processing & set(const Filters::Outlier &value)
Set Filters::Outlier
Definition: Settings.h:7977
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled & get() const
Definition: Settings.h:8164
Zivid::Settings::Processing::set
Processing & set(const Filters::Reflection::Removal::Enabled &value)
Set Filters::Reflection::Removal::Enabled
Definition: Settings.h:8019
Zivid::Settings::Processing::set
Processing & set(const Filters::Experimental::ContrastDistortion::Correction::Enabled &value)
Set Filters::Experimental::ContrastDistortion::Correction::Enabled
Definition: Settings.h:7914
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Outlier::Removal::Threshold & get() const
Definition: Settings.h:8277
Zivid::Settings::Processing::set
Processing & set(const Filters::Reflection::Removal &value)
Set Filters::Reflection::Removal
Definition: Settings.h:8012
Zivid::Settings::Processing::Processing
Processing(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:7660
Zivid::Settings::Processing::set
Processing & set(const Filters::Experimental::ContrastDistortion::Correction &value)
Set Filters::Experimental::ContrastDistortion::Correction
Definition: Settings.h:7907
Zivid::Settings::Processing::get
const Settings::Processing::Color & get() const
Definition: Settings.h:8055
Zivid::Settings::Processing::operator==
bool operator==(const Processing &other) const
Equality operator
Zivid::Settings::Processing::color
const Color & color() const
Get Color
Definition: Settings.h:7799
Zivid::Settings::Processing::set
Processing & set(const Filters::Experimental::ContrastDistortion &value)
Set Filters::Experimental::ContrastDistortion
Definition: Settings.h:7900
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Reflection & get() const
Definition: Settings.h:8285
Zivid::Settings::Processing::get
const Settings::Processing::Color::Experimental::ToneMapping & get() const
Definition: Settings.h:8104
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Outlier::Removal::Enabled & get() const
Definition: Settings.h:8268
Zivid::Settings::Processing::set
Processing & set(const Filters &value)
Set Filters
Definition: Settings.h:7886
Zivid::Settings::Processing::set
Processing & set(const Color::Balance::Red &value)
Set Color::Balance::Red
Definition: Settings.h:7839
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Noise & get() const
Definition: Settings.h:8217
Zivid::Settings::Processing::operator!=
bool operator!=(const Processing &other) const
Inequality operator
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Experimental & get() const
Definition: Settings.h:8135
Zivid::Settings::Processing::set
Processing & set(const Color::Gamma &value)
Set Color::Gamma
Definition: Settings.h:7867
Zivid::Settings::Processing::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:7718
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold & get() const
Definition: Settings.h:8208
Zivid::Settings::Processing::set
Processing & set(const Color::Experimental::ToneMapping &value)
Set Color::Experimental::ToneMapping
Definition: Settings.h:7853
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction & get() const
Definition: Settings.h:8154
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Experimental::ContrastDistortion & get() const
Definition: Settings.h:8144
Zivid::Settings::Processing::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:8355
Zivid::Settings::Processing::get
const Settings::Processing::Filters::Outlier::Removal & get() const
Definition: Settings.h:8259
Zivid::Settings
Settings used when capturing with a Zivid camera
Definition: Settings.h:120
Zivid::Settings::get
const Settings::Processing::Filters::Outlier::Removal::Enabled & get() const
Definition: Settings.h:9177
Zivid::Settings::Settings
Settings(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:8499
Zivid::Settings::get
const Settings::Processing::Filters::Outlier & get() const
Definition: Settings.h:9160
Zivid::Settings::get
const Settings::Processing::Color::Balance & get() const
Definition: Settings.h:8974
Zivid::Settings::set
Settings & set(const Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &value)
Set Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled
Definition: Settings.h:8822
Zivid::Settings::experimental
const Experimental & experimental() const
Get Experimental
Definition: Settings.h:8665
Zivid::Settings::get
const Settings::Processing::Color::Balance::Red & get() const
Definition: Settings.h:8998
Zivid::Settings::set
Settings & set(const Processing::Filters::Smoothing &value)
Set Processing::Filters::Smoothing
Definition: Settings.h:8913
Zivid::Settings::get
const Settings::Processing::Filters::Noise::Removal & get() const
Definition: Settings.h:9136
Zivid::Settings::copyWith
Settings copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:8628
Zivid::Settings::processing
const Processing & processing() const
Get Processing
Definition: Settings.h:8691
Zivid::Settings::get
const Settings::Experimental & get() const
Definition: Settings.h:8947
Zivid::Settings::get
const Settings::Processing::Color::Gamma & get() const
Definition: Settings.h:9030
Zivid::Settings::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal & get() const
Definition: Settings.h:9097
Zivid::Settings::set
Settings & set(const Processing &value)
Set Processing
Definition: Settings.h:8703
Zivid::Settings::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold & get() const
Definition: Settings.h:9120
Zivid::Settings::set
Settings & set(const Processing::Filters::Outlier::Removal::Enabled &value)
Set Processing::Filters::Outlier::Removal::Enabled
Definition: Settings.h:8878
Zivid::Settings::set
Settings & set(const Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &value)
Set Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold
Definition: Settings.h:8829
Zivid::Settings::set
Settings & set(const Experimental::Engine &value)
Set Experimental::Engine
Definition: Settings.h:8684
Zivid::Settings::set
Settings & set(const Processing::Filters::Smoothing::Gaussian &value)
Set Processing::Filters::Smoothing::Gaussian
Definition: Settings.h:8920
Zivid::Settings::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled & get() const
Definition: Settings.h:9108
Zivid::Settings::set
Settings & set(const Processing::Filters::Noise &value)
Set Processing::Filters::Noise
Definition: Settings.h:8836
Zivid::Settings::load
void load(const std::string &fileName)
Load from the given file
Zivid::Settings::get
const Settings::Acquisitions & get() const
Definition: Settings.h:8941
Zivid::Settings::get
const Settings::Processing::Filters::Experimental & get() const
Definition: Settings.h:9045
Zivid::Settings::get
const Settings::Processing::Filters::Outlier::Removal & get() const
Definition: Settings.h:9168
Zivid::Settings::get
const Settings::Processing::Filters::Smoothing::Gaussian::Sigma & get() const
Definition: Settings.h:9245
Zivid::Settings::get
const Settings::Processing::Filters::Smoothing::Gaussian::Enabled & get() const
Definition: Settings.h:9236
Zivid::Settings::set
Settings & set(const Processing::Color::Balance &value)
Set Processing::Color::Balance
Definition: Settings.h:8717
Zivid::Settings::get
const Settings::Processing::Filters::Noise::Removal::Enabled & get() const
Definition: Settings.h:9144
Zivid::Settings::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction & get() const
Definition: Settings.h:9064
Zivid::Settings::forEach
void forEach(const F &f) const
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:9270
Zivid::Settings::get
const Settings::Processing::Color::Balance::Green & get() const
Definition: Settings.h:8990
Zivid::Settings::set
Settings & set(const Processing::Filters::Smoothing::Gaussian::Enabled &value)
Set Processing::Filters::Smoothing::Gaussian::Enabled
Definition: Settings.h:8927
Zivid::Settings::get
const Settings::Processing & get() const
Definition: Settings.h:8960
Zivid::Settings::set
Settings & set(const Processing::Filters::Reflection &value)
Set Processing::Filters::Reflection
Definition: Settings.h:8892
Zivid::Settings::get
const Settings::Experimental::Engine & get() const
Definition: Settings.h:8954
Zivid::Settings::forEach
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:9279
Zivid::Settings::Settings
Settings()
Default constructor
Zivid::Settings::get
const Settings::Processing::Filters::Experimental::ContrastDistortion & get() const
Definition: Settings.h:9054
Zivid::Settings::set
Settings & set(const Processing::Filters::Outlier::Removal::Threshold &value)
Set Processing::Filters::Outlier::Removal::Threshold
Definition: Settings.h:8885
Zivid::Settings::get
const Settings::Processing::Color::Experimental::ToneMapping::Enabled & get() const
Definition: Settings.h:9023
Zivid::Settings::set
Settings & set(const Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &value)
Set Processing::Filters::Experimental::ContrastDistortion::Correction::Strength
Definition: Settings.h:8808
Zivid::Settings::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength & get() const
Definition: Settings.h:9087
Zivid::Settings::get
const Settings::Processing::Color::Balance::Blue & get() const
Definition: Settings.h:8982
Zivid::Settings::acquisitions
const Acquisitions & acquisitions() const
Get Acquisitions
Definition: Settings.h:8646
Zivid::Settings::set
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:8561
Zivid::Settings::get
const Settings::Processing::Filters::Reflection & get() const
Definition: Settings.h:9194
Zivid::Settings::set
Settings & set(const Processing::Filters::Experimental &value)
Set Processing::Filters::Experimental
Definition: Settings.h:8780
Zivid::Settings::get
const Settings::Processing::Filters::Smoothing & get() const
Definition: Settings.h:9219
Zivid::Settings::get
const Settings::Processing::Filters & get() const
Definition: Settings.h:9037
Zivid::Settings::set
Settings & set(const Processing::Color::Experimental &value)
Set Processing::Color::Experimental
Definition: Settings.h:8745
Zivid::Settings::save
void save(const std::string &fileName) const
Save to the given file
Zivid::Settings::get
const Settings::Processing::Color::Experimental & get() const
Definition: Settings.h:9006
Zivid::Settings::set
Settings & set(const Processing::Filters::Experimental::ContrastDistortion::Removal &value)
Set Processing::Filters::Experimental::ContrastDistortion::Removal
Definition: Settings.h:8815
Zivid::Settings::set
Settings & set(const Processing::Color &value)
Set Processing::Color
Definition: Settings.h:8710
Zivid::Settings::experimental
Experimental & experimental()
Get Experimental
Definition: Settings.h:8671
Zivid::Settings::set
Settings & set(const Processing::Filters::Outlier &value)
Set Processing::Filters::Outlier
Definition: Settings.h:8864
Zivid::Settings::operator==
bool operator==(const Settings &other) const
Equality operator
Zivid::Settings::acquisitions
Acquisitions & acquisitions()
Get Acquisitions
Definition: Settings.h:8652
Zivid::Settings::set
Settings & set(const Processing::Filters::Reflection::Removal &value)
Set Processing::Filters::Reflection::Removal
Definition: Settings.h:8899
Zivid::Settings::Settings
Settings(const std::string &fileName)
Construct Settings by loading from file
Zivid::Settings::set
Settings & set(const Processing::Color::Balance::Red &value)
Set Processing::Color::Balance::Red
Definition: Settings.h:8738
Zivid::Settings::get
const Settings::Processing::Filters::Noise::Removal::Threshold & get() const
Definition: Settings.h:9153
Zivid::Settings::set
Settings & set(const Processing::Filters::Reflection::Removal::Enabled &value)
Set Processing::Filters::Reflection::Removal::Enabled
Definition: Settings.h:8906
Zivid::Settings::processing
Processing & processing()
Get Processing
Definition: Settings.h:8697
Zivid::Settings::Descendants
std::tuple< Settings::Acquisitions, Settings::Experimental, Settings::Experimental::Engine, Settings::Processing, Settings::Processing::Color, Settings::Processing::Color::Balance, Settings::Processing::Color::Balance::Blue, Settings::Processing::Color::Balance::Green, Settings::Processing::Color::Balance::Red, Settings::Processing::Color::Experimental, Settings::Processing::Color::Experimental::ToneMapping, Settings::Processing::Color::Experimental::ToneMapping::Enabled, Settings::Processing::Color::Gamma, Settings::Processing::Filters, Settings::Processing::Filters::Experimental, Settings::Processing::Filters::Experimental::ContrastDistortion, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold, Settings::Processing::Filters::Noise, Settings::Processing::Filters::Noise::Removal, Settings::Processing::Filters::Noise::Removal::Enabled, Settings::Processing::Filters::Noise::Removal::Threshold, Settings::Processing::Filters::Outlier, Settings::Processing::Filters::Outlier::Removal, Settings::Processing::Filters::Outlier::Removal::Enabled, Settings::Processing::Filters::Outlier::Removal::Threshold, Settings::Processing::Filters::Reflection, Settings::Processing::Filters::Reflection::Removal, Settings::Processing::Filters::Reflection::Removal::Enabled, Settings::Processing::Filters::Smoothing, Settings::Processing::Filters::Smoothing::Gaussian, Settings::Processing::Filters::Smoothing::Gaussian::Enabled, Settings::Processing::Filters::Smoothing::Gaussian::Sigma > Descendants
Definition: Settings.h:8434
Zivid::Settings::get
const Settings::Processing::Filters::Noise & get() const
Definition: Settings.h:9128
Zivid::Settings::toString
std::string toString() const
Get the value as string
Zivid::Settings::get
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled & get() const
Definition: Settings.h:9075
Zivid::Settings::set
Settings & set(const Processing::Filters::Experimental::ContrastDistortion &value)
Set Processing::Filters::Experimental::ContrastDistortion
Definition: Settings.h:8787
Zivid::Settings::set
Settings & set(const Processing::Color::Gamma &value)
Set Processing::Color::Gamma
Definition: Settings.h:8766
Zivid::Settings::set
Settings & set(const Processing::Filters::Noise::Removal::Threshold &value)
Set Processing::Filters::Noise::Removal::Threshold
Definition: Settings.h:8857
Zivid::Settings::set
Settings & set(const Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &value)
Set Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled
Definition: Settings.h:8801
Zivid::Settings::set
Settings & set(const Acquisitions &value)
Set Acquisitions
Definition: Settings.h:8658
Zivid::Settings::set
Settings & set(const Processing::Filters::Smoothing::Gaussian::Sigma &value)
Set Processing::Filters::Smoothing::Gaussian::Sigma
Definition: Settings.h:8934
Zivid::Settings::operator!=
bool operator!=(const Settings &other) const
Inequality operator
Zivid::Settings::set
Settings & set(const Processing::Filters::Noise::Removal &value)
Set Processing::Filters::Noise::Removal
Definition: Settings.h:8843
Zivid::Settings::get
const Settings::Processing::Color::Experimental::ToneMapping & get() const
Definition: Settings.h:9014
Zivid::Settings::set
Settings & set(const Processing::Filters::Outlier::Removal &value)
Set Processing::Filters::Outlier::Removal
Definition: Settings.h:8871
Zivid::Settings::set
Settings & set(const Processing::Color::Experimental::ToneMapping::Enabled &value)
Set Processing::Color::Experimental::ToneMapping::Enabled
Definition: Settings.h:8759
Zivid::Settings::set
Settings & set(const Processing::Filters::Noise::Removal::Enabled &value)
Set Processing::Filters::Noise::Removal::Enabled
Definition: Settings.h:8850
Zivid::Settings::set
Settings & set(const Processing::Filters::Experimental::ContrastDistortion::Correction &value)
Set Processing::Filters::Experimental::ContrastDistortion::Correction
Definition: Settings.h:8794
Zivid::Settings::get
const Settings::Processing::Color & get() const
Definition: Settings.h:8967
Zivid::Settings::set
Settings & set(const Processing::Color::Experimental::ToneMapping &value)
Set Processing::Color::Experimental::ToneMapping
Definition: Settings.h:8752
Zivid::Settings::get
const Settings::Processing::Filters::Reflection::Removal::Enabled & get() const
Definition: Settings.h:9211
Zivid::Settings::get
const Settings::Processing::Filters::Reflection::Removal & get() const
Definition: Settings.h:9202
Zivid::Settings::set
Settings & set(const Processing::Color::Balance::Green &value)
Set Processing::Color::Balance::Green
Definition: Settings.h:8731
Zivid::Settings::set
Settings & set(const Processing::Filters &value)
Set Processing::Filters
Definition: Settings.h:8773
Zivid::Settings::set
Settings & set(const Experimental &value)
Set Experimental
Definition: Settings.h:8677
Zivid::Settings::get
const Settings::Processing::Filters::Outlier::Removal::Threshold & get() const
Definition: Settings.h:9186
Zivid::Settings::set
Settings & set(const Processing::Color::Balance::Blue &value)
Set Processing::Color::Balance::Blue
Definition: Settings.h:8724
Zivid::Settings::get
const Settings::Processing::Filters::Smoothing::Gaussian & get() const
Definition: Settings.h:9227
Zivid::Settings::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Settings &value)
Operator to send the value as string to a stream
Definition: Settings.h:9296
Zivid::DataModel::NodeType
NodeType
Definition: NodeType.h:100
Zivid::Experimental::SettingsInfo::validRange
Ret validRange(const CameraInfo &cameraInfo)
Definition: SettingsInfo.h:201
Zivid
The main Zivid namespace. All Zivid code is found here
Definition: Application.h:99
Generated by doxygen 1.9.2