Zivid C++ API 2.9.0+4dbba385-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-2023 (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
109#include "Zivid/Point.h"
110#include "Zivid/Range.h"
111
112#ifdef _MSC_VER
113# pragma warning(push)
114# pragma warning(disable : 4251) // "X needs to have dll-interface to be used by clients of class Y."
115#endif
116
117namespace Zivid
118{
119
121
122 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
124 {
125 public:
128
130 static constexpr const char *path{ "" };
131
133 static constexpr const char *name{ "Settings" };
134
136 static constexpr const char *description{
137 R"description(Settings used when capturing with a Zivid camera)description"
138 };
139
140 static constexpr size_t version{ 17 };
141
142#ifndef NO_DOC
143 template<size_t>
144 struct Version;
145
146 using LatestVersion = Zivid::Settings;
147
148 // Short identifier. This value is not guaranteed to be universally unique
149 // Todo(ZIVID-2808): Move this to internal DataModelExt header
150 static constexpr std::array<uint8_t, 3> binaryId{ 's', 'e', 't' };
151
152#endif
153
155
156 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
158 {
159 public:
162
164 static constexpr const char *path{ "Acquisition" };
165
167 static constexpr const char *name{ "Acquisition" };
168
170 static constexpr const char *description{ R"description(Settings for a single acquisition)description" };
171
175
176 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
178 {
179 public:
182
184 static constexpr const char *path{ "Acquisition/Aperture" };
185
187 static constexpr const char *name{ "Aperture" };
188
190 static constexpr const char *description{
191 R"description(Aperture setting for the camera. Specified as an f-number (the ratio of lens focal length to
192the effective aperture diameter).
193)description"
194 };
195
197 using ValueType = double;
198
200 static constexpr Range<double> validRange()
201 {
202 return { 1.4, 32.0 };
203 }
204
206 Aperture() = default;
207
209 explicit constexpr Aperture(double value)
210 : m_opt{ verifyValue(value) }
211 {}
212
217 double value() const;
218
220 bool hasValue() const;
221
223 void reset();
224
226 std::string toString() const;
227
229 bool operator==(const Aperture &other) const
230 {
231 return m_opt == other.m_opt;
232 }
233
235 bool operator!=(const Aperture &other) const
236 {
237 return m_opt != other.m_opt;
238 }
239
241 bool operator<(const Aperture &other) const
242 {
243 return m_opt < other.m_opt;
244 }
245
247 bool operator>(const Aperture &other) const
248 {
249 return m_opt > other.m_opt;
250 }
251
253 bool operator<=(const Aperture &other) const
254 {
255 return m_opt <= other.m_opt;
256 }
257
259 bool operator>=(const Aperture &other) const
260 {
261 return m_opt >= other.m_opt;
262 }
263
265 friend std::ostream &operator<<(std::ostream &stream, const Aperture &value)
266 {
267 return stream << value.toString();
268 }
269
270 private:
271 void setFromString(const std::string &value);
272
273 constexpr ValueType static verifyValue(const ValueType &value)
274 {
275 return validRange().isInRange(value)
276 ? value
277 : throw std::out_of_range{ "Aperture{ " + std::to_string(value) + " } is not in range ["
278 + std::to_string(validRange().min()) + ", "
279 + std::to_string(validRange().max()) + "]" };
280 }
281
282 Zivid::DataModel::Detail::Optional<double> m_opt;
283
284 friend struct DataModel::Detail::Befriend<Aperture>;
285 };
286
298
299 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
301 {
302 public:
305
307 static constexpr const char *path{ "Acquisition/Brightness" };
308
310 static constexpr const char *name{ "Brightness" };
311
313 static constexpr const char *description{
314 R"description(Brightness controls the light output from the projector.
315
316Brightness above 1.0 may be needed when the distance between the camera and the scene is large,
317or in case of high levels of ambient lighting.
318
319When brightness is above 1.0 the duty cycle of the camera (the percentage of time the camera
320can capture) will be reduced. The duty cycle in boost mode is 50%. The duty cycle is calculated
321over a 10 second period. This limitation is enforced automatically by the camera. Calling capture
322when the duty cycle limit has been reached will cause the camera to first wait (sleep) for a
323duration of time to cool down, before capture will start.
324)description"
325 };
326
328 using ValueType = double;
329
331 static constexpr Range<double> validRange()
332 {
333 return { 0, 2.5 };
334 }
335
337 Brightness() = default;
338
340 explicit constexpr Brightness(double value)
341 : m_opt{ verifyValue(value) }
342 {}
343
348 double value() const;
349
351 bool hasValue() const;
352
354 void reset();
355
357 std::string toString() const;
358
360 bool operator==(const Brightness &other) const
361 {
362 return m_opt == other.m_opt;
363 }
364
366 bool operator!=(const Brightness &other) const
367 {
368 return m_opt != other.m_opt;
369 }
370
372 bool operator<(const Brightness &other) const
373 {
374 return m_opt < other.m_opt;
375 }
376
378 bool operator>(const Brightness &other) const
379 {
380 return m_opt > other.m_opt;
381 }
382
384 bool operator<=(const Brightness &other) const
385 {
386 return m_opt <= other.m_opt;
387 }
388
390 bool operator>=(const Brightness &other) const
391 {
392 return m_opt >= other.m_opt;
393 }
394
396 friend std::ostream &operator<<(std::ostream &stream, const Brightness &value)
397 {
398 return stream << value.toString();
399 }
400
401 private:
402 void setFromString(const std::string &value);
403
404 constexpr ValueType static verifyValue(const ValueType &value)
405 {
406 return validRange().isInRange(value)
407 ? value
408 : throw std::out_of_range{ "Brightness{ " + std::to_string(value)
409 + " } is not in range [" + std::to_string(validRange().min())
410 + ", " + std::to_string(validRange().max()) + "]" };
411 }
412
413 Zivid::DataModel::Detail::Optional<double> m_opt;
414
415 friend struct DataModel::Detail::Befriend<Brightness>;
416 };
417
419
420 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
422 {
423 public:
426
428 static constexpr const char *path{ "Acquisition/ExposureTime" };
429
431 static constexpr const char *name{ "ExposureTime" };
432
434 static constexpr const char *description{
435 R"description(Exposure time for each single image in the measurement. Affects frame rate.)description"
436 };
437
439 using ValueType = std::chrono::microseconds;
440
443 {
444 return { std::chrono::microseconds{ 1677 }, std::chrono::microseconds{ 100000 } };
445 }
446
448 ExposureTime() = default;
449
451 explicit constexpr ExposureTime(std::chrono::microseconds value)
452 : m_opt{ verifyValue(value) }
453 {}
454
459 std::chrono::microseconds value() const;
460
462 bool hasValue() const;
463
465 void reset();
466
468 std::string toString() const;
469
471 bool operator==(const ExposureTime &other) const
472 {
473 return m_opt == other.m_opt;
474 }
475
477 bool operator!=(const ExposureTime &other) const
478 {
479 return m_opt != other.m_opt;
480 }
481
483 bool operator<(const ExposureTime &other) const
484 {
485 return m_opt < other.m_opt;
486 }
487
489 bool operator>(const ExposureTime &other) const
490 {
491 return m_opt > other.m_opt;
492 }
493
495 bool operator<=(const ExposureTime &other) const
496 {
497 return m_opt <= other.m_opt;
498 }
499
501 bool operator>=(const ExposureTime &other) const
502 {
503 return m_opt >= other.m_opt;
504 }
505
507 friend std::ostream &operator<<(std::ostream &stream, const ExposureTime &value)
508 {
509 return stream << value.toString();
510 }
511
512 private:
513 void setFromString(const std::string &value);
514
515 constexpr ValueType static verifyValue(const ValueType &value)
516 {
517 return validRange().isInRange(value)
518 ? value
519 : throw std::out_of_range{ "ExposureTime{ " + std::to_string(value.count())
520 + " } is not in range ["
521 + std::to_string(validRange().min().count()) + ", "
522 + std::to_string(validRange().max().count()) + "]" };
523 }
524
525 Zivid::DataModel::Detail::Optional<std::chrono::microseconds> m_opt;
526
527 friend struct DataModel::Detail::Befriend<ExposureTime>;
528 };
529
531
532 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
534 {
535 public:
538
540 static constexpr const char *path{ "Acquisition/Gain" };
541
543 static constexpr const char *name{ "Gain" };
544
546 static constexpr const char *description{ R"description(Analog gain in the camera)description" };
547
549 using ValueType = double;
550
552 static constexpr Range<double> validRange()
553 {
554 return { 1, 16 };
555 }
556
558 Gain() = default;
559
561 explicit constexpr Gain(double value)
562 : m_opt{ verifyValue(value) }
563 {}
564
569 double value() const;
570
572 bool hasValue() const;
573
575 void reset();
576
578 std::string toString() const;
579
581 bool operator==(const Gain &other) const
582 {
583 return m_opt == other.m_opt;
584 }
585
587 bool operator!=(const Gain &other) const
588 {
589 return m_opt != other.m_opt;
590 }
591
593 bool operator<(const Gain &other) const
594 {
595 return m_opt < other.m_opt;
596 }
597
599 bool operator>(const Gain &other) const
600 {
601 return m_opt > other.m_opt;
602 }
603
605 bool operator<=(const Gain &other) const
606 {
607 return m_opt <= other.m_opt;
608 }
609
611 bool operator>=(const Gain &other) const
612 {
613 return m_opt >= other.m_opt;
614 }
615
617 friend std::ostream &operator<<(std::ostream &stream, const Gain &value)
618 {
619 return stream << value.toString();
620 }
621
622 private:
623 void setFromString(const std::string &value);
624
625 constexpr ValueType static verifyValue(const ValueType &value)
626 {
627 return validRange().isInRange(value)
628 ? value
629 : throw std::out_of_range{ "Gain{ " + std::to_string(value) + " } is not in range ["
630 + std::to_string(validRange().min()) + ", "
631 + std::to_string(validRange().max()) + "]" };
632 }
633
634 Zivid::DataModel::Detail::Optional<double> m_opt;
635
636 friend struct DataModel::Detail::Befriend<Gain>;
637 };
638
639 using Descendants = std::tuple<
644
647
662#ifndef NO_DOC
663 template<
664 typename... Args,
665 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
666 typename std::enable_if<
667 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
668 value,
669 int>::type = 0>
670#else
671 template<typename... Args>
672#endif
673 explicit Acquisition(Args &&...args)
674 {
675 using namespace Zivid::Detail::TypeTraits;
676
677 static_assert(
678 AllArgsDecayedAreUnique<Args...>::value,
679 "Found duplicate types among the arguments passed to Acquisition(...). "
680 "Types should be listed at most once.");
681
682 set(std::forward<Args>(args)...);
683 }
684
698#ifndef NO_DOC
699 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
700#else
701 template<typename... Args>
702#endif
703 void set(Args &&...args)
704 {
705 using namespace Zivid::Detail::TypeTraits;
706
707 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
708 static_assert(
709 AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
710
711 static_assert(
712 AllArgsDecayedAreUnique<Args...>::value,
713 "Found duplicate types among the arguments passed to set(...). "
714 "Types should be listed at most once.");
715
716 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
717 }
718
733#ifndef NO_DOC
734 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
735#else
736 template<typename... Args>
737#endif
738 Acquisition copyWith(Args &&...args) const
739 {
740 using namespace Zivid::Detail::TypeTraits;
741
742 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
743 static_assert(
744 AllArgsAreDescendantNodes::value,
745 "All arguments passed to copyWith(...) must be descendant nodes.");
746
747 static_assert(
748 AllArgsDecayedAreUnique<Args...>::value,
749 "Found duplicate types among the arguments passed to copyWith(...). "
750 "Types should be listed at most once.");
751
752 auto copy{ *this };
753 copy.set(std::forward<Args>(args)...);
754 return copy;
755 }
756
758 const Aperture &aperture() const
759 {
760 return m_aperture;
761 }
762
765 {
766 return m_aperture;
767 }
768
770 Acquisition &set(const Aperture &value)
771 {
772 m_aperture = value;
773 return *this;
774 }
775
777 const Brightness &brightness() const
778 {
779 return m_brightness;
780 }
781
784 {
785 return m_brightness;
786 }
787
790 {
791 m_brightness = value;
792 return *this;
793 }
794
797 {
798 return m_exposureTime;
799 }
800
803 {
804 return m_exposureTime;
805 }
806
809 {
810 m_exposureTime = value;
811 return *this;
812 }
813
815 const Gain &gain() const
816 {
817 return m_gain;
818 }
819
822 {
823 return m_gain;
824 }
825
827 Acquisition &set(const Gain &value)
828 {
829 m_gain = value;
830 return *this;
831 }
832
833 template<
834 typename T,
835 typename std::enable_if<std::is_same<T, Settings::Acquisition::Aperture>::value, int>::type = 0>
837 {
838 return m_aperture;
839 }
840
841 template<
842 typename T,
843 typename std::enable_if<std::is_same<T, Settings::Acquisition::Brightness>::value, int>::type = 0>
845 {
846 return m_brightness;
847 }
848
849 template<
850 typename T,
851 typename std::enable_if<std::is_same<T, Settings::Acquisition::ExposureTime>::value, int>::type = 0>
853 {
854 return m_exposureTime;
855 }
856
857 template<
858 typename T,
859 typename std::enable_if<std::is_same<T, Settings::Acquisition::Gain>::value, int>::type = 0>
861 {
862 return m_gain;
863 }
864
865 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
867 {
868 return m_aperture;
869 }
870
871 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
873 {
874 return m_brightness;
875 }
876
877 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
879 {
880 return m_exposureTime;
881 }
882
883 template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
885 {
886 return m_gain;
887 }
888
890 template<typename F>
891 void forEach(const F &f) const
892 {
893 f(m_aperture);
894 f(m_brightness);
895 f(m_exposureTime);
896 f(m_gain);
897 }
898
900 template<typename F>
901 void forEach(const F &f)
902 {
903 f(m_aperture);
904 f(m_brightness);
905 f(m_exposureTime);
906 f(m_gain);
907 }
908
910 bool operator==(const Acquisition &other) const;
911
913 bool operator!=(const Acquisition &other) const;
914
916 std::string toString() const;
917
919 friend std::ostream &operator<<(std::ostream &stream, const Acquisition &value)
920 {
921 return stream << value.toString();
922 }
923
924 private:
925 void setFromString(const std::string &value);
926
927 void setFromString(const std::string &fullPath, const std::string &value);
928
929 std::string getString(const std::string &fullPath) const;
930
931 Aperture m_aperture;
932 Brightness m_brightness;
933 ExposureTime m_exposureTime;
934 Gain m_gain;
935
936 friend struct DataModel::Detail::Befriend<Acquisition>;
937 };
938
940
941 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
943 {
944 public:
947
949 static constexpr const char *path{ "Acquisitions" };
950
952 static constexpr const char *name{ "Acquisitions" };
953
955 static constexpr const char *description{ R"description(List of Acquisition objects)description" };
956
958 using ValueType = std::vector<Settings::Acquisition>;
959
962 {
963 return { 0, std::numeric_limits<ValueType::size_type>::max() };
964 }
965
967 Acquisitions() = default;
968
970 explicit Acquisitions(std::vector<Settings::Acquisition> value)
971 : m_value{ std::move(value) }
972 {}
973
975 explicit Acquisitions(std::initializer_list<Settings::Acquisition> value)
976 : Acquisitions{ ValueType{ value } }
977 {}
978
980 const std::vector<Settings::Acquisition> &value() const;
981
983 std::string toString() const;
984
986 std::size_t size() const noexcept;
987
989 bool isEmpty() const noexcept;
990
996 template<typename... Args>
997 void emplaceBack(Args &&...args)
998 {
999 m_value.emplace_back(std::forward<Args>(args)...);
1000 }
1001
1007 Settings::Acquisition &at(std::size_t pos);
1008
1014 const Settings::Acquisition &at(std::size_t pos) const;
1015
1022
1028 const Settings::Acquisition &operator[](std::size_t pos) const;
1029
1031 template<typename F>
1032 void forEach(const F &f)
1033 {
1034 for(auto &child : m_value)
1035 {
1036 f(child);
1037 }
1038 }
1039
1041 template<typename F>
1042 void forEach(const F &f) const
1043 {
1044 for(const auto &child : m_value)
1045 {
1046 f(child);
1047 }
1048 }
1049
1051 using Iterator = std::vector<Settings::Acquisition>::iterator;
1052
1054 Iterator begin() noexcept;
1055
1057 Iterator end() noexcept;
1058
1060 using ConstIterator = std::vector<Settings::Acquisition>::const_iterator;
1061
1063 ConstIterator begin() const noexcept;
1064
1066 ConstIterator end() const noexcept;
1067
1069 ConstIterator cbegin() const noexcept;
1070
1072 ConstIterator cend() const noexcept;
1073
1075 bool operator==(const Acquisitions &other) const
1076 {
1077 return m_value == other.m_value;
1078 }
1079
1081 bool operator!=(const Acquisitions &other) const
1082 {
1083 return m_value != other.m_value;
1084 }
1085
1087 friend std::ostream &operator<<(std::ostream &stream, const Acquisitions &value)
1088 {
1089 return stream << value.toString();
1090 }
1091
1092 private:
1093 void setFromString(const std::string &value);
1094
1095 std::vector<Settings::Acquisition> m_value{};
1096
1097 friend struct DataModel::Detail::Befriend<Acquisitions>;
1098 };
1099
1107
1108 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
1110 {
1111 public:
1114
1116 static constexpr const char *path{ "Diagnostics" };
1117
1119 static constexpr const char *name{ "Diagnostics" };
1120
1122 static constexpr const char *description{
1123 R"description(When Diagnostics is enabled, extra diagnostic information is recorded during capture. This extra
1124information is included when saving the frame to a .zdf file, and will help Zivid's support team
1125to provide better assistance.
1126
1127Enabling Diagnostics increases the capture time and the RAM usage. It will also increase the size of the
1128.zdf file. It is recommended to enable Diagnostics only when reporting issues to Zivid's support team.
1129)description"
1130 };
1131
1133
1134 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
1136 {
1137 public:
1140
1142 static constexpr const char *path{ "Diagnostics/Enabled" };
1143
1145 static constexpr const char *name{ "Enabled" };
1146
1148 static constexpr const char *description{ R"description(Enable diagnostics)description" };
1149
1151 using ValueType = bool;
1152 static const Enabled yes;
1153 static const Enabled no;
1154
1156 static std::set<bool> validValues()
1157 {
1158 return { false, true };
1159 }
1160
1162 Enabled() = default;
1163
1165 explicit constexpr Enabled(bool value)
1166 : m_opt{ value }
1167 {}
1168
1173 bool value() const;
1174
1176 bool hasValue() const;
1177
1179 void reset();
1180
1182 std::string toString() const;
1183
1185 bool operator==(const Enabled &other) const
1186 {
1187 return m_opt == other.m_opt;
1188 }
1189
1191 bool operator!=(const Enabled &other) const
1192 {
1193 return m_opt != other.m_opt;
1194 }
1195
1197 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
1198 {
1199 return stream << value.toString();
1200 }
1201
1202 private:
1203 void setFromString(const std::string &value);
1204
1205 Zivid::DataModel::Detail::Optional<bool> m_opt;
1206
1207 friend struct DataModel::Detail::Befriend<Enabled>;
1208 };
1209
1210 using Descendants = std::tuple<Settings::Diagnostics::Enabled>;
1211
1214
1226#ifndef NO_DOC
1227 template<
1228 typename... Args,
1229 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
1230 typename std::enable_if<
1231 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
1232 value,
1233 int>::type = 0>
1234#else
1235 template<typename... Args>
1236#endif
1237 explicit Diagnostics(Args &&...args)
1238 {
1239 using namespace Zivid::Detail::TypeTraits;
1240
1241 static_assert(
1242 AllArgsDecayedAreUnique<Args...>::value,
1243 "Found duplicate types among the arguments passed to Diagnostics(...). "
1244 "Types should be listed at most once.");
1245
1246 set(std::forward<Args>(args)...);
1247 }
1248
1259#ifndef NO_DOC
1260 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
1261#else
1262 template<typename... Args>
1263#endif
1264 void set(Args &&...args)
1265 {
1266 using namespace Zivid::Detail::TypeTraits;
1267
1268 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
1269 static_assert(
1270 AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
1271
1272 static_assert(
1273 AllArgsDecayedAreUnique<Args...>::value,
1274 "Found duplicate types among the arguments passed to set(...). "
1275 "Types should be listed at most once.");
1276
1277 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
1278 }
1279
1291#ifndef NO_DOC
1292 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
1293#else
1294 template<typename... Args>
1295#endif
1296 Diagnostics copyWith(Args &&...args) const
1297 {
1298 using namespace Zivid::Detail::TypeTraits;
1299
1300 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
1301 static_assert(
1302 AllArgsAreDescendantNodes::value,
1303 "All arguments passed to copyWith(...) must be descendant nodes.");
1304
1305 static_assert(
1306 AllArgsDecayedAreUnique<Args...>::value,
1307 "Found duplicate types among the arguments passed to copyWith(...). "
1308 "Types should be listed at most once.");
1309
1310 auto copy{ *this };
1311 copy.set(std::forward<Args>(args)...);
1312 return copy;
1313 }
1314
1316 const Enabled &isEnabled() const
1317 {
1318 return m_enabled;
1319 }
1320
1323 {
1324 return m_enabled;
1325 }
1326
1328 Diagnostics &set(const Enabled &value)
1329 {
1330 m_enabled = value;
1331 return *this;
1332 }
1333
1334 template<
1335 typename T,
1336 typename std::enable_if<std::is_same<T, Settings::Diagnostics::Enabled>::value, int>::type = 0>
1338 {
1339 return m_enabled;
1340 }
1341
1342 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
1344 {
1345 return m_enabled;
1346 }
1347
1349 template<typename F>
1350 void forEach(const F &f) const
1351 {
1352 f(m_enabled);
1353 }
1354
1356 template<typename F>
1357 void forEach(const F &f)
1358 {
1359 f(m_enabled);
1360 }
1361
1363 bool operator==(const Diagnostics &other) const;
1364
1366 bool operator!=(const Diagnostics &other) const;
1367
1369 std::string toString() const;
1370
1372 friend std::ostream &operator<<(std::ostream &stream, const Diagnostics &value)
1373 {
1374 return stream << value.toString();
1375 }
1376
1377 private:
1378 void setFromString(const std::string &value);
1379
1380 void setFromString(const std::string &fullPath, const std::string &value);
1381
1382 std::string getString(const std::string &fullPath) const;
1383
1384 Enabled m_enabled;
1385
1386 friend struct DataModel::Detail::Befriend<Diagnostics>;
1387 };
1388
1390
1391 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
1393 {
1394 public:
1397
1399 static constexpr const char *path{ "Experimental" };
1400
1402 static constexpr const char *name{ "Experimental" };
1403
1405 static constexpr const char *description{
1406 R"description(Experimental features. These settings may be changed, renamed, moved or deleted in the future.)description"
1407 };
1408
1418
1419 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
1421 {
1422 public:
1425
1427 static constexpr const char *path{ "Experimental/Engine" };
1428
1430 static constexpr const char *name{ "Engine" };
1431
1433 static constexpr const char *description{ R"description(Set the Zivid Vision Engine to use.
1434
1435The Phase Engine is the current default Zivid Vision Engine.
1436
1437The Stripe Engine uses anti-reflection technology to suppress interreflection artifacts
1438and improve data quality on shiny objects like cylinders and chrome-plated parts.
1439Additional acquisition and processing time are required for the Stripe Engine.
1440The Stripe Engine is currently experimental, and may be changed and improved in the future.
1441)description" };
1442
1444 enum class ValueType
1445 {
1446 phase,
1447 stripe
1448 };
1449 static const Engine phase;
1450 static const Engine stripe;
1451
1453 static std::set<ValueType> validValues()
1454 {
1455 return { ValueType::phase, ValueType::stripe };
1456 }
1457
1459 Engine() = default;
1460
1462 explicit constexpr Engine(ValueType value)
1463 : m_opt{ verifyValue(value) }
1464 {}
1465
1471
1473 bool hasValue() const;
1474
1476 void reset();
1477
1479 std::string toString() const;
1480
1482 friend std::ostream &operator<<(std::ostream &stream, const Engine::ValueType &value)
1483 {
1484 return stream << Engine{ value }.toString();
1485 }
1486
1488 bool operator==(const Engine &other) const
1489 {
1490 return m_opt == other.m_opt;
1491 }
1492
1494 bool operator!=(const Engine &other) const
1495 {
1496 return m_opt != other.m_opt;
1497 }
1498
1500 friend std::ostream &operator<<(std::ostream &stream, const Engine &value)
1501 {
1502 return stream << value.toString();
1503 }
1504
1505 private:
1506 void setFromString(const std::string &value);
1507
1508 constexpr ValueType static verifyValue(const ValueType &value)
1509 {
1510 return value == ValueType::phase || value == ValueType::stripe
1511 ? value
1512 : throw std::invalid_argument{
1513 "Invalid value: Engine{ "
1514 + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
1515 };
1516 }
1517
1518 Zivid::DataModel::Detail::Optional<ValueType> m_opt;
1519
1520 friend struct DataModel::Detail::Befriend<Engine>;
1521 };
1522
1523 using Descendants = std::tuple<Settings::Experimental::Engine>;
1524
1527
1539#ifndef NO_DOC
1540 template<
1541 typename... Args,
1542 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
1543 typename std::enable_if<
1544 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
1545 value,
1546 int>::type = 0>
1547#else
1548 template<typename... Args>
1549#endif
1550 explicit Experimental(Args &&...args)
1551 {
1552 using namespace Zivid::Detail::TypeTraits;
1553
1554 static_assert(
1555 AllArgsDecayedAreUnique<Args...>::value,
1556 "Found duplicate types among the arguments passed to Experimental(...). "
1557 "Types should be listed at most once.");
1558
1559 set(std::forward<Args>(args)...);
1560 }
1561
1572#ifndef NO_DOC
1573 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
1574#else
1575 template<typename... Args>
1576#endif
1577 void set(Args &&...args)
1578 {
1579 using namespace Zivid::Detail::TypeTraits;
1580
1581 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
1582 static_assert(
1583 AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
1584
1585 static_assert(
1586 AllArgsDecayedAreUnique<Args...>::value,
1587 "Found duplicate types among the arguments passed to set(...). "
1588 "Types should be listed at most once.");
1589
1590 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
1591 }
1592
1604#ifndef NO_DOC
1605 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
1606#else
1607 template<typename... Args>
1608#endif
1609 Experimental copyWith(Args &&...args) const
1610 {
1611 using namespace Zivid::Detail::TypeTraits;
1612
1613 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
1614 static_assert(
1615 AllArgsAreDescendantNodes::value,
1616 "All arguments passed to copyWith(...) must be descendant nodes.");
1617
1618 static_assert(
1619 AllArgsDecayedAreUnique<Args...>::value,
1620 "Found duplicate types among the arguments passed to copyWith(...). "
1621 "Types should be listed at most once.");
1622
1623 auto copy{ *this };
1624 copy.set(std::forward<Args>(args)...);
1625 return copy;
1626 }
1627
1629 const Engine &engine() const
1630 {
1631 return m_engine;
1632 }
1633
1636 {
1637 return m_engine;
1638 }
1639
1641 Experimental &set(const Engine &value)
1642 {
1643 m_engine = value;
1644 return *this;
1645 }
1646
1647 template<
1648 typename T,
1649 typename std::enable_if<std::is_same<T, Settings::Experimental::Engine>::value, int>::type = 0>
1651 {
1652 return m_engine;
1653 }
1654
1655 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
1657 {
1658 return m_engine;
1659 }
1660
1662 template<typename F>
1663 void forEach(const F &f) const
1664 {
1665 f(m_engine);
1666 }
1667
1669 template<typename F>
1670 void forEach(const F &f)
1671 {
1672 f(m_engine);
1673 }
1674
1676 bool operator==(const Experimental &other) const;
1677
1679 bool operator!=(const Experimental &other) const;
1680
1682 std::string toString() const;
1683
1685 friend std::ostream &operator<<(std::ostream &stream, const Experimental &value)
1686 {
1687 return stream << value.toString();
1688 }
1689
1690 private:
1691 void setFromString(const std::string &value);
1692
1693 void setFromString(const std::string &fullPath, const std::string &value);
1694
1695 std::string getString(const std::string &fullPath) const;
1696
1697 Engine m_engine;
1698
1699 friend struct DataModel::Detail::Befriend<Experimental>;
1700 };
1701
1703
1704 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
1706 {
1707 public:
1710
1712 static constexpr const char *path{ "Processing" };
1713
1715 static constexpr const char *name{ "Processing" };
1716
1718 static constexpr const char *description{
1719 R"description(Settings related to processing of a capture, including filters and color balance)description"
1720 };
1721
1723
1724 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
1726 {
1727 public:
1730
1732 static constexpr const char *path{ "Processing/Color" };
1733
1735 static constexpr const char *name{ "Color" };
1736
1738 static constexpr const char *description{ R"description(Color settings)description" };
1739
1741
1742 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
1744 {
1745 public:
1748
1750 static constexpr const char *path{ "Processing/Color/Balance" };
1751
1753 static constexpr const char *name{ "Balance" };
1754
1756 static constexpr const char *description{ R"description(Color balance settings)description" };
1757
1759
1760 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
1762 {
1763 public:
1766
1768 static constexpr const char *path{ "Processing/Color/Balance/Blue" };
1769
1771 static constexpr const char *name{ "Blue" };
1772
1774 static constexpr const char *description{
1775 R"description(Digital gain applied to blue channel)description"
1776 };
1777
1779 using ValueType = double;
1780
1782 static constexpr Range<double> validRange()
1783 {
1784 return { 1.0, 8.0 };
1785 }
1786
1788 Blue() = default;
1789
1791 explicit constexpr Blue(double value)
1792 : m_opt{ verifyValue(value) }
1793 {}
1794
1799 double value() const;
1800
1802 bool hasValue() const;
1803
1805 void reset();
1806
1808 std::string toString() const;
1809
1811 bool operator==(const Blue &other) const
1812 {
1813 return m_opt == other.m_opt;
1814 }
1815
1817 bool operator!=(const Blue &other) const
1818 {
1819 return m_opt != other.m_opt;
1820 }
1821
1823 bool operator<(const Blue &other) const
1824 {
1825 return m_opt < other.m_opt;
1826 }
1827
1829 bool operator>(const Blue &other) const
1830 {
1831 return m_opt > other.m_opt;
1832 }
1833
1835 bool operator<=(const Blue &other) const
1836 {
1837 return m_opt <= other.m_opt;
1838 }
1839
1841 bool operator>=(const Blue &other) const
1842 {
1843 return m_opt >= other.m_opt;
1844 }
1845
1847 friend std::ostream &operator<<(std::ostream &stream, const Blue &value)
1848 {
1849 return stream << value.toString();
1850 }
1851
1852 private:
1853 void setFromString(const std::string &value);
1854
1855 constexpr ValueType static verifyValue(const ValueType &value)
1856 {
1857 return validRange().isInRange(value)
1858 ? value
1859 : throw std::out_of_range{ "Blue{ " + std::to_string(value)
1860 + " } is not in range ["
1861 + std::to_string(validRange().min()) + ", "
1862 + std::to_string(validRange().max()) + "]" };
1863 }
1864
1865 Zivid::DataModel::Detail::Optional<double> m_opt;
1866
1867 friend struct DataModel::Detail::Befriend<Blue>;
1868 };
1869
1871
1872 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
1874 {
1875 public:
1878
1880 static constexpr const char *path{ "Processing/Color/Balance/Green" };
1881
1883 static constexpr const char *name{ "Green" };
1884
1886 static constexpr const char *description{
1887 R"description(Digital gain applied to green channel)description"
1888 };
1889
1891 using ValueType = double;
1892
1894 static constexpr Range<double> validRange()
1895 {
1896 return { 1.0, 8.0 };
1897 }
1898
1900 Green() = default;
1901
1903 explicit constexpr Green(double value)
1904 : m_opt{ verifyValue(value) }
1905 {}
1906
1911 double value() const;
1912
1914 bool hasValue() const;
1915
1917 void reset();
1918
1920 std::string toString() const;
1921
1923 bool operator==(const Green &other) const
1924 {
1925 return m_opt == other.m_opt;
1926 }
1927
1929 bool operator!=(const Green &other) const
1930 {
1931 return m_opt != other.m_opt;
1932 }
1933
1935 bool operator<(const Green &other) const
1936 {
1937 return m_opt < other.m_opt;
1938 }
1939
1941 bool operator>(const Green &other) const
1942 {
1943 return m_opt > other.m_opt;
1944 }
1945
1947 bool operator<=(const Green &other) const
1948 {
1949 return m_opt <= other.m_opt;
1950 }
1951
1953 bool operator>=(const Green &other) const
1954 {
1955 return m_opt >= other.m_opt;
1956 }
1957
1959 friend std::ostream &operator<<(std::ostream &stream, const Green &value)
1960 {
1961 return stream << value.toString();
1962 }
1963
1964 private:
1965 void setFromString(const std::string &value);
1966
1967 constexpr ValueType static verifyValue(const ValueType &value)
1968 {
1969 return validRange().isInRange(value)
1970 ? value
1971 : throw std::out_of_range{ "Green{ " + std::to_string(value)
1972 + " } is not in range ["
1973 + std::to_string(validRange().min()) + ", "
1974 + std::to_string(validRange().max()) + "]" };
1975 }
1976
1977 Zivid::DataModel::Detail::Optional<double> m_opt;
1978
1979 friend struct DataModel::Detail::Befriend<Green>;
1980 };
1981
1983
1984 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
1986 {
1987 public:
1990
1992 static constexpr const char *path{ "Processing/Color/Balance/Red" };
1993
1995 static constexpr const char *name{ "Red" };
1996
1998 static constexpr const char *description{
1999 R"description(Digital gain applied to red channel)description"
2000 };
2001
2003 using ValueType = double;
2004
2006 static constexpr Range<double> validRange()
2007 {
2008 return { 1.0, 8.0 };
2009 }
2010
2012 Red() = default;
2013
2015 explicit constexpr Red(double value)
2016 : m_opt{ verifyValue(value) }
2017 {}
2018
2023 double value() const;
2024
2026 bool hasValue() const;
2027
2029 void reset();
2030
2032 std::string toString() const;
2033
2035 bool operator==(const Red &other) const
2036 {
2037 return m_opt == other.m_opt;
2038 }
2039
2041 bool operator!=(const Red &other) const
2042 {
2043 return m_opt != other.m_opt;
2044 }
2045
2047 bool operator<(const Red &other) const
2048 {
2049 return m_opt < other.m_opt;
2050 }
2051
2053 bool operator>(const Red &other) const
2054 {
2055 return m_opt > other.m_opt;
2056 }
2057
2059 bool operator<=(const Red &other) const
2060 {
2061 return m_opt <= other.m_opt;
2062 }
2063
2065 bool operator>=(const Red &other) const
2066 {
2067 return m_opt >= other.m_opt;
2068 }
2069
2071 friend std::ostream &operator<<(std::ostream &stream, const Red &value)
2072 {
2073 return stream << value.toString();
2074 }
2075
2076 private:
2077 void setFromString(const std::string &value);
2078
2079 constexpr ValueType static verifyValue(const ValueType &value)
2080 {
2081 return validRange().isInRange(value)
2082 ? value
2083 : throw std::out_of_range{ "Red{ " + std::to_string(value)
2084 + " } is not in range ["
2085 + std::to_string(validRange().min()) + ", "
2086 + std::to_string(validRange().max()) + "]" };
2087 }
2088
2089 Zivid::DataModel::Detail::Optional<double> m_opt;
2090
2091 friend struct DataModel::Detail::Befriend<Red>;
2092 };
2093
2094 using Descendants = std::tuple<
2098
2101
2115#ifndef NO_DOC
2116 template<
2117 typename... Args,
2118 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
2119 typename std::enable_if<
2120 Zivid::Detail::TypeTraits::
2121 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
2122 int>::type = 0>
2123#else
2124 template<typename... Args>
2125#endif
2126 explicit Balance(Args &&...args)
2127 {
2128 using namespace Zivid::Detail::TypeTraits;
2129
2130 static_assert(
2131 AllArgsDecayedAreUnique<Args...>::value,
2132 "Found duplicate types among the arguments passed to Balance(...). "
2133 "Types should be listed at most once.");
2134
2135 set(std::forward<Args>(args)...);
2136 }
2137
2150#ifndef NO_DOC
2151 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
2152#else
2153 template<typename... Args>
2154#endif
2155 void set(Args &&...args)
2156 {
2157 using namespace Zivid::Detail::TypeTraits;
2158
2159 using AllArgsAreDescendantNodes =
2160 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
2161 static_assert(
2162 AllArgsAreDescendantNodes::value,
2163 "All arguments passed to set(...) must be descendant nodes.");
2164
2165 static_assert(
2166 AllArgsDecayedAreUnique<Args...>::value,
2167 "Found duplicate types among the arguments passed to set(...). "
2168 "Types should be listed at most once.");
2169
2170 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
2171 }
2172
2186#ifndef NO_DOC
2187 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
2188#else
2189 template<typename... Args>
2190#endif
2191 Balance copyWith(Args &&...args) const
2192 {
2193 using namespace Zivid::Detail::TypeTraits;
2194
2195 using AllArgsAreDescendantNodes =
2196 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
2197 static_assert(
2198 AllArgsAreDescendantNodes::value,
2199 "All arguments passed to copyWith(...) must be descendant nodes.");
2200
2201 static_assert(
2202 AllArgsDecayedAreUnique<Args...>::value,
2203 "Found duplicate types among the arguments passed to copyWith(...). "
2204 "Types should be listed at most once.");
2205
2206 auto copy{ *this };
2207 copy.set(std::forward<Args>(args)...);
2208 return copy;
2209 }
2210
2212 const Blue &blue() const
2213 {
2214 return m_blue;
2215 }
2216
2219 {
2220 return m_blue;
2221 }
2222
2224 Balance &set(const Blue &value)
2225 {
2226 m_blue = value;
2227 return *this;
2228 }
2229
2231 const Green &green() const
2232 {
2233 return m_green;
2234 }
2235
2238 {
2239 return m_green;
2240 }
2241
2243 Balance &set(const Green &value)
2244 {
2245 m_green = value;
2246 return *this;
2247 }
2248
2250 const Red &red() const
2251 {
2252 return m_red;
2253 }
2254
2257 {
2258 return m_red;
2259 }
2260
2262 Balance &set(const Red &value)
2263 {
2264 m_red = value;
2265 return *this;
2266 }
2267
2268 template<
2269 typename T,
2270 typename std::enable_if<
2271 std::is_same<T, Settings::Processing::Color::Balance::Blue>::value,
2272 int>::type = 0>
2274 {
2275 return m_blue;
2276 }
2277
2278 template<
2279 typename T,
2280 typename std::enable_if<
2281 std::is_same<T, Settings::Processing::Color::Balance::Green>::value,
2282 int>::type = 0>
2284 {
2285 return m_green;
2286 }
2287
2288 template<
2289 typename T,
2290 typename std::
2291 enable_if<std::is_same<T, Settings::Processing::Color::Balance::Red>::value, int>::type = 0>
2293 {
2294 return m_red;
2295 }
2296
2297 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
2299 {
2300 return m_blue;
2301 }
2302
2303 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
2305 {
2306 return m_green;
2307 }
2308
2309 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
2311 {
2312 return m_red;
2313 }
2314
2316 template<typename F>
2317 void forEach(const F &f) const
2318 {
2319 f(m_blue);
2320 f(m_green);
2321 f(m_red);
2322 }
2323
2325 template<typename F>
2326 void forEach(const F &f)
2327 {
2328 f(m_blue);
2329 f(m_green);
2330 f(m_red);
2331 }
2332
2334 bool operator==(const Balance &other) const;
2335
2337 bool operator!=(const Balance &other) const;
2338
2340 std::string toString() const;
2341
2343 friend std::ostream &operator<<(std::ostream &stream, const Balance &value)
2344 {
2345 return stream << value.toString();
2346 }
2347
2348 private:
2349 void setFromString(const std::string &value);
2350
2351 void setFromString(const std::string &fullPath, const std::string &value);
2352
2353 std::string getString(const std::string &fullPath) const;
2354
2355 Blue m_blue;
2356 Green m_green;
2357 Red m_red;
2358
2359 friend struct DataModel::Detail::Befriend<Balance>;
2360 };
2361
2363
2364 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
2366 {
2367 public:
2370
2372 static constexpr const char *path{ "Processing/Color/Experimental" };
2373
2375 static constexpr const char *name{ "Experimental" };
2376
2378 static constexpr const char *description{
2379 R"description(Experimental color settings. These may be renamed, moved or deleted in the future.)description"
2380 };
2381
2404
2405 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
2407 {
2408 public:
2411
2413 static constexpr const char *path{ "Processing/Color/Experimental/Mode" };
2414
2416 static constexpr const char *name{ "Mode" };
2417
2419 static constexpr const char *description{
2420 R"description(This setting controls how the color image is computed.
2421
2422`automatic` is the default option. `automatic` is identical to `useFirstAcquisition` for
2423single-acquisition captures and multi-acquisition captures when all the acquisitions have
2424identical (duplicated) acquisition settings. `automatic` is identical to `toneMapping` for
2425multi-acquisition HDR captures with differing acquisition settings.
2426
2427`useFirstAcquisition` uses the color data acquired from the first acquisition provided. If
2428the capture consists of more than one acquisition, then the remaining acquisitions are not used
2429for the color image. No tone mapping is performed. This option provides the most control of
2430the color image, and the color values will be consistent over repeated captures with the same
2431settings.
2432
2433`toneMapping` uses all the acquisitions to create one merged and normalized color image. For
2434HDR captures the dynamic range of the captured images is usually higher than the 8-bit color
2435image range. `toneMapping` will map the HDR color data to the 8-bit color output range by
2436applying a scaling factor. `toneMapping` can also be used for single-acquisition captures to
2437normalize the captured color image to the full 8-bit output. Note that when using `toneMapping`
2438mode the color values can be inconsistent over repeated captures if you move, add or remove
2439objects in the scene. For the most control over the colors, select the `useFirstAcquisition`
2440mode.
2441)description"
2442 };
2443
2445 enum class ValueType
2446 {
2447 automatic,
2448 useFirstAcquisition,
2449 toneMapping
2450 };
2451 static const Mode automatic;
2453 static const Mode toneMapping;
2454
2456 static std::set<ValueType> validValues()
2457 {
2458 return { ValueType::automatic, ValueType::useFirstAcquisition, ValueType::toneMapping };
2459 }
2460
2462 Mode() = default;
2463
2465 explicit constexpr Mode(ValueType value)
2466 : m_opt{ verifyValue(value) }
2467 {}
2468
2474
2476 bool hasValue() const;
2477
2479 void reset();
2480
2482 std::string toString() const;
2483
2485 friend std::ostream &operator<<(std::ostream &stream, const Mode::ValueType &value)
2486 {
2487 return stream << Mode{ value }.toString();
2488 }
2489
2491 bool operator==(const Mode &other) const
2492 {
2493 return m_opt == other.m_opt;
2494 }
2495
2497 bool operator!=(const Mode &other) const
2498 {
2499 return m_opt != other.m_opt;
2500 }
2501
2503 friend std::ostream &operator<<(std::ostream &stream, const Mode &value)
2504 {
2505 return stream << value.toString();
2506 }
2507
2508 private:
2509 void setFromString(const std::string &value);
2510
2511 constexpr ValueType static verifyValue(const ValueType &value)
2512 {
2513 return value == ValueType::automatic || value == ValueType::useFirstAcquisition
2514 || value == ValueType::toneMapping
2515 ? value
2516 : throw std::invalid_argument{
2517 "Invalid value: Mode{ "
2518 + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value))
2519 + " }"
2520 };
2521 }
2522
2523 Zivid::DataModel::Detail::Optional<ValueType> m_opt;
2524
2525 friend struct DataModel::Detail::Befriend<Mode>;
2526 };
2527
2528 using Descendants = std::tuple<Settings::Processing::Color::Experimental::Mode>;
2529
2532
2544#ifndef NO_DOC
2545 template<
2546 typename... Args,
2547 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
2548 typename std::enable_if<
2549 Zivid::Detail::TypeTraits::
2550 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
2551 int>::type = 0>
2552#else
2553 template<typename... Args>
2554#endif
2555 explicit Experimental(Args &&...args)
2556 {
2557 using namespace Zivid::Detail::TypeTraits;
2558
2559 static_assert(
2560 AllArgsDecayedAreUnique<Args...>::value,
2561 "Found duplicate types among the arguments passed to Experimental(...). "
2562 "Types should be listed at most once.");
2563
2564 set(std::forward<Args>(args)...);
2565 }
2566
2577#ifndef NO_DOC
2578 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
2579#else
2580 template<typename... Args>
2581#endif
2582 void set(Args &&...args)
2583 {
2584 using namespace Zivid::Detail::TypeTraits;
2585
2586 using AllArgsAreDescendantNodes =
2587 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
2588 static_assert(
2589 AllArgsAreDescendantNodes::value,
2590 "All arguments passed to set(...) must be descendant nodes.");
2591
2592 static_assert(
2593 AllArgsDecayedAreUnique<Args...>::value,
2594 "Found duplicate types among the arguments passed to set(...). "
2595 "Types should be listed at most once.");
2596
2597 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
2598 }
2599
2611#ifndef NO_DOC
2612 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
2613#else
2614 template<typename... Args>
2615#endif
2616 Experimental copyWith(Args &&...args) const
2617 {
2618 using namespace Zivid::Detail::TypeTraits;
2619
2620 using AllArgsAreDescendantNodes =
2621 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
2622 static_assert(
2623 AllArgsAreDescendantNodes::value,
2624 "All arguments passed to copyWith(...) must be descendant nodes.");
2625
2626 static_assert(
2627 AllArgsDecayedAreUnique<Args...>::value,
2628 "Found duplicate types among the arguments passed to copyWith(...). "
2629 "Types should be listed at most once.");
2630
2631 auto copy{ *this };
2632 copy.set(std::forward<Args>(args)...);
2633 return copy;
2634 }
2635
2637 const Mode &mode() const
2638 {
2639 return m_mode;
2640 }
2641
2644 {
2645 return m_mode;
2646 }
2647
2649 Experimental &set(const Mode &value)
2650 {
2651 m_mode = value;
2652 return *this;
2653 }
2654
2655 template<
2656 typename T,
2657 typename std::enable_if<
2658 std::is_same<T, Settings::Processing::Color::Experimental::Mode>::value,
2659 int>::type = 0>
2661 {
2662 return m_mode;
2663 }
2664
2665 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
2667 {
2668 return m_mode;
2669 }
2670
2672 template<typename F>
2673 void forEach(const F &f) const
2674 {
2675 f(m_mode);
2676 }
2677
2679 template<typename F>
2680 void forEach(const F &f)
2681 {
2682 f(m_mode);
2683 }
2684
2686 bool operator==(const Experimental &other) const;
2687
2689 bool operator!=(const Experimental &other) const;
2690
2692 std::string toString() const;
2693
2695 friend std::ostream &operator<<(std::ostream &stream, const Experimental &value)
2696 {
2697 return stream << value.toString();
2698 }
2699
2700 private:
2701 void setFromString(const std::string &value);
2702
2703 void setFromString(const std::string &fullPath, const std::string &value);
2704
2705 std::string getString(const std::string &fullPath) const;
2706
2707 Mode m_mode;
2708
2709 friend struct DataModel::Detail::Befriend<Experimental>;
2710 };
2711
2715
2716 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
2718 {
2719 public:
2722
2724 static constexpr const char *path{ "Processing/Color/Gamma" };
2725
2727 static constexpr const char *name{ "Gamma" };
2728
2730 static constexpr const char *description{
2731 R"description(Gamma applied to the color values. Gamma less than 1 makes the colors brighter, while gamma
2732greater than 1 makes the colors darker.
2733)description"
2734 };
2735
2737 using ValueType = double;
2738
2740 static constexpr Range<double> validRange()
2741 {
2742 return { 0.25, 1.5 };
2743 }
2744
2746 Gamma() = default;
2747
2749 explicit constexpr Gamma(double value)
2750 : m_opt{ verifyValue(value) }
2751 {}
2752
2757 double value() const;
2758
2760 bool hasValue() const;
2761
2763 void reset();
2764
2766 std::string toString() const;
2767
2769 bool operator==(const Gamma &other) const
2770 {
2771 return m_opt == other.m_opt;
2772 }
2773
2775 bool operator!=(const Gamma &other) const
2776 {
2777 return m_opt != other.m_opt;
2778 }
2779
2781 bool operator<(const Gamma &other) const
2782 {
2783 return m_opt < other.m_opt;
2784 }
2785
2787 bool operator>(const Gamma &other) const
2788 {
2789 return m_opt > other.m_opt;
2790 }
2791
2793 bool operator<=(const Gamma &other) const
2794 {
2795 return m_opt <= other.m_opt;
2796 }
2797
2799 bool operator>=(const Gamma &other) const
2800 {
2801 return m_opt >= other.m_opt;
2802 }
2803
2805 friend std::ostream &operator<<(std::ostream &stream, const Gamma &value)
2806 {
2807 return stream << value.toString();
2808 }
2809
2810 private:
2811 void setFromString(const std::string &value);
2812
2813 constexpr ValueType static verifyValue(const ValueType &value)
2814 {
2815 return validRange().isInRange(value)
2816 ? value
2817 : throw std::out_of_range{ "Gamma{ " + std::to_string(value) + " } is not in range ["
2818 + std::to_string(validRange().min()) + ", "
2819 + std::to_string(validRange().max()) + "]" };
2820 }
2821
2822 Zivid::DataModel::Detail::Optional<double> m_opt;
2823
2824 friend struct DataModel::Detail::Befriend<Gamma>;
2825 };
2826
2827 using Descendants = std::tuple<
2835
2838
2856#ifndef NO_DOC
2857 template<
2858 typename... Args,
2859 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
2860 typename std::enable_if<
2861 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
2862 value,
2863 int>::type = 0>
2864#else
2865 template<typename... Args>
2866#endif
2867 explicit Color(Args &&...args)
2868 {
2869 using namespace Zivid::Detail::TypeTraits;
2870
2871 static_assert(
2872 AllArgsDecayedAreUnique<Args...>::value,
2873 "Found duplicate types among the arguments passed to Color(...). "
2874 "Types should be listed at most once.");
2875
2876 set(std::forward<Args>(args)...);
2877 }
2878
2895#ifndef NO_DOC
2896 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
2897#else
2898 template<typename... Args>
2899#endif
2900 void set(Args &&...args)
2901 {
2902 using namespace Zivid::Detail::TypeTraits;
2903
2904 using AllArgsAreDescendantNodes =
2905 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
2906 static_assert(
2907 AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
2908
2909 static_assert(
2910 AllArgsDecayedAreUnique<Args...>::value,
2911 "Found duplicate types among the arguments passed to set(...). "
2912 "Types should be listed at most once.");
2913
2914 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
2915 }
2916
2934#ifndef NO_DOC
2935 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
2936#else
2937 template<typename... Args>
2938#endif
2939 Color copyWith(Args &&...args) const
2940 {
2941 using namespace Zivid::Detail::TypeTraits;
2942
2943 using AllArgsAreDescendantNodes =
2944 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
2945 static_assert(
2946 AllArgsAreDescendantNodes::value,
2947 "All arguments passed to copyWith(...) must be descendant nodes.");
2948
2949 static_assert(
2950 AllArgsDecayedAreUnique<Args...>::value,
2951 "Found duplicate types among the arguments passed to copyWith(...). "
2952 "Types should be listed at most once.");
2953
2954 auto copy{ *this };
2955 copy.set(std::forward<Args>(args)...);
2956 return copy;
2957 }
2958
2960 const Balance &balance() const
2961 {
2962 return m_balance;
2963 }
2964
2967 {
2968 return m_balance;
2969 }
2970
2972 Color &set(const Balance &value)
2973 {
2974 m_balance = value;
2975 return *this;
2976 }
2977
2979 Color &set(const Balance::Blue &value)
2980 {
2981 m_balance.set(value);
2982 return *this;
2983 }
2984
2986 Color &set(const Balance::Green &value)
2987 {
2988 m_balance.set(value);
2989 return *this;
2990 }
2991
2993 Color &set(const Balance::Red &value)
2994 {
2995 m_balance.set(value);
2996 return *this;
2997 }
2998
3001 {
3002 return m_experimental;
3003 }
3004
3007 {
3008 return m_experimental;
3009 }
3010
3012 Color &set(const Experimental &value)
3013 {
3014 m_experimental = value;
3015 return *this;
3016 }
3017
3020 {
3021 m_experimental.set(value);
3022 return *this;
3023 }
3024
3026 const Gamma &gamma() const
3027 {
3028 return m_gamma;
3029 }
3030
3033 {
3034 return m_gamma;
3035 }
3036
3038 Color &set(const Gamma &value)
3039 {
3040 m_gamma = value;
3041 return *this;
3042 }
3043
3044 template<
3045 typename T,
3046 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance>::value, int>::type =
3047 0>
3049 {
3050 return m_balance;
3051 }
3052
3053 template<
3054 typename T,
3055 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Blue>::value, int>::
3056 type = 0>
3058 {
3059 return m_balance.get<Settings::Processing::Color::Balance::Blue>();
3060 }
3061
3062 template<
3063 typename T,
3064 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Green>::value, int>::
3065 type = 0>
3067 {
3068 return m_balance.get<Settings::Processing::Color::Balance::Green>();
3069 }
3070
3071 template<
3072 typename T,
3073 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Red>::value, int>::
3074 type = 0>
3076 {
3077 return m_balance.get<Settings::Processing::Color::Balance::Red>();
3078 }
3079
3080 template<
3081 typename T,
3082 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental>::value, int>::
3083 type = 0>
3085 {
3086 return m_experimental;
3087 }
3088
3089 template<
3090 typename T,
3091 typename std::enable_if<
3092 std::is_same<T, Settings::Processing::Color::Experimental::Mode>::value,
3093 int>::type = 0>
3095 {
3096 return m_experimental.get<Settings::Processing::Color::Experimental::Mode>();
3097 }
3098
3099 template<
3100 typename T,
3101 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Gamma>::value, int>::type = 0>
3103 {
3104 return m_gamma;
3105 }
3106
3107 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
3109 {
3110 return m_balance;
3111 }
3112
3113 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
3115 {
3116 return m_experimental;
3117 }
3118
3119 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
3121 {
3122 return m_gamma;
3123 }
3124
3126 template<typename F>
3127 void forEach(const F &f) const
3128 {
3129 f(m_balance);
3130 f(m_experimental);
3131 f(m_gamma);
3132 }
3133
3135 template<typename F>
3136 void forEach(const F &f)
3137 {
3138 f(m_balance);
3139 f(m_experimental);
3140 f(m_gamma);
3141 }
3142
3144 bool operator==(const Color &other) const;
3145
3147 bool operator!=(const Color &other) const;
3148
3150 std::string toString() const;
3151
3153 friend std::ostream &operator<<(std::ostream &stream, const Color &value)
3154 {
3155 return stream << value.toString();
3156 }
3157
3158 private:
3159 void setFromString(const std::string &value);
3160
3161 void setFromString(const std::string &fullPath, const std::string &value);
3162
3163 std::string getString(const std::string &fullPath) const;
3164
3165 Balance m_balance;
3166 Experimental m_experimental;
3167 Gamma m_gamma;
3168
3169 friend struct DataModel::Detail::Befriend<Color>;
3170 };
3171
3173
3174 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
3176 {
3177 public:
3180
3182 static constexpr const char *path{ "Processing/Filters" };
3183
3185 static constexpr const char *name{ "Filters" };
3186
3188 static constexpr const char *description{ R"description(Filters)description" };
3189
3192
3193 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
3195 {
3196 public:
3199
3201 static constexpr const char *path{ "Processing/Filters/Cluster" };
3202
3204 static constexpr const char *name{ "Cluster" };
3205
3207 static constexpr const char *description{
3208 R"description(Removes floating points and small isolated clusters from the point cloud.
3209)description"
3210 };
3211
3213
3214 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
3216 {
3217 public:
3220
3222 static constexpr const char *path{ "Processing/Filters/Cluster/Removal" };
3223
3225 static constexpr const char *name{ "Removal" };
3226
3228 static constexpr const char *description{ R"description(Removal)description" };
3229
3231
3232 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
3234 {
3235 public:
3238
3240 static constexpr const char *path{ "Processing/Filters/Cluster/Removal/Enabled" };
3241
3243 static constexpr const char *name{ "Enabled" };
3244
3246 static constexpr const char *description{ R"description(Enabled)description" };
3247
3249 using ValueType = bool;
3250 static const Enabled yes;
3251 static const Enabled no;
3252
3254 static std::set<bool> validValues()
3255 {
3256 return { false, true };
3257 }
3258
3260 Enabled() = default;
3261
3263 explicit constexpr Enabled(bool value)
3264 : m_opt{ value }
3265 {}
3266
3271 bool value() const;
3272
3274 bool hasValue() const;
3275
3277 void reset();
3278
3280 std::string toString() const;
3281
3283 bool operator==(const Enabled &other) const
3284 {
3285 return m_opt == other.m_opt;
3286 }
3287
3289 bool operator!=(const Enabled &other) const
3290 {
3291 return m_opt != other.m_opt;
3292 }
3293
3295 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
3296 {
3297 return stream << value.toString();
3298 }
3299
3300 private:
3301 void setFromString(const std::string &value);
3302
3303 Zivid::DataModel::Detail::Optional<bool> m_opt;
3304
3305 friend struct DataModel::Detail::Befriend<Enabled>;
3306 };
3307
3312
3313 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
3315 {
3316 public:
3319
3321 static constexpr const char *path{
3322 "Processing/Filters/Cluster/Removal/MaxNeighborDistance"
3323 };
3324
3326 static constexpr const char *name{ "MaxNeighborDistance" };
3327
3329 static constexpr const char *description{
3330 R"description(Maximum normalized distance between neighboring points that are still classified as
3331belonging to the same cluster. The default value (10.0) is optimal for most scenes.
3332On messy scenes turning this setting down helps removing more bad points.
3333)description"
3334 };
3335
3337 using ValueType = double;
3338
3340 static constexpr Range<double> validRange()
3341 {
3342 return { 4.0, 10.0 };
3343 }
3344
3347
3349 explicit constexpr MaxNeighborDistance(double value)
3350 : m_opt{ verifyValue(value) }
3351 {}
3352
3357 double value() const;
3358
3360 bool hasValue() const;
3361
3363 void reset();
3364
3366 std::string toString() const;
3367
3369 bool operator==(const MaxNeighborDistance &other) const
3370 {
3371 return m_opt == other.m_opt;
3372 }
3373
3375 bool operator!=(const MaxNeighborDistance &other) const
3376 {
3377 return m_opt != other.m_opt;
3378 }
3379
3381 bool operator<(const MaxNeighborDistance &other) const
3382 {
3383 return m_opt < other.m_opt;
3384 }
3385
3387 bool operator>(const MaxNeighborDistance &other) const
3388 {
3389 return m_opt > other.m_opt;
3390 }
3391
3393 bool operator<=(const MaxNeighborDistance &other) const
3394 {
3395 return m_opt <= other.m_opt;
3396 }
3397
3399 bool operator>=(const MaxNeighborDistance &other) const
3400 {
3401 return m_opt >= other.m_opt;
3402 }
3403
3405 friend std::ostream &operator<<(std::ostream &stream, const MaxNeighborDistance &value)
3406 {
3407 return stream << value.toString();
3408 }
3409
3410 private:
3411 void setFromString(const std::string &value);
3412
3413 constexpr ValueType static verifyValue(const ValueType &value)
3414 {
3415 return validRange().isInRange(value)
3416 ? value
3417 : throw std::out_of_range{ "MaxNeighborDistance{ " + std::to_string(value)
3418 + " } is not in range ["
3419 + std::to_string(validRange().min()) + ", "
3420 + std::to_string(validRange().max()) + "]" };
3421 }
3422
3423 Zivid::DataModel::Detail::Optional<double> m_opt;
3424
3425 friend struct DataModel::Detail::Befriend<MaxNeighborDistance>;
3426 };
3427
3431
3432 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
3434 {
3435 public:
3438
3440 static constexpr const char *path{ "Processing/Filters/Cluster/Removal/MinArea" };
3441
3443 static constexpr const char *name{ "MinArea" };
3444
3446 static constexpr const char *description{
3447 R"description(Clusters with area below this threshold are removed by the filter.
3448The area is given in mm^2.
3449)description"
3450 };
3451
3453 using ValueType = double;
3454
3456 static constexpr Range<double> validRange()
3457 {
3458 return { 0.0, 1500.0 };
3459 }
3460
3462 MinArea() = default;
3463
3465 explicit constexpr MinArea(double value)
3466 : m_opt{ verifyValue(value) }
3467 {}
3468
3473 double value() const;
3474
3476 bool hasValue() const;
3477
3479 void reset();
3480
3482 std::string toString() const;
3483
3485 bool operator==(const MinArea &other) const
3486 {
3487 return m_opt == other.m_opt;
3488 }
3489
3491 bool operator!=(const MinArea &other) const
3492 {
3493 return m_opt != other.m_opt;
3494 }
3495
3497 bool operator<(const MinArea &other) const
3498 {
3499 return m_opt < other.m_opt;
3500 }
3501
3503 bool operator>(const MinArea &other) const
3504 {
3505 return m_opt > other.m_opt;
3506 }
3507
3509 bool operator<=(const MinArea &other) const
3510 {
3511 return m_opt <= other.m_opt;
3512 }
3513
3515 bool operator>=(const MinArea &other) const
3516 {
3517 return m_opt >= other.m_opt;
3518 }
3519
3521 friend std::ostream &operator<<(std::ostream &stream, const MinArea &value)
3522 {
3523 return stream << value.toString();
3524 }
3525
3526 private:
3527 void setFromString(const std::string &value);
3528
3529 constexpr ValueType static verifyValue(const ValueType &value)
3530 {
3531 return validRange().isInRange(value)
3532 ? value
3533 : throw std::out_of_range{ "MinArea{ " + std::to_string(value)
3534 + " } is not in range ["
3535 + std::to_string(validRange().min()) + ", "
3536 + std::to_string(validRange().max()) + "]" };
3537 }
3538
3539 Zivid::DataModel::Detail::Optional<double> m_opt;
3540
3541 friend struct DataModel::Detail::Befriend<MinArea>;
3542 };
3543
3544 using Descendants = std::tuple<
3548
3551
3565#ifndef NO_DOC
3566 template<
3567 typename... Args,
3568 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
3569 typename std::enable_if<
3570 Zivid::Detail::TypeTraits::
3571 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
3572 int>::type = 0>
3573#else
3574 template<typename... Args>
3575#endif
3576 explicit Removal(Args &&...args)
3577 {
3578 using namespace Zivid::Detail::TypeTraits;
3579
3580 static_assert(
3581 AllArgsDecayedAreUnique<Args...>::value,
3582 "Found duplicate types among the arguments passed to Removal(...). "
3583 "Types should be listed at most once.");
3584
3585 set(std::forward<Args>(args)...);
3586 }
3587
3600#ifndef NO_DOC
3601 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
3602#else
3603 template<typename... Args>
3604#endif
3605 void set(Args &&...args)
3606 {
3607 using namespace Zivid::Detail::TypeTraits;
3608
3609 using AllArgsAreDescendantNodes =
3610 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
3611 static_assert(
3612 AllArgsAreDescendantNodes::value,
3613 "All arguments passed to set(...) must be descendant nodes.");
3614
3615 static_assert(
3616 AllArgsDecayedAreUnique<Args...>::value,
3617 "Found duplicate types among the arguments passed to set(...). "
3618 "Types should be listed at most once.");
3619
3620 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
3621 }
3622
3636#ifndef NO_DOC
3637 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
3638#else
3639 template<typename... Args>
3640#endif
3641 Removal copyWith(Args &&...args) const
3642 {
3643 using namespace Zivid::Detail::TypeTraits;
3644
3645 using AllArgsAreDescendantNodes =
3646 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
3647 static_assert(
3648 AllArgsAreDescendantNodes::value,
3649 "All arguments passed to copyWith(...) must be descendant nodes.");
3650
3651 static_assert(
3652 AllArgsDecayedAreUnique<Args...>::value,
3653 "Found duplicate types among the arguments passed to copyWith(...). "
3654 "Types should be listed at most once.");
3655
3656 auto copy{ *this };
3657 copy.set(std::forward<Args>(args)...);
3658 return copy;
3659 }
3660
3662 const Enabled &isEnabled() const
3663 {
3664 return m_enabled;
3665 }
3666
3669 {
3670 return m_enabled;
3671 }
3672
3674 Removal &set(const Enabled &value)
3675 {
3676 m_enabled = value;
3677 return *this;
3678 }
3679
3682 {
3683 return m_maxNeighborDistance;
3684 }
3685
3688 {
3689 return m_maxNeighborDistance;
3690 }
3691
3694 {
3695 m_maxNeighborDistance = value;
3696 return *this;
3697 }
3698
3700 const MinArea &minArea() const
3701 {
3702 return m_minArea;
3703 }
3704
3707 {
3708 return m_minArea;
3709 }
3710
3712 Removal &set(const MinArea &value)
3713 {
3714 m_minArea = value;
3715 return *this;
3716 }
3717
3718 template<
3719 typename T,
3720 typename std::enable_if<
3721 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::Enabled>::value,
3722 int>::type = 0>
3724 {
3725 return m_enabled;
3726 }
3727
3728 template<
3729 typename T,
3730 typename std::enable_if<
3731 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>::
3732 value,
3733 int>::type = 0>
3735 {
3736 return m_maxNeighborDistance;
3737 }
3738
3739 template<
3740 typename T,
3741 typename std::enable_if<
3742 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MinArea>::value,
3743 int>::type = 0>
3745 {
3746 return m_minArea;
3747 }
3748
3749 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
3751 {
3752 return m_enabled;
3753 }
3754
3755 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
3757 {
3758 return m_maxNeighborDistance;
3759 }
3760
3761 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
3763 {
3764 return m_minArea;
3765 }
3766
3768 template<typename F>
3769 void forEach(const F &f) const
3770 {
3771 f(m_enabled);
3772 f(m_maxNeighborDistance);
3773 f(m_minArea);
3774 }
3775
3777 template<typename F>
3778 void forEach(const F &f)
3779 {
3780 f(m_enabled);
3781 f(m_maxNeighborDistance);
3782 f(m_minArea);
3783 }
3784
3786 bool operator==(const Removal &other) const;
3787
3789 bool operator!=(const Removal &other) const;
3790
3792 std::string toString() const;
3793
3795 friend std::ostream &operator<<(std::ostream &stream, const Removal &value)
3796 {
3797 return stream << value.toString();
3798 }
3799
3800 private:
3801 void setFromString(const std::string &value);
3802
3803 void setFromString(const std::string &fullPath, const std::string &value);
3804
3805 std::string getString(const std::string &fullPath) const;
3806
3807 Enabled m_enabled;
3808 MaxNeighborDistance m_maxNeighborDistance;
3809 MinArea m_minArea;
3810
3811 friend struct DataModel::Detail::Befriend<Removal>;
3812 };
3813
3814 using Descendants = std::tuple<
3819
3822
3837#ifndef NO_DOC
3838 template<
3839 typename... Args,
3840 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
3841 typename std::enable_if<
3842 Zivid::Detail::TypeTraits::
3843 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
3844 int>::type = 0>
3845#else
3846 template<typename... Args>
3847#endif
3848 explicit Cluster(Args &&...args)
3849 {
3850 using namespace Zivid::Detail::TypeTraits;
3851
3852 static_assert(
3853 AllArgsDecayedAreUnique<Args...>::value,
3854 "Found duplicate types among the arguments passed to Cluster(...). "
3855 "Types should be listed at most once.");
3856
3857 set(std::forward<Args>(args)...);
3858 }
3859
3873#ifndef NO_DOC
3874 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
3875#else
3876 template<typename... Args>
3877#endif
3878 void set(Args &&...args)
3879 {
3880 using namespace Zivid::Detail::TypeTraits;
3881
3882 using AllArgsAreDescendantNodes =
3883 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
3884 static_assert(
3885 AllArgsAreDescendantNodes::value,
3886 "All arguments passed to set(...) must be descendant nodes.");
3887
3888 static_assert(
3889 AllArgsDecayedAreUnique<Args...>::value,
3890 "Found duplicate types among the arguments passed to set(...). "
3891 "Types should be listed at most once.");
3892
3893 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
3894 }
3895
3910#ifndef NO_DOC
3911 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
3912#else
3913 template<typename... Args>
3914#endif
3915 Cluster copyWith(Args &&...args) const
3916 {
3917 using namespace Zivid::Detail::TypeTraits;
3918
3919 using AllArgsAreDescendantNodes =
3920 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
3921 static_assert(
3922 AllArgsAreDescendantNodes::value,
3923 "All arguments passed to copyWith(...) must be descendant nodes.");
3924
3925 static_assert(
3926 AllArgsDecayedAreUnique<Args...>::value,
3927 "Found duplicate types among the arguments passed to copyWith(...). "
3928 "Types should be listed at most once.");
3929
3930 auto copy{ *this };
3931 copy.set(std::forward<Args>(args)...);
3932 return copy;
3933 }
3934
3936 const Removal &removal() const
3937 {
3938 return m_removal;
3939 }
3940
3943 {
3944 return m_removal;
3945 }
3946
3948 Cluster &set(const Removal &value)
3949 {
3950 m_removal = value;
3951 return *this;
3952 }
3953
3956 {
3957 m_removal.set(value);
3958 return *this;
3959 }
3960
3963 {
3964 m_removal.set(value);
3965 return *this;
3966 }
3967
3970 {
3971 m_removal.set(value);
3972 return *this;
3973 }
3974
3975 template<
3976 typename T,
3977 typename std::enable_if<
3978 std::is_same<T, Settings::Processing::Filters::Cluster::Removal>::value,
3979 int>::type = 0>
3981 {
3982 return m_removal;
3983 }
3984
3985 template<
3986 typename T,
3987 typename std::enable_if<
3988 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::Enabled>::value,
3989 int>::type = 0>
3991 {
3993 }
3994
3995 template<
3996 typename T,
3997 typename std::enable_if<
3998 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>::
3999 value,
4000 int>::type = 0>
4002 {
4004 }
4005
4006 template<
4007 typename T,
4008 typename std::enable_if<
4009 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MinArea>::value,
4010 int>::type = 0>
4012 {
4014 }
4015
4016 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
4018 {
4019 return m_removal;
4020 }
4021
4023 template<typename F>
4024 void forEach(const F &f) const
4025 {
4026 f(m_removal);
4027 }
4028
4030 template<typename F>
4031 void forEach(const F &f)
4032 {
4033 f(m_removal);
4034 }
4035
4037 bool operator==(const Cluster &other) const;
4038
4040 bool operator!=(const Cluster &other) const;
4041
4043 std::string toString() const;
4044
4046 friend std::ostream &operator<<(std::ostream &stream, const Cluster &value)
4047 {
4048 return stream << value.toString();
4049 }
4050
4051 private:
4052 void setFromString(const std::string &value);
4053
4054 void setFromString(const std::string &fullPath, const std::string &value);
4055
4056 std::string getString(const std::string &fullPath) const;
4057
4058 Removal m_removal;
4059
4060 friend struct DataModel::Detail::Befriend<Cluster>;
4061 };
4062
4064
4065 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
4067 {
4068 public:
4071
4073 static constexpr const char *path{ "Processing/Filters/Experimental" };
4074
4076 static constexpr const char *name{ "Experimental" };
4077
4079 static constexpr const char *description{
4080 R"description(Experimental filters. These may be renamed, moved or deleted in the future.)description"
4081 };
4082
4088
4089 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
4091 {
4092 public:
4095
4097 static constexpr const char *path{ "Processing/Filters/Experimental/ContrastDistortion" };
4098
4100 static constexpr const char *name{ "ContrastDistortion" };
4101
4103 static constexpr const char *description{
4104 R"description(Corrects artifacts that appear when imaging scenes with large texture gradients
4105or high contrast. These artifacts are caused by blurring in the lens. The filter
4106works best when aperture values are chosen such that the camera has quite good focus.
4107The filter also supports removing the points that experience a large correction.
4108)description"
4109 };
4110
4112
4113 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
4115 {
4116 public:
4119
4121 static constexpr const char *path{
4122 "Processing/Filters/Experimental/ContrastDistortion/Correction"
4123 };
4124
4126 static constexpr const char *name{ "Correction" };
4127
4129 static constexpr const char *description{ R"description(Correction)description" };
4130
4132
4133 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
4135 {
4136 public:
4139
4141 static constexpr const char *path{
4142 "Processing/Filters/Experimental/ContrastDistortion/Correction/Enabled"
4143 };
4144
4146 static constexpr const char *name{ "Enabled" };
4147
4149 static constexpr const char *description{ R"description(Enabled)description" };
4150
4152 using ValueType = bool;
4153 static const Enabled yes;
4154 static const Enabled no;
4155
4157 static std::set<bool> validValues()
4158 {
4159 return { false, true };
4160 }
4161
4163 Enabled() = default;
4164
4166 explicit constexpr Enabled(bool value)
4167 : m_opt{ value }
4168 {}
4169
4174 bool value() const;
4175
4177 bool hasValue() const;
4178
4180 void reset();
4181
4183 std::string toString() const;
4184
4186 bool operator==(const Enabled &other) const
4187 {
4188 return m_opt == other.m_opt;
4189 }
4190
4192 bool operator!=(const Enabled &other) const
4193 {
4194 return m_opt != other.m_opt;
4195 }
4196
4198 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
4199 {
4200 return stream << value.toString();
4201 }
4202
4203 private:
4204 void setFromString(const std::string &value);
4205
4206 Zivid::DataModel::Detail::Optional<bool> m_opt;
4207
4208 friend struct DataModel::Detail::Befriend<Enabled>;
4209 };
4210
4212
4213 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
4215 {
4216 public:
4219
4221 static constexpr const char *path{
4222 "Processing/Filters/Experimental/ContrastDistortion/Correction/Strength"
4223 };
4224
4226 static constexpr const char *name{ "Strength" };
4227
4229 static constexpr const char *description{
4230 R"description(Higher values gives more correction.)description"
4231 };
4232
4234 using ValueType = double;
4235
4237 static constexpr Range<double> validRange()
4238 {
4239 return { 0.0, 1.0 };
4240 }
4241
4243 Strength() = default;
4244
4246 explicit constexpr Strength(double value)
4247 : m_opt{ verifyValue(value) }
4248 {}
4249
4254 double value() const;
4255
4257 bool hasValue() const;
4258
4260 void reset();
4261
4263 std::string toString() const;
4264
4266 bool operator==(const Strength &other) const
4267 {
4268 return m_opt == other.m_opt;
4269 }
4270
4272 bool operator!=(const Strength &other) const
4273 {
4274 return m_opt != other.m_opt;
4275 }
4276
4278 bool operator<(const Strength &other) const
4279 {
4280 return m_opt < other.m_opt;
4281 }
4282
4284 bool operator>(const Strength &other) const
4285 {
4286 return m_opt > other.m_opt;
4287 }
4288
4290 bool operator<=(const Strength &other) const
4291 {
4292 return m_opt <= other.m_opt;
4293 }
4294
4296 bool operator>=(const Strength &other) const
4297 {
4298 return m_opt >= other.m_opt;
4299 }
4300
4302 friend std::ostream &operator<<(std::ostream &stream, const Strength &value)
4303 {
4304 return stream << value.toString();
4305 }
4306
4307 private:
4308 void setFromString(const std::string &value);
4309
4310 constexpr ValueType static verifyValue(const ValueType &value)
4311 {
4312 return validRange().isInRange(value)
4313 ? value
4314 : throw std::out_of_range{ "Strength{ " + std::to_string(value)
4315 + " } is not in range ["
4316 + std::to_string(validRange().min()) + ", "
4317 + std::to_string(validRange().max()) + "]" };
4318 }
4319
4320 Zivid::DataModel::Detail::Optional<double> m_opt;
4321
4322 friend struct DataModel::Detail::Befriend<Strength>;
4323 };
4324
4325 using Descendants = std::tuple<
4328
4331
4344#ifndef NO_DOC
4345 template<
4346 typename... Args,
4347 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
4348 typename std::enable_if<
4349 Zivid::Detail::TypeTraits::
4350 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
4351 int>::type = 0>
4352#else
4353 template<typename... Args>
4354#endif
4355 explicit Correction(Args &&...args)
4356 {
4357 using namespace Zivid::Detail::TypeTraits;
4358
4359 static_assert(
4360 AllArgsDecayedAreUnique<Args...>::value,
4361 "Found duplicate types among the arguments passed to Correction(...). "
4362 "Types should be listed at most once.");
4363
4364 set(std::forward<Args>(args)...);
4365 }
4366
4378#ifndef NO_DOC
4379 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
4380#else
4381 template<typename... Args>
4382#endif
4383 void set(Args &&...args)
4384 {
4385 using namespace Zivid::Detail::TypeTraits;
4386
4387 using AllArgsAreDescendantNodes =
4388 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
4389 static_assert(
4390 AllArgsAreDescendantNodes::value,
4391 "All arguments passed to set(...) must be descendant nodes.");
4392
4393 static_assert(
4394 AllArgsDecayedAreUnique<Args...>::value,
4395 "Found duplicate types among the arguments passed to set(...). "
4396 "Types should be listed at most once.");
4397
4398 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
4399 }
4400
4413#ifndef NO_DOC
4414 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
4415#else
4416 template<typename... Args>
4417#endif
4418 Correction copyWith(Args &&...args) const
4419 {
4420 using namespace Zivid::Detail::TypeTraits;
4421
4422 using AllArgsAreDescendantNodes =
4423 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
4424 static_assert(
4425 AllArgsAreDescendantNodes::value,
4426 "All arguments passed to copyWith(...) must be descendant nodes.");
4427
4428 static_assert(
4429 AllArgsDecayedAreUnique<Args...>::value,
4430 "Found duplicate types among the arguments passed to copyWith(...). "
4431 "Types should be listed at most once.");
4432
4433 auto copy{ *this };
4434 copy.set(std::forward<Args>(args)...);
4435 return copy;
4436 }
4437
4439 const Enabled &isEnabled() const
4440 {
4441 return m_enabled;
4442 }
4443
4446 {
4447 return m_enabled;
4448 }
4449
4451 Correction &set(const Enabled &value)
4452 {
4453 m_enabled = value;
4454 return *this;
4455 }
4456
4458 const Strength &strength() const
4459 {
4460 return m_strength;
4461 }
4462
4465 {
4466 return m_strength;
4467 }
4468
4470 Correction &set(const Strength &value)
4471 {
4472 m_strength = value;
4473 return *this;
4474 }
4475
4476 template<
4477 typename T,
4478 typename std::enable_if<
4479 std::is_same<
4480 T,
4481 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::
4482 Enabled>::value,
4483 int>::type = 0>
4485 get() const
4486 {
4487 return m_enabled;
4488 }
4489
4490 template<
4491 typename T,
4492 typename std::enable_if<
4493 std::is_same<
4494 T,
4495 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::
4496 Strength>::value,
4497 int>::type = 0>
4499 &
4500 get() const
4501 {
4502 return m_strength;
4503 }
4504
4505 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
4507 get() const
4508 {
4509 return m_enabled;
4510 }
4511
4512 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
4514 &
4515 get() const
4516 {
4517 return m_strength;
4518 }
4519
4521 template<typename F>
4522 void forEach(const F &f) const
4523 {
4524 f(m_enabled);
4525 f(m_strength);
4526 }
4527
4529 template<typename F>
4530 void forEach(const F &f)
4531 {
4532 f(m_enabled);
4533 f(m_strength);
4534 }
4535
4537 bool operator==(const Correction &other) const;
4538
4540 bool operator!=(const Correction &other) const;
4541
4543 std::string toString() const;
4544
4546 friend std::ostream &operator<<(std::ostream &stream, const Correction &value)
4547 {
4548 return stream << value.toString();
4549 }
4550
4551 private:
4552 void setFromString(const std::string &value);
4553
4554 void setFromString(const std::string &fullPath, const std::string &value);
4555
4556 std::string getString(const std::string &fullPath) const;
4557
4558 Enabled m_enabled;
4559 Strength m_strength;
4560
4561 friend struct DataModel::Detail::Befriend<Correction>;
4562 };
4563
4565
4566 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
4568 {
4569 public:
4572
4574 static constexpr const char *path{
4575 "Processing/Filters/Experimental/ContrastDistortion/Removal"
4576 };
4577
4579 static constexpr const char *name{ "Removal" };
4580
4582 static constexpr const char *description{ R"description(Removal)description" };
4583
4585
4586 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
4588 {
4589 public:
4592
4594 static constexpr const char *path{
4595 "Processing/Filters/Experimental/ContrastDistortion/Removal/Enabled"
4596 };
4597
4599 static constexpr const char *name{ "Enabled" };
4600
4602 static constexpr const char *description{ R"description(Enabled)description" };
4603
4605 using ValueType = bool;
4606 static const Enabled yes;
4607 static const Enabled no;
4608
4610 static std::set<bool> validValues()
4611 {
4612 return { false, true };
4613 }
4614
4616 Enabled() = default;
4617
4619 explicit constexpr Enabled(bool value)
4620 : m_opt{ value }
4621 {}
4622
4627 bool value() const;
4628
4630 bool hasValue() const;
4631
4633 void reset();
4634
4636 std::string toString() const;
4637
4639 bool operator==(const Enabled &other) const
4640 {
4641 return m_opt == other.m_opt;
4642 }
4643
4645 bool operator!=(const Enabled &other) const
4646 {
4647 return m_opt != other.m_opt;
4648 }
4649
4651 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
4652 {
4653 return stream << value.toString();
4654 }
4655
4656 private:
4657 void setFromString(const std::string &value);
4658
4659 Zivid::DataModel::Detail::Optional<bool> m_opt;
4660
4661 friend struct DataModel::Detail::Befriend<Enabled>;
4662 };
4663
4665
4666 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
4668 {
4669 public:
4672
4674 static constexpr const char *path{
4675 "Processing/Filters/Experimental/ContrastDistortion/Removal/Threshold"
4676 };
4677
4679 static constexpr const char *name{ "Threshold" };
4680
4682 static constexpr const char *description{
4683 R"description(Higher values remove more points.)description"
4684 };
4685
4687 using ValueType = double;
4688
4690 static constexpr Range<double> validRange()
4691 {
4692 return { 0.0, 1.0 };
4693 }
4694
4696 Threshold() = default;
4697
4699 explicit constexpr Threshold(double value)
4700 : m_opt{ verifyValue(value) }
4701 {}
4702
4707 double value() const;
4708
4710 bool hasValue() const;
4711
4713 void reset();
4714
4716 std::string toString() const;
4717
4719 bool operator==(const Threshold &other) const
4720 {
4721 return m_opt == other.m_opt;
4722 }
4723
4725 bool operator!=(const Threshold &other) const
4726 {
4727 return m_opt != other.m_opt;
4728 }
4729
4731 bool operator<(const Threshold &other) const
4732 {
4733 return m_opt < other.m_opt;
4734 }
4735
4737 bool operator>(const Threshold &other) const
4738 {
4739 return m_opt > other.m_opt;
4740 }
4741
4743 bool operator<=(const Threshold &other) const
4744 {
4745 return m_opt <= other.m_opt;
4746 }
4747
4749 bool operator>=(const Threshold &other) const
4750 {
4751 return m_opt >= other.m_opt;
4752 }
4753
4755 friend std::ostream &operator<<(std::ostream &stream, const Threshold &value)
4756 {
4757 return stream << value.toString();
4758 }
4759
4760 private:
4761 void setFromString(const std::string &value);
4762
4763 constexpr ValueType static verifyValue(const ValueType &value)
4764 {
4765 return validRange().isInRange(value)
4766 ? value
4767 : throw std::out_of_range{ "Threshold{ " + std::to_string(value)
4768 + " } is not in range ["
4769 + std::to_string(validRange().min()) + ", "
4770 + std::to_string(validRange().max()) + "]" };
4771 }
4772
4773 Zivid::DataModel::Detail::Optional<double> m_opt;
4774
4775 friend struct DataModel::Detail::Befriend<Threshold>;
4776 };
4777
4778 using Descendants = std::tuple<
4781
4784
4797#ifndef NO_DOC
4798 template<
4799 typename... Args,
4800 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
4801 typename std::enable_if<
4802 Zivid::Detail::TypeTraits::
4803 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
4804 int>::type = 0>
4805#else
4806 template<typename... Args>
4807#endif
4808 explicit Removal(Args &&...args)
4809 {
4810 using namespace Zivid::Detail::TypeTraits;
4811
4812 static_assert(
4813 AllArgsDecayedAreUnique<Args...>::value,
4814 "Found duplicate types among the arguments passed to Removal(...). "
4815 "Types should be listed at most once.");
4816
4817 set(std::forward<Args>(args)...);
4818 }
4819
4831#ifndef NO_DOC
4832 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
4833#else
4834 template<typename... Args>
4835#endif
4836 void set(Args &&...args)
4837 {
4838 using namespace Zivid::Detail::TypeTraits;
4839
4840 using AllArgsAreDescendantNodes =
4841 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
4842 static_assert(
4843 AllArgsAreDescendantNodes::value,
4844 "All arguments passed to set(...) must be descendant nodes.");
4845
4846 static_assert(
4847 AllArgsDecayedAreUnique<Args...>::value,
4848 "Found duplicate types among the arguments passed to set(...). "
4849 "Types should be listed at most once.");
4850
4851 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
4852 }
4853
4866#ifndef NO_DOC
4867 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
4868#else
4869 template<typename... Args>
4870#endif
4871 Removal copyWith(Args &&...args) const
4872 {
4873 using namespace Zivid::Detail::TypeTraits;
4874
4875 using AllArgsAreDescendantNodes =
4876 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
4877 static_assert(
4878 AllArgsAreDescendantNodes::value,
4879 "All arguments passed to copyWith(...) must be descendant nodes.");
4880
4881 static_assert(
4882 AllArgsDecayedAreUnique<Args...>::value,
4883 "Found duplicate types among the arguments passed to copyWith(...). "
4884 "Types should be listed at most once.");
4885
4886 auto copy{ *this };
4887 copy.set(std::forward<Args>(args)...);
4888 return copy;
4889 }
4890
4892 const Enabled &isEnabled() const
4893 {
4894 return m_enabled;
4895 }
4896
4899 {
4900 return m_enabled;
4901 }
4902
4904 Removal &set(const Enabled &value)
4905 {
4906 m_enabled = value;
4907 return *this;
4908 }
4909
4911 const Threshold &threshold() const
4912 {
4913 return m_threshold;
4914 }
4915
4918 {
4919 return m_threshold;
4920 }
4921
4923 Removal &set(const Threshold &value)
4924 {
4925 m_threshold = value;
4926 return *this;
4927 }
4928
4929 template<
4930 typename T,
4931 typename std::enable_if<
4932 std::is_same<
4933 T,
4934 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::
4935 Enabled>::value,
4936 int>::type = 0>
4938 get() const
4939 {
4940 return m_enabled;
4941 }
4942
4943 template<
4944 typename T,
4945 typename std::enable_if<
4946 std::is_same<
4947 T,
4948 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::
4949 Threshold>::value,
4950 int>::type = 0>
4952 get() const
4953 {
4954 return m_threshold;
4955 }
4956
4957 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
4959 get() const
4960 {
4961 return m_enabled;
4962 }
4963
4964 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
4966 get() const
4967 {
4968 return m_threshold;
4969 }
4970
4972 template<typename F>
4973 void forEach(const F &f) const
4974 {
4975 f(m_enabled);
4976 f(m_threshold);
4977 }
4978
4980 template<typename F>
4981 void forEach(const F &f)
4982 {
4983 f(m_enabled);
4984 f(m_threshold);
4985 }
4986
4988 bool operator==(const Removal &other) const;
4989
4991 bool operator!=(const Removal &other) const;
4992
4994 std::string toString() const;
4995
4997 friend std::ostream &operator<<(std::ostream &stream, const Removal &value)
4998 {
4999 return stream << value.toString();
5000 }
5001
5002 private:
5003 void setFromString(const std::string &value);
5004
5005 void setFromString(const std::string &fullPath, const std::string &value);
5006
5007 std::string getString(const std::string &fullPath) const;
5008
5009 Enabled m_enabled;
5010 Threshold m_threshold;
5011
5012 friend struct DataModel::Detail::Befriend<Removal>;
5013 };
5014
5015 using Descendants = std::tuple<
5022
5025
5042#ifndef NO_DOC
5043 template<
5044 typename... Args,
5045 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
5046 typename std::enable_if<
5047 Zivid::Detail::TypeTraits::
5048 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
5049 int>::type = 0>
5050#else
5051 template<typename... Args>
5052#endif
5053 explicit ContrastDistortion(Args &&...args)
5054 {
5055 using namespace Zivid::Detail::TypeTraits;
5056
5057 static_assert(
5058 AllArgsDecayedAreUnique<Args...>::value,
5059 "Found duplicate types among the arguments passed to ContrastDistortion(...). "
5060 "Types should be listed at most once.");
5061
5062 set(std::forward<Args>(args)...);
5063 }
5064
5080#ifndef NO_DOC
5081 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
5082#else
5083 template<typename... Args>
5084#endif
5085 void set(Args &&...args)
5086 {
5087 using namespace Zivid::Detail::TypeTraits;
5088
5089 using AllArgsAreDescendantNodes =
5090 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
5091 static_assert(
5092 AllArgsAreDescendantNodes::value,
5093 "All arguments passed to set(...) must be descendant nodes.");
5094
5095 static_assert(
5096 AllArgsDecayedAreUnique<Args...>::value,
5097 "Found duplicate types among the arguments passed to set(...). "
5098 "Types should be listed at most once.");
5099
5100 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
5101 }
5102
5119#ifndef NO_DOC
5120 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
5121#else
5122 template<typename... Args>
5123#endif
5124 ContrastDistortion copyWith(Args &&...args) const
5125 {
5126 using namespace Zivid::Detail::TypeTraits;
5127
5128 using AllArgsAreDescendantNodes =
5129 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
5130 static_assert(
5131 AllArgsAreDescendantNodes::value,
5132 "All arguments passed to copyWith(...) must be descendant nodes.");
5133
5134 static_assert(
5135 AllArgsDecayedAreUnique<Args...>::value,
5136 "Found duplicate types among the arguments passed to copyWith(...). "
5137 "Types should be listed at most once.");
5138
5139 auto copy{ *this };
5140 copy.set(std::forward<Args>(args)...);
5141 return copy;
5142 }
5143
5145 const Correction &correction() const
5146 {
5147 return m_correction;
5148 }
5149
5152 {
5153 return m_correction;
5154 }
5155
5158 {
5159 m_correction = value;
5160 return *this;
5161 }
5162
5165 {
5166 m_correction.set(value);
5167 return *this;
5168 }
5169
5172 {
5173 m_correction.set(value);
5174 return *this;
5175 }
5176
5178 const Removal &removal() const
5179 {
5180 return m_removal;
5181 }
5182
5185 {
5186 return m_removal;
5187 }
5188
5191 {
5192 m_removal = value;
5193 return *this;
5194 }
5195
5198 {
5199 m_removal.set(value);
5200 return *this;
5201 }
5202
5205 {
5206 m_removal.set(value);
5207 return *this;
5208 }
5209
5210 template<
5211 typename T,
5212 typename std::enable_if<
5213 std::is_same<
5214 T,
5216 int>::type = 0>
5218 {
5219 return m_correction;
5220 }
5221
5222 template<
5223 typename T,
5224 typename std::enable_if<
5225 std::is_same<
5226 T,
5227 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::
5228 Enabled>::value,
5229 int>::type = 0>
5231 get() const
5232 {
5233 return m_correction.get<
5235 }
5236
5237 template<
5238 typename T,
5239 typename std::enable_if<
5240 std::is_same<
5241 T,
5242 Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::
5243 Strength>::value,
5244 int>::type = 0>
5246 get() const
5247 {
5248 return m_correction.get<Settings::Processing::Filters::Experimental::ContrastDistortion::
5249 Correction::Strength>();
5250 }
5251
5252 template<
5253 typename T,
5254 typename std::enable_if<
5255 std::is_same<
5256 T,
5258 int>::type = 0>
5260 {
5261 return m_removal;
5262 }
5263
5264 template<
5265 typename T,
5266 typename std::enable_if<
5267 std::is_same<
5268 T,
5270 value,
5271 int>::type = 0>
5273 const
5274 {
5275 return m_removal.get<
5277 }
5278
5279 template<
5280 typename T,
5281 typename std::enable_if<
5282 std::is_same<
5283 T,
5284 Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::
5285 Threshold>::value,
5286 int>::type = 0>
5288 const
5289 {
5290 return m_removal.get<
5292 }
5293
5294 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
5296 {
5297 return m_correction;
5298 }
5299
5300 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
5302 {
5303 return m_removal;
5304 }
5305
5307 template<typename F>
5308 void forEach(const F &f) const
5309 {
5310 f(m_correction);
5311 f(m_removal);
5312 }
5313
5315 template<typename F>
5316 void forEach(const F &f)
5317 {
5318 f(m_correction);
5319 f(m_removal);
5320 }
5321
5323 bool operator==(const ContrastDistortion &other) const;
5324
5326 bool operator!=(const ContrastDistortion &other) const;
5327
5329 std::string toString() const;
5330
5332 friend std::ostream &operator<<(std::ostream &stream, const ContrastDistortion &value)
5333 {
5334 return stream << value.toString();
5335 }
5336
5337 private:
5338 void setFromString(const std::string &value);
5339
5340 void setFromString(const std::string &fullPath, const std::string &value);
5341
5342 std::string getString(const std::string &fullPath) const;
5343
5344 Correction m_correction;
5345 Removal m_removal;
5346
5347 friend struct DataModel::Detail::Befriend<ContrastDistortion>;
5348 };
5349
5352
5353 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
5355 {
5356 public:
5359
5361 static constexpr const char *path{ "Processing/Filters/Experimental/HoleFilling" };
5362
5364 static constexpr const char *name{ "HoleFilling" };
5365
5367 static constexpr const char *description{
5368 R"description(Fills missing points considering a circular neighborhood.
5369)description"
5370 };
5371
5373
5374 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
5376 {
5377 public:
5380
5382 static constexpr const char *path{ "Processing/Filters/Experimental/HoleFilling/Enabled" };
5383
5385 static constexpr const char *name{ "Enabled" };
5386
5388 static constexpr const char *description{ R"description(Enabled)description" };
5389
5391 using ValueType = bool;
5392 static const Enabled yes;
5393 static const Enabled no;
5394
5396 static std::set<bool> validValues()
5397 {
5398 return { false, true };
5399 }
5400
5402 Enabled() = default;
5403
5405 explicit constexpr Enabled(bool value)
5406 : m_opt{ value }
5407 {}
5408
5413 bool value() const;
5414
5416 bool hasValue() const;
5417
5419 void reset();
5420
5422 std::string toString() const;
5423
5425 bool operator==(const Enabled &other) const
5426 {
5427 return m_opt == other.m_opt;
5428 }
5429
5431 bool operator!=(const Enabled &other) const
5432 {
5433 return m_opt != other.m_opt;
5434 }
5435
5437 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
5438 {
5439 return stream << value.toString();
5440 }
5441
5442 private:
5443 void setFromString(const std::string &value);
5444
5445 Zivid::DataModel::Detail::Optional<bool> m_opt;
5446
5447 friend struct DataModel::Detail::Befriend<Enabled>;
5448 };
5449
5454
5455 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
5457 {
5458 public:
5461
5463 static constexpr const char *path{ "Processing/Filters/Experimental/HoleFilling/HoleSize" };
5464
5466 static constexpr const char *name{ "HoleSize" };
5467
5469 static constexpr const char *description{
5470 R"description(Relative diameter of holes to fill. Increasing this will fill more points, but require more
5471computation time. The maximum allowed hole size scales with distance, so that we allow
5472filling larger holes at greater distances, measured in mm.
5473)description"
5474 };
5475
5477 using ValueType = double;
5478
5480 static constexpr Range<double> validRange()
5481 {
5482 return { 0.0, 1.0 };
5483 }
5484
5486 HoleSize() = default;
5487
5489 explicit constexpr HoleSize(double value)
5490 : m_opt{ verifyValue(value) }
5491 {}
5492
5497 double value() const;
5498
5500 bool hasValue() const;
5501
5503 void reset();
5504
5506 std::string toString() const;
5507
5509 bool operator==(const HoleSize &other) const
5510 {
5511 return m_opt == other.m_opt;
5512 }
5513
5515 bool operator!=(const HoleSize &other) const
5516 {
5517 return m_opt != other.m_opt;
5518 }
5519
5521 bool operator<(const HoleSize &other) const
5522 {
5523 return m_opt < other.m_opt;
5524 }
5525
5527 bool operator>(const HoleSize &other) const
5528 {
5529 return m_opt > other.m_opt;
5530 }
5531
5533 bool operator<=(const HoleSize &other) const
5534 {
5535 return m_opt <= other.m_opt;
5536 }
5537
5539 bool operator>=(const HoleSize &other) const
5540 {
5541 return m_opt >= other.m_opt;
5542 }
5543
5545 friend std::ostream &operator<<(std::ostream &stream, const HoleSize &value)
5546 {
5547 return stream << value.toString();
5548 }
5549
5550 private:
5551 void setFromString(const std::string &value);
5552
5553 constexpr ValueType static verifyValue(const ValueType &value)
5554 {
5555 return validRange().isInRange(value)
5556 ? value
5557 : throw std::out_of_range{ "HoleSize{ " + std::to_string(value)
5558 + " } is not in range ["
5559 + std::to_string(validRange().min()) + ", "
5560 + std::to_string(validRange().max()) + "]" };
5561 }
5562
5563 Zivid::DataModel::Detail::Optional<double> m_opt;
5564
5565 friend struct DataModel::Detail::Befriend<HoleSize>;
5566 };
5567
5573
5574 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
5576 {
5577 public:
5580
5582 static constexpr const char *path{
5583 "Processing/Filters/Experimental/HoleFilling/Strictness"
5584 };
5585
5587 static constexpr const char *name{ "Strictness" };
5588
5590 static constexpr const char *description{
5591 R"description(Level of strictness when considering if a point should be filled. A higher level of
5592strictness requires a missing point to be surrounded by valid points on more sides in
5593order to be filled. Increasing this will fill fewer points, but it will be less likely to
5594fill gaps that are not circular, for example between two edges.
5595)description"
5596 };
5597
5599 using ValueType = int32_t;
5600
5602 static constexpr Range<int32_t> validRange()
5603 {
5604 return { 1, 4 };
5605 }
5606
5608 Strictness() = default;
5609
5611 explicit constexpr Strictness(int32_t value)
5612 : m_opt{ verifyValue(value) }
5613 {}
5614
5619 int32_t value() const;
5620
5622 bool hasValue() const;
5623
5625 void reset();
5626
5628 std::string toString() const;
5629
5631 bool operator==(const Strictness &other) const
5632 {
5633 return m_opt == other.m_opt;
5634 }
5635
5637 bool operator!=(const Strictness &other) const
5638 {
5639 return m_opt != other.m_opt;
5640 }
5641
5643 bool operator<(const Strictness &other) const
5644 {
5645 return m_opt < other.m_opt;
5646 }
5647
5649 bool operator>(const Strictness &other) const
5650 {
5651 return m_opt > other.m_opt;
5652 }
5653
5655 bool operator<=(const Strictness &other) const
5656 {
5657 return m_opt <= other.m_opt;
5658 }
5659
5661 bool operator>=(const Strictness &other) const
5662 {
5663 return m_opt >= other.m_opt;
5664 }
5665
5667 friend std::ostream &operator<<(std::ostream &stream, const Strictness &value)
5668 {
5669 return stream << value.toString();
5670 }
5671
5672 private:
5673 void setFromString(const std::string &value);
5674
5675 constexpr ValueType static verifyValue(const ValueType &value)
5676 {
5677 return validRange().isInRange(value)
5678 ? value
5679 : throw std::out_of_range{ "Strictness{ " + std::to_string(value)
5680 + " } is not in range ["
5681 + std::to_string(validRange().min()) + ", "
5682 + std::to_string(validRange().max()) + "]" };
5683 }
5684
5685 Zivid::DataModel::Detail::Optional<int32_t> m_opt;
5686
5687 friend struct DataModel::Detail::Befriend<Strictness>;
5688 };
5689
5690 using Descendants = std::tuple<
5694
5697
5711#ifndef NO_DOC
5712 template<
5713 typename... Args,
5714 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
5715 typename std::enable_if<
5716 Zivid::Detail::TypeTraits::
5717 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
5718 int>::type = 0>
5719#else
5720 template<typename... Args>
5721#endif
5722 explicit HoleFilling(Args &&...args)
5723 {
5724 using namespace Zivid::Detail::TypeTraits;
5725
5726 static_assert(
5727 AllArgsDecayedAreUnique<Args...>::value,
5728 "Found duplicate types among the arguments passed to HoleFilling(...). "
5729 "Types should be listed at most once.");
5730
5731 set(std::forward<Args>(args)...);
5732 }
5733
5746#ifndef NO_DOC
5747 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
5748#else
5749 template<typename... Args>
5750#endif
5751 void set(Args &&...args)
5752 {
5753 using namespace Zivid::Detail::TypeTraits;
5754
5755 using AllArgsAreDescendantNodes =
5756 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
5757 static_assert(
5758 AllArgsAreDescendantNodes::value,
5759 "All arguments passed to set(...) must be descendant nodes.");
5760
5761 static_assert(
5762 AllArgsDecayedAreUnique<Args...>::value,
5763 "Found duplicate types among the arguments passed to set(...). "
5764 "Types should be listed at most once.");
5765
5766 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
5767 }
5768
5782#ifndef NO_DOC
5783 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
5784#else
5785 template<typename... Args>
5786#endif
5787 HoleFilling copyWith(Args &&...args) const
5788 {
5789 using namespace Zivid::Detail::TypeTraits;
5790
5791 using AllArgsAreDescendantNodes =
5792 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
5793 static_assert(
5794 AllArgsAreDescendantNodes::value,
5795 "All arguments passed to copyWith(...) must be descendant nodes.");
5796
5797 static_assert(
5798 AllArgsDecayedAreUnique<Args...>::value,
5799 "Found duplicate types among the arguments passed to copyWith(...). "
5800 "Types should be listed at most once.");
5801
5802 auto copy{ *this };
5803 copy.set(std::forward<Args>(args)...);
5804 return copy;
5805 }
5806
5808 const Enabled &isEnabled() const
5809 {
5810 return m_enabled;
5811 }
5812
5815 {
5816 return m_enabled;
5817 }
5818
5820 HoleFilling &set(const Enabled &value)
5821 {
5822 m_enabled = value;
5823 return *this;
5824 }
5825
5827 const HoleSize &holeSize() const
5828 {
5829 return m_holeSize;
5830 }
5831
5834 {
5835 return m_holeSize;
5836 }
5837
5839 HoleFilling &set(const HoleSize &value)
5840 {
5841 m_holeSize = value;
5842 return *this;
5843 }
5844
5846 const Strictness &strictness() const
5847 {
5848 return m_strictness;
5849 }
5850
5853 {
5854 return m_strictness;
5855 }
5856
5859 {
5860 m_strictness = value;
5861 return *this;
5862 }
5863
5864 template<
5865 typename T,
5866 typename std::enable_if<
5867 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Enabled>::
5868 value,
5869 int>::type = 0>
5871 {
5872 return m_enabled;
5873 }
5874
5875 template<
5876 typename T,
5877 typename std::enable_if<
5878 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>::
5879 value,
5880 int>::type = 0>
5882 {
5883 return m_holeSize;
5884 }
5885
5886 template<
5887 typename T,
5888 typename std::enable_if<
5889 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Strictness>::
5890 value,
5891 int>::type = 0>
5893 {
5894 return m_strictness;
5895 }
5896
5897 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
5899 {
5900 return m_enabled;
5901 }
5902
5903 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
5905 {
5906 return m_holeSize;
5907 }
5908
5909 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
5911 {
5912 return m_strictness;
5913 }
5914
5916 template<typename F>
5917 void forEach(const F &f) const
5918 {
5919 f(m_enabled);
5920 f(m_holeSize);
5921 f(m_strictness);
5922 }
5923
5925 template<typename F>
5926 void forEach(const F &f)
5927 {
5928 f(m_enabled);
5929 f(m_holeSize);
5930 f(m_strictness);
5931 }
5932
5934 bool operator==(const HoleFilling &other) const;
5935
5937 bool operator!=(const HoleFilling &other) const;
5938
5940 std::string toString() const;
5941
5943 friend std::ostream &operator<<(std::ostream &stream, const HoleFilling &value)
5944 {
5945 return stream << value.toString();
5946 }
5947
5948 private:
5949 void setFromString(const std::string &value);
5950
5951 void setFromString(const std::string &fullPath, const std::string &value);
5952
5953 std::string getString(const std::string &fullPath) const;
5954
5955 Enabled m_enabled;
5956 HoleSize m_holeSize;
5957 Strictness m_strictness;
5958
5959 friend struct DataModel::Detail::Befriend<HoleFilling>;
5960 };
5961
5962 using Descendants = std::tuple<
5974
5977
5999#ifndef NO_DOC
6000 template<
6001 typename... Args,
6002 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
6003 typename std::enable_if<
6004 Zivid::Detail::TypeTraits::
6005 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
6006 int>::type = 0>
6007#else
6008 template<typename... Args>
6009#endif
6010 explicit Experimental(Args &&...args)
6011 {
6012 using namespace Zivid::Detail::TypeTraits;
6013
6014 static_assert(
6015 AllArgsDecayedAreUnique<Args...>::value,
6016 "Found duplicate types among the arguments passed to Experimental(...). "
6017 "Types should be listed at most once.");
6018
6019 set(std::forward<Args>(args)...);
6020 }
6021
6042#ifndef NO_DOC
6043 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
6044#else
6045 template<typename... Args>
6046#endif
6047 void set(Args &&...args)
6048 {
6049 using namespace Zivid::Detail::TypeTraits;
6050
6051 using AllArgsAreDescendantNodes =
6052 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
6053 static_assert(
6054 AllArgsAreDescendantNodes::value,
6055 "All arguments passed to set(...) must be descendant nodes.");
6056
6057 static_assert(
6058 AllArgsDecayedAreUnique<Args...>::value,
6059 "Found duplicate types among the arguments passed to set(...). "
6060 "Types should be listed at most once.");
6061
6062 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
6063 }
6064
6086#ifndef NO_DOC
6087 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
6088#else
6089 template<typename... Args>
6090#endif
6091 Experimental copyWith(Args &&...args) const
6092 {
6093 using namespace Zivid::Detail::TypeTraits;
6094
6095 using AllArgsAreDescendantNodes =
6096 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
6097 static_assert(
6098 AllArgsAreDescendantNodes::value,
6099 "All arguments passed to copyWith(...) must be descendant nodes.");
6100
6101 static_assert(
6102 AllArgsDecayedAreUnique<Args...>::value,
6103 "Found duplicate types among the arguments passed to copyWith(...). "
6104 "Types should be listed at most once.");
6105
6106 auto copy{ *this };
6107 copy.set(std::forward<Args>(args)...);
6108 return copy;
6109 }
6110
6113 {
6114 return m_contrastDistortion;
6115 }
6116
6119 {
6120 return m_contrastDistortion;
6121 }
6122
6125 {
6126 m_contrastDistortion = value;
6127 return *this;
6128 }
6129
6132 {
6133 m_contrastDistortion.set(value);
6134 return *this;
6135 }
6136
6139 {
6140 m_contrastDistortion.set(value);
6141 return *this;
6142 }
6143
6146 {
6147 m_contrastDistortion.set(value);
6148 return *this;
6149 }
6150
6153 {
6154 m_contrastDistortion.set(value);
6155 return *this;
6156 }
6157
6160 {
6161 m_contrastDistortion.set(value);
6162 return *this;
6163 }
6164
6167 {
6168 m_contrastDistortion.set(value);
6169 return *this;
6170 }
6171
6174 {
6175 return m_holeFilling;
6176 }
6177
6180 {
6181 return m_holeFilling;
6182 }
6183
6186 {
6187 m_holeFilling = value;
6188 return *this;
6189 }
6190
6193 {
6194 m_holeFilling.set(value);
6195 return *this;
6196 }
6197
6200 {
6201 m_holeFilling.set(value);
6202 return *this;
6203 }
6204
6207 {
6208 m_holeFilling.set(value);
6209 return *this;
6210 }
6211
6212 template<
6213 typename T,
6214 typename std::enable_if<
6215 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
6216 int>::type = 0>
6218 {
6219 return m_contrastDistortion;
6220 }
6221
6222 template<
6223 typename T,
6224 typename std::enable_if<
6225 std::is_same<
6226 T,
6228 int>::type = 0>
6230 {
6231 return m_contrastDistortion
6233 }
6234
6235 template<
6236 typename T,
6237 typename std::enable_if<
6238 std::is_same<
6239 T,
6241 value,
6242 int>::type = 0>
6244 const
6245 {
6246 return m_contrastDistortion.get<
6248 }
6249
6250 template<
6251 typename T,
6252 typename std::enable_if<
6253 std::is_same<
6254 T,
6256 value,
6257 int>::type = 0>
6259 const
6260 {
6261 return m_contrastDistortion.get<
6263 }
6264
6265 template<
6266 typename T,
6267 typename std::enable_if<
6268 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::
6269 value,
6270 int>::type = 0>
6272 {
6273 return m_contrastDistortion
6275 }
6276
6277 template<
6278 typename T,
6279 typename std::enable_if<
6280 std::is_same<
6281 T,
6283 value,
6284 int>::type = 0>
6286 {
6287 return m_contrastDistortion
6289 }
6290
6291 template<
6292 typename T,
6293 typename std::enable_if<
6294 std::is_same<
6295 T,
6297 value,
6298 int>::type = 0>
6300 const
6301 {
6302 return m_contrastDistortion
6304 }
6305
6306 template<
6307 typename T,
6308 typename std::enable_if<
6309 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling>::value,
6310 int>::type = 0>
6312 {
6313 return m_holeFilling;
6314 }
6315
6316 template<
6317 typename T,
6318 typename std::enable_if<
6319 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Enabled>::value,
6320 int>::type = 0>
6322 {
6324 }
6325
6326 template<
6327 typename T,
6328 typename std::enable_if<
6329 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>::value,
6330 int>::type = 0>
6332 {
6334 }
6335
6336 template<
6337 typename T,
6338 typename std::enable_if<
6339 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Strictness>::
6340 value,
6341 int>::type = 0>
6343 {
6344 return m_holeFilling
6346 }
6347
6348 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
6350 {
6351 return m_contrastDistortion;
6352 }
6353
6354 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
6356 {
6357 return m_holeFilling;
6358 }
6359
6361 template<typename F>
6362 void forEach(const F &f) const
6363 {
6364 f(m_contrastDistortion);
6365 f(m_holeFilling);
6366 }
6367
6369 template<typename F>
6370 void forEach(const F &f)
6371 {
6372 f(m_contrastDistortion);
6373 f(m_holeFilling);
6374 }
6375
6377 bool operator==(const Experimental &other) const;
6378
6380 bool operator!=(const Experimental &other) const;
6381
6383 std::string toString() const;
6384
6386 friend std::ostream &operator<<(std::ostream &stream, const Experimental &value)
6387 {
6388 return stream << value.toString();
6389 }
6390
6391 private:
6392 void setFromString(const std::string &value);
6393
6394 void setFromString(const std::string &fullPath, const std::string &value);
6395
6396 std::string getString(const std::string &fullPath) const;
6397
6398 ContrastDistortion m_contrastDistortion;
6399 HoleFilling m_holeFilling;
6400
6401 friend struct DataModel::Detail::Befriend<Experimental>;
6402 };
6403
6405
6406 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
6408 {
6409 public:
6412
6414 static constexpr const char *path{ "Processing/Filters/Noise" };
6415
6417 static constexpr const char *name{ "Noise" };
6418
6420 static constexpr const char *description{
6421 R"description(Contains a filter that removes points with low signal-to-noise ratio (SNR))description"
6422 };
6423
6425
6426 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
6428 {
6429 public:
6432
6434 static constexpr const char *path{ "Processing/Filters/Noise/Removal" };
6435
6437 static constexpr const char *name{ "Removal" };
6438
6440 static constexpr const char *description{
6441 R"description(Discard points with signal-to-noise ratio (SNR) values below a threshold)description"
6442 };
6443
6445
6446 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
6448 {
6449 public:
6452
6454 static constexpr const char *path{ "Processing/Filters/Noise/Removal/Enabled" };
6455
6457 static constexpr const char *name{ "Enabled" };
6458
6460 static constexpr const char *description{
6461 R"description(Enable or disable the SNR filter)description"
6462 };
6463
6465 using ValueType = bool;
6466 static const Enabled yes;
6467 static const Enabled no;
6468
6470 static std::set<bool> validValues()
6471 {
6472 return { false, true };
6473 }
6474
6476 Enabled() = default;
6477
6479 explicit constexpr Enabled(bool value)
6480 : m_opt{ value }
6481 {}
6482
6487 bool value() const;
6488
6490 bool hasValue() const;
6491
6493 void reset();
6494
6496 std::string toString() const;
6497
6499 bool operator==(const Enabled &other) const
6500 {
6501 return m_opt == other.m_opt;
6502 }
6503
6505 bool operator!=(const Enabled &other) const
6506 {
6507 return m_opt != other.m_opt;
6508 }
6509
6511 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
6512 {
6513 return stream << value.toString();
6514 }
6515
6516 private:
6517 void setFromString(const std::string &value);
6518
6519 Zivid::DataModel::Detail::Optional<bool> m_opt;
6520
6521 friend struct DataModel::Detail::Befriend<Enabled>;
6522 };
6523
6525
6526 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
6528 {
6529 public:
6532
6534 static constexpr const char *path{ "Processing/Filters/Noise/Removal/Threshold" };
6535
6537 static constexpr const char *name{ "Threshold" };
6538
6540 static constexpr const char *description{
6541 R"description(Discard points with signal-to-noise ratio (SNR) below the given value)description"
6542 };
6543
6545 using ValueType = double;
6546
6548 static constexpr Range<double> validRange()
6549 {
6550 return { 0.0, 100.0 };
6551 }
6552
6554 Threshold() = default;
6555
6557 explicit constexpr Threshold(double value)
6558 : m_opt{ verifyValue(value) }
6559 {}
6560
6565 double value() const;
6566
6568 bool hasValue() const;
6569
6571 void reset();
6572
6574 std::string toString() const;
6575
6577 bool operator==(const Threshold &other) const
6578 {
6579 return m_opt == other.m_opt;
6580 }
6581
6583 bool operator!=(const Threshold &other) const
6584 {
6585 return m_opt != other.m_opt;
6586 }
6587
6589 bool operator<(const Threshold &other) const
6590 {
6591 return m_opt < other.m_opt;
6592 }
6593
6595 bool operator>(const Threshold &other) const
6596 {
6597 return m_opt > other.m_opt;
6598 }
6599
6601 bool operator<=(const Threshold &other) const
6602 {
6603 return m_opt <= other.m_opt;
6604 }
6605
6607 bool operator>=(const Threshold &other) const
6608 {
6609 return m_opt >= other.m_opt;
6610 }
6611
6613 friend std::ostream &operator<<(std::ostream &stream, const Threshold &value)
6614 {
6615 return stream << value.toString();
6616 }
6617
6618 private:
6619 void setFromString(const std::string &value);
6620
6621 constexpr ValueType static verifyValue(const ValueType &value)
6622 {
6623 return validRange().isInRange(value)
6624 ? value
6625 : throw std::out_of_range{ "Threshold{ " + std::to_string(value)
6626 + " } is not in range ["
6627 + std::to_string(validRange().min()) + ", "
6628 + std::to_string(validRange().max()) + "]" };
6629 }
6630
6631 Zivid::DataModel::Detail::Optional<double> m_opt;
6632
6633 friend struct DataModel::Detail::Befriend<Threshold>;
6634 };
6635
6636 using Descendants = std::tuple<
6639
6642
6655#ifndef NO_DOC
6656 template<
6657 typename... Args,
6658 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
6659 typename std::enable_if<
6660 Zivid::Detail::TypeTraits::
6661 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
6662 int>::type = 0>
6663#else
6664 template<typename... Args>
6665#endif
6666 explicit Removal(Args &&...args)
6667 {
6668 using namespace Zivid::Detail::TypeTraits;
6669
6670 static_assert(
6671 AllArgsDecayedAreUnique<Args...>::value,
6672 "Found duplicate types among the arguments passed to Removal(...). "
6673 "Types should be listed at most once.");
6674
6675 set(std::forward<Args>(args)...);
6676 }
6677
6689#ifndef NO_DOC
6690 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
6691#else
6692 template<typename... Args>
6693#endif
6694 void set(Args &&...args)
6695 {
6696 using namespace Zivid::Detail::TypeTraits;
6697
6698 using AllArgsAreDescendantNodes =
6699 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
6700 static_assert(
6701 AllArgsAreDescendantNodes::value,
6702 "All arguments passed to set(...) must be descendant nodes.");
6703
6704 static_assert(
6705 AllArgsDecayedAreUnique<Args...>::value,
6706 "Found duplicate types among the arguments passed to set(...). "
6707 "Types should be listed at most once.");
6708
6709 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
6710 }
6711
6724#ifndef NO_DOC
6725 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
6726#else
6727 template<typename... Args>
6728#endif
6729 Removal copyWith(Args &&...args) const
6730 {
6731 using namespace Zivid::Detail::TypeTraits;
6732
6733 using AllArgsAreDescendantNodes =
6734 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
6735 static_assert(
6736 AllArgsAreDescendantNodes::value,
6737 "All arguments passed to copyWith(...) must be descendant nodes.");
6738
6739 static_assert(
6740 AllArgsDecayedAreUnique<Args...>::value,
6741 "Found duplicate types among the arguments passed to copyWith(...). "
6742 "Types should be listed at most once.");
6743
6744 auto copy{ *this };
6745 copy.set(std::forward<Args>(args)...);
6746 return copy;
6747 }
6748
6750 const Enabled &isEnabled() const
6751 {
6752 return m_enabled;
6753 }
6754
6757 {
6758 return m_enabled;
6759 }
6760
6762 Removal &set(const Enabled &value)
6763 {
6764 m_enabled = value;
6765 return *this;
6766 }
6767
6769 const Threshold &threshold() const
6770 {
6771 return m_threshold;
6772 }
6773
6776 {
6777 return m_threshold;
6778 }
6779
6781 Removal &set(const Threshold &value)
6782 {
6783 m_threshold = value;
6784 return *this;
6785 }
6786
6787 template<
6788 typename T,
6789 typename std::enable_if<
6790 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
6791 int>::type = 0>
6793 {
6794 return m_enabled;
6795 }
6796
6797 template<
6798 typename T,
6799 typename std::enable_if<
6800 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
6801 int>::type = 0>
6803 {
6804 return m_threshold;
6805 }
6806
6807 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
6809 {
6810 return m_enabled;
6811 }
6812
6813 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
6815 {
6816 return m_threshold;
6817 }
6818
6820 template<typename F>
6821 void forEach(const F &f) const
6822 {
6823 f(m_enabled);
6824 f(m_threshold);
6825 }
6826
6828 template<typename F>
6829 void forEach(const F &f)
6830 {
6831 f(m_enabled);
6832 f(m_threshold);
6833 }
6834
6836 bool operator==(const Removal &other) const;
6837
6839 bool operator!=(const Removal &other) const;
6840
6842 std::string toString() const;
6843
6845 friend std::ostream &operator<<(std::ostream &stream, const Removal &value)
6846 {
6847 return stream << value.toString();
6848 }
6849
6850 private:
6851 void setFromString(const std::string &value);
6852
6853 void setFromString(const std::string &fullPath, const std::string &value);
6854
6855 std::string getString(const std::string &fullPath) const;
6856
6857 Enabled m_enabled;
6858 Threshold m_threshold;
6859
6860 friend struct DataModel::Detail::Befriend<Removal>;
6861 };
6862
6863 using Descendants = std::tuple<
6867
6870
6884#ifndef NO_DOC
6885 template<
6886 typename... Args,
6887 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
6888 typename std::enable_if<
6889 Zivid::Detail::TypeTraits::
6890 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
6891 int>::type = 0>
6892#else
6893 template<typename... Args>
6894#endif
6895 explicit Noise(Args &&...args)
6896 {
6897 using namespace Zivid::Detail::TypeTraits;
6898
6899 static_assert(
6900 AllArgsDecayedAreUnique<Args...>::value,
6901 "Found duplicate types among the arguments passed to Noise(...). "
6902 "Types should be listed at most once.");
6903
6904 set(std::forward<Args>(args)...);
6905 }
6906
6919#ifndef NO_DOC
6920 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
6921#else
6922 template<typename... Args>
6923#endif
6924 void set(Args &&...args)
6925 {
6926 using namespace Zivid::Detail::TypeTraits;
6927
6928 using AllArgsAreDescendantNodes =
6929 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
6930 static_assert(
6931 AllArgsAreDescendantNodes::value,
6932 "All arguments passed to set(...) must be descendant nodes.");
6933
6934 static_assert(
6935 AllArgsDecayedAreUnique<Args...>::value,
6936 "Found duplicate types among the arguments passed to set(...). "
6937 "Types should be listed at most once.");
6938
6939 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
6940 }
6941
6955#ifndef NO_DOC
6956 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
6957#else
6958 template<typename... Args>
6959#endif
6960 Noise copyWith(Args &&...args) const
6961 {
6962 using namespace Zivid::Detail::TypeTraits;
6963
6964 using AllArgsAreDescendantNodes =
6965 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
6966 static_assert(
6967 AllArgsAreDescendantNodes::value,
6968 "All arguments passed to copyWith(...) must be descendant nodes.");
6969
6970 static_assert(
6971 AllArgsDecayedAreUnique<Args...>::value,
6972 "Found duplicate types among the arguments passed to copyWith(...). "
6973 "Types should be listed at most once.");
6974
6975 auto copy{ *this };
6976 copy.set(std::forward<Args>(args)...);
6977 return copy;
6978 }
6979
6981 const Removal &removal() const
6982 {
6983 return m_removal;
6984 }
6985
6988 {
6989 return m_removal;
6990 }
6991
6993 Noise &set(const Removal &value)
6994 {
6995 m_removal = value;
6996 return *this;
6997 }
6998
7001 {
7002 m_removal.set(value);
7003 return *this;
7004 }
7005
7008 {
7009 m_removal.set(value);
7010 return *this;
7011 }
7012
7013 template<
7014 typename T,
7015 typename std::enable_if<
7016 std::is_same<T, Settings::Processing::Filters::Noise::Removal>::value,
7017 int>::type = 0>
7019 {
7020 return m_removal;
7021 }
7022
7023 template<
7024 typename T,
7025 typename std::enable_if<
7026 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
7027 int>::type = 0>
7029 {
7031 }
7032
7033 template<
7034 typename T,
7035 typename std::enable_if<
7036 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
7037 int>::type = 0>
7039 {
7041 }
7042
7043 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
7045 {
7046 return m_removal;
7047 }
7048
7050 template<typename F>
7051 void forEach(const F &f) const
7052 {
7053 f(m_removal);
7054 }
7055
7057 template<typename F>
7058 void forEach(const F &f)
7059 {
7060 f(m_removal);
7061 }
7062
7064 bool operator==(const Noise &other) const;
7065
7067 bool operator!=(const Noise &other) const;
7068
7070 std::string toString() const;
7071
7073 friend std::ostream &operator<<(std::ostream &stream, const Noise &value)
7074 {
7075 return stream << value.toString();
7076 }
7077
7078 private:
7079 void setFromString(const std::string &value);
7080
7081 void setFromString(const std::string &fullPath, const std::string &value);
7082
7083 std::string getString(const std::string &fullPath) const;
7084
7085 Removal m_removal;
7086
7087 friend struct DataModel::Detail::Befriend<Noise>;
7088 };
7089
7091
7092 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
7094 {
7095 public:
7098
7100 static constexpr const char *path{ "Processing/Filters/Outlier" };
7101
7103 static constexpr const char *name{ "Outlier" };
7104
7106 static constexpr const char *description{
7107 R"description(Contains a filter that removes points with large Euclidean distance to neighboring points)description"
7108 };
7109
7111
7112 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
7114 {
7115 public:
7118
7120 static constexpr const char *path{ "Processing/Filters/Outlier/Removal" };
7121
7123 static constexpr const char *name{ "Removal" };
7124
7126 static constexpr const char *description{
7127 R"description(Discard point if Euclidean distance to neighboring points is above a threshold)description"
7128 };
7129
7131
7132 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
7134 {
7135 public:
7138
7140 static constexpr const char *path{ "Processing/Filters/Outlier/Removal/Enabled" };
7141
7143 static constexpr const char *name{ "Enabled" };
7144
7146 static constexpr const char *description{
7147 R"description(Enable or disable the outlier filter)description"
7148 };
7149
7151 using ValueType = bool;
7152 static const Enabled yes;
7153 static const Enabled no;
7154
7156 static std::set<bool> validValues()
7157 {
7158 return { false, true };
7159 }
7160
7162 Enabled() = default;
7163
7165 explicit constexpr Enabled(bool value)
7166 : m_opt{ value }
7167 {}
7168
7173 bool value() const;
7174
7176 bool hasValue() const;
7177
7179 void reset();
7180
7182 std::string toString() const;
7183
7185 bool operator==(const Enabled &other) const
7186 {
7187 return m_opt == other.m_opt;
7188 }
7189
7191 bool operator!=(const Enabled &other) const
7192 {
7193 return m_opt != other.m_opt;
7194 }
7195
7197 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
7198 {
7199 return stream << value.toString();
7200 }
7201
7202 private:
7203 void setFromString(const std::string &value);
7204
7205 Zivid::DataModel::Detail::Optional<bool> m_opt;
7206
7207 friend struct DataModel::Detail::Befriend<Enabled>;
7208 };
7209
7211
7212 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
7214 {
7215 public:
7218
7220 static constexpr const char *path{ "Processing/Filters/Outlier/Removal/Threshold" };
7221
7223 static constexpr const char *name{ "Threshold" };
7224
7226 static constexpr const char *description{
7227 R"description(Discard point if Euclidean distance to neighboring points is above the given value)description"
7228 };
7229
7231 using ValueType = double;
7232
7234 static constexpr Range<double> validRange()
7235 {
7236 return { 0.0, 100.0 };
7237 }
7238
7240 Threshold() = default;
7241
7243 explicit constexpr Threshold(double value)
7244 : m_opt{ verifyValue(value) }
7245 {}
7246
7251 double value() const;
7252
7254 bool hasValue() const;
7255
7257 void reset();
7258
7260 std::string toString() const;
7261
7263 bool operator==(const Threshold &other) const
7264 {
7265 return m_opt == other.m_opt;
7266 }
7267
7269 bool operator!=(const Threshold &other) const
7270 {
7271 return m_opt != other.m_opt;
7272 }
7273
7275 bool operator<(const Threshold &other) const
7276 {
7277 return m_opt < other.m_opt;
7278 }
7279
7281 bool operator>(const Threshold &other) const
7282 {
7283 return m_opt > other.m_opt;
7284 }
7285
7287 bool operator<=(const Threshold &other) const
7288 {
7289 return m_opt <= other.m_opt;
7290 }
7291
7293 bool operator>=(const Threshold &other) const
7294 {
7295 return m_opt >= other.m_opt;
7296 }
7297
7299 friend std::ostream &operator<<(std::ostream &stream, const Threshold &value)
7300 {
7301 return stream << value.toString();
7302 }
7303
7304 private:
7305 void setFromString(const std::string &value);
7306
7307 constexpr ValueType static verifyValue(const ValueType &value)
7308 {
7309 return validRange().isInRange(value)
7310 ? value
7311 : throw std::out_of_range{ "Threshold{ " + std::to_string(value)
7312 + " } is not in range ["
7313 + std::to_string(validRange().min()) + ", "
7314 + std::to_string(validRange().max()) + "]" };
7315 }
7316
7317 Zivid::DataModel::Detail::Optional<double> m_opt;
7318
7319 friend struct DataModel::Detail::Befriend<Threshold>;
7320 };
7321
7322 using Descendants = std::tuple<
7325
7328
7341#ifndef NO_DOC
7342 template<
7343 typename... Args,
7344 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
7345 typename std::enable_if<
7346 Zivid::Detail::TypeTraits::
7347 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
7348 int>::type = 0>
7349#else
7350 template<typename... Args>
7351#endif
7352 explicit Removal(Args &&...args)
7353 {
7354 using namespace Zivid::Detail::TypeTraits;
7355
7356 static_assert(
7357 AllArgsDecayedAreUnique<Args...>::value,
7358 "Found duplicate types among the arguments passed to Removal(...). "
7359 "Types should be listed at most once.");
7360
7361 set(std::forward<Args>(args)...);
7362 }
7363
7375#ifndef NO_DOC
7376 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
7377#else
7378 template<typename... Args>
7379#endif
7380 void set(Args &&...args)
7381 {
7382 using namespace Zivid::Detail::TypeTraits;
7383
7384 using AllArgsAreDescendantNodes =
7385 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
7386 static_assert(
7387 AllArgsAreDescendantNodes::value,
7388 "All arguments passed to set(...) must be descendant nodes.");
7389
7390 static_assert(
7391 AllArgsDecayedAreUnique<Args...>::value,
7392 "Found duplicate types among the arguments passed to set(...). "
7393 "Types should be listed at most once.");
7394
7395 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
7396 }
7397
7410#ifndef NO_DOC
7411 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
7412#else
7413 template<typename... Args>
7414#endif
7415 Removal copyWith(Args &&...args) const
7416 {
7417 using namespace Zivid::Detail::TypeTraits;
7418
7419 using AllArgsAreDescendantNodes =
7420 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
7421 static_assert(
7422 AllArgsAreDescendantNodes::value,
7423 "All arguments passed to copyWith(...) must be descendant nodes.");
7424
7425 static_assert(
7426 AllArgsDecayedAreUnique<Args...>::value,
7427 "Found duplicate types among the arguments passed to copyWith(...). "
7428 "Types should be listed at most once.");
7429
7430 auto copy{ *this };
7431 copy.set(std::forward<Args>(args)...);
7432 return copy;
7433 }
7434
7436 const Enabled &isEnabled() const
7437 {
7438 return m_enabled;
7439 }
7440
7443 {
7444 return m_enabled;
7445 }
7446
7448 Removal &set(const Enabled &value)
7449 {
7450 m_enabled = value;
7451 return *this;
7452 }
7453
7455 const Threshold &threshold() const
7456 {
7457 return m_threshold;
7458 }
7459
7462 {
7463 return m_threshold;
7464 }
7465
7467 Removal &set(const Threshold &value)
7468 {
7469 m_threshold = value;
7470 return *this;
7471 }
7472
7473 template<
7474 typename T,
7475 typename std::enable_if<
7476 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
7477 int>::type = 0>
7479 {
7480 return m_enabled;
7481 }
7482
7483 template<
7484 typename T,
7485 typename std::enable_if<
7486 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
7487 int>::type = 0>
7489 {
7490 return m_threshold;
7491 }
7492
7493 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
7495 {
7496 return m_enabled;
7497 }
7498
7499 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
7501 {
7502 return m_threshold;
7503 }
7504
7506 template<typename F>
7507 void forEach(const F &f) const
7508 {
7509 f(m_enabled);
7510 f(m_threshold);
7511 }
7512
7514 template<typename F>
7515 void forEach(const F &f)
7516 {
7517 f(m_enabled);
7518 f(m_threshold);
7519 }
7520
7522 bool operator==(const Removal &other) const;
7523
7525 bool operator!=(const Removal &other) const;
7526
7528 std::string toString() const;
7529
7531 friend std::ostream &operator<<(std::ostream &stream, const Removal &value)
7532 {
7533 return stream << value.toString();
7534 }
7535
7536 private:
7537 void setFromString(const std::string &value);
7538
7539 void setFromString(const std::string &fullPath, const std::string &value);
7540
7541 std::string getString(const std::string &fullPath) const;
7542
7543 Enabled m_enabled;
7544 Threshold m_threshold;
7545
7546 friend struct DataModel::Detail::Befriend<Removal>;
7547 };
7548
7549 using Descendants = std::tuple<
7553
7556
7570#ifndef NO_DOC
7571 template<
7572 typename... Args,
7573 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
7574 typename std::enable_if<
7575 Zivid::Detail::TypeTraits::
7576 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
7577 int>::type = 0>
7578#else
7579 template<typename... Args>
7580#endif
7581 explicit Outlier(Args &&...args)
7582 {
7583 using namespace Zivid::Detail::TypeTraits;
7584
7585 static_assert(
7586 AllArgsDecayedAreUnique<Args...>::value,
7587 "Found duplicate types among the arguments passed to Outlier(...). "
7588 "Types should be listed at most once.");
7589
7590 set(std::forward<Args>(args)...);
7591 }
7592
7605#ifndef NO_DOC
7606 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
7607#else
7608 template<typename... Args>
7609#endif
7610 void set(Args &&...args)
7611 {
7612 using namespace Zivid::Detail::TypeTraits;
7613
7614 using AllArgsAreDescendantNodes =
7615 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
7616 static_assert(
7617 AllArgsAreDescendantNodes::value,
7618 "All arguments passed to set(...) must be descendant nodes.");
7619
7620 static_assert(
7621 AllArgsDecayedAreUnique<Args...>::value,
7622 "Found duplicate types among the arguments passed to set(...). "
7623 "Types should be listed at most once.");
7624
7625 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
7626 }
7627
7641#ifndef NO_DOC
7642 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
7643#else
7644 template<typename... Args>
7645#endif
7646 Outlier copyWith(Args &&...args) const
7647 {
7648 using namespace Zivid::Detail::TypeTraits;
7649
7650 using AllArgsAreDescendantNodes =
7651 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
7652 static_assert(
7653 AllArgsAreDescendantNodes::value,
7654 "All arguments passed to copyWith(...) must be descendant nodes.");
7655
7656 static_assert(
7657 AllArgsDecayedAreUnique<Args...>::value,
7658 "Found duplicate types among the arguments passed to copyWith(...). "
7659 "Types should be listed at most once.");
7660
7661 auto copy{ *this };
7662 copy.set(std::forward<Args>(args)...);
7663 return copy;
7664 }
7665
7667 const Removal &removal() const
7668 {
7669 return m_removal;
7670 }
7671
7674 {
7675 return m_removal;
7676 }
7677
7679 Outlier &set(const Removal &value)
7680 {
7681 m_removal = value;
7682 return *this;
7683 }
7684
7687 {
7688 m_removal.set(value);
7689 return *this;
7690 }
7691
7694 {
7695 m_removal.set(value);
7696 return *this;
7697 }
7698
7699 template<
7700 typename T,
7701 typename std::enable_if<
7702 std::is_same<T, Settings::Processing::Filters::Outlier::Removal>::value,
7703 int>::type = 0>
7705 {
7706 return m_removal;
7707 }
7708
7709 template<
7710 typename T,
7711 typename std::enable_if<
7712 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
7713 int>::type = 0>
7715 {
7717 }
7718
7719 template<
7720 typename T,
7721 typename std::enable_if<
7722 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
7723 int>::type = 0>
7725 {
7727 }
7728
7729 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
7731 {
7732 return m_removal;
7733 }
7734
7736 template<typename F>
7737 void forEach(const F &f) const
7738 {
7739 f(m_removal);
7740 }
7741
7743 template<typename F>
7744 void forEach(const F &f)
7745 {
7746 f(m_removal);
7747 }
7748
7750 bool operator==(const Outlier &other) const;
7751
7753 bool operator!=(const Outlier &other) const;
7754
7756 std::string toString() const;
7757
7759 friend std::ostream &operator<<(std::ostream &stream, const Outlier &value)
7760 {
7761 return stream << value.toString();
7762 }
7763
7764 private:
7765 void setFromString(const std::string &value);
7766
7767 void setFromString(const std::string &fullPath, const std::string &value);
7768
7769 std::string getString(const std::string &fullPath) const;
7770
7771 Removal m_removal;
7772
7773 friend struct DataModel::Detail::Befriend<Outlier>;
7774 };
7775
7777
7778 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
7780 {
7781 public:
7784
7786 static constexpr const char *path{ "Processing/Filters/Reflection" };
7787
7789 static constexpr const char *name{ "Reflection" };
7790
7792 static constexpr const char *description{
7793 R"description(Contains a filter that removes points likely introduced by reflections (useful for shiny materials))description"
7794 };
7795
7797
7798 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
7800 {
7801 public:
7804
7806 static constexpr const char *path{ "Processing/Filters/Reflection/Removal" };
7807
7809 static constexpr const char *name{ "Removal" };
7810
7812 static constexpr const char *description{
7813 R"description(Discard points likely introduced by reflections (useful for shiny materials))description"
7814 };
7815
7817
7818 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
7820 {
7821 public:
7824
7826 static constexpr const char *path{ "Processing/Filters/Reflection/Removal/Enabled" };
7827
7829 static constexpr const char *name{ "Enabled" };
7830
7832 static constexpr const char *description{
7833 R"description(Enable or disable the reflection filter. Note that this filter is computationally intensive and may affect the frame rate)description"
7834 };
7835
7837 using ValueType = bool;
7838 static const Enabled yes;
7839 static const Enabled no;
7840
7842 static std::set<bool> validValues()
7843 {
7844 return { false, true };
7845 }
7846
7848 Enabled() = default;
7849
7851 explicit constexpr Enabled(bool value)
7852 : m_opt{ value }
7853 {}
7854
7859 bool value() const;
7860
7862 bool hasValue() const;
7863
7865 void reset();
7866
7868 std::string toString() const;
7869
7871 bool operator==(const Enabled &other) const
7872 {
7873 return m_opt == other.m_opt;
7874 }
7875
7877 bool operator!=(const Enabled &other) const
7878 {
7879 return m_opt != other.m_opt;
7880 }
7881
7883 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
7884 {
7885 return stream << value.toString();
7886 }
7887
7888 private:
7889 void setFromString(const std::string &value);
7890
7891 Zivid::DataModel::Detail::Optional<bool> m_opt;
7892
7893 friend struct DataModel::Detail::Befriend<Enabled>;
7894 };
7895
7897
7898 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
7900 {
7901 public:
7904
7906 static constexpr const char *path{ "Processing/Filters/Reflection/Removal/Experimental" };
7907
7909 static constexpr const char *name{ "Experimental" };
7910
7912 static constexpr const char *description{
7913 R"description(Experimental reflection filter related settings)description"
7914 };
7915
7924
7925 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
7927 {
7928 public:
7931
7933 static constexpr const char *path{
7934 "Processing/Filters/Reflection/Removal/Experimental/Mode"
7935 };
7936
7938 static constexpr const char *name{ "Mode" };
7939
7941 static constexpr const char *description{
7942 R"description(The reflection filter has two modes: Local and Global. Local mode preserves more 3D data
7943on thinner objects, generally removes more reflection artifacts and processes faster than
7944the Global filter. The Global filter is generally better at removing outlier points in
7945the point cloud. It is advised to use the Outlier filter together with the Local
7946Reflection filter.
7947
7948Global mode was introduced in SDK 1.0 and Local mode was introduced in SDK 2.7.
7949)description"
7950 };
7951
7953 enum class ValueType
7954 {
7955 global,
7956 local
7957 };
7958 static const Mode global;
7959 static const Mode local;
7960
7962 static std::set<ValueType> validValues()
7963 {
7964 return { ValueType::global, ValueType::local };
7965 }
7966
7968 Mode() = default;
7969
7971 explicit constexpr Mode(ValueType value)
7972 : m_opt{ verifyValue(value) }
7973 {}
7974
7980
7982 bool hasValue() const;
7983
7985 void reset();
7986
7988 std::string toString() const;
7989
7991 friend std::ostream &operator<<(std::ostream &stream, const Mode::ValueType &value)
7992 {
7993 return stream << Mode{ value }.toString();
7994 }
7995
7997 bool operator==(const Mode &other) const
7998 {
7999 return m_opt == other.m_opt;
8000 }
8001
8003 bool operator!=(const Mode &other) const
8004 {
8005 return m_opt != other.m_opt;
8006 }
8007
8009 friend std::ostream &operator<<(std::ostream &stream, const Mode &value)
8010 {
8011 return stream << value.toString();
8012 }
8013
8014 private:
8015 void setFromString(const std::string &value);
8016
8017 constexpr ValueType static verifyValue(const ValueType &value)
8018 {
8019 return value == ValueType::global || value == ValueType::local
8020 ? value
8021 : throw std::invalid_argument{
8022 "Invalid value: Mode{ "
8023 + std::to_string(
8024 static_cast<std::underlying_type<ValueType>::type>(value))
8025 + " }"
8026 };
8027 }
8028
8029 Zivid::DataModel::Detail::Optional<ValueType> m_opt;
8030
8031 friend struct DataModel::Detail::Befriend<Mode>;
8032 };
8033
8035 std::tuple<Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>;
8036
8039
8051#ifndef NO_DOC
8052 template<
8053 typename... Args,
8054 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
8055 typename std::enable_if<
8056 Zivid::Detail::TypeTraits::
8057 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
8058 int>::type = 0>
8059#else
8060 template<typename... Args>
8061#endif
8062 explicit Experimental(Args &&...args)
8063 {
8064 using namespace Zivid::Detail::TypeTraits;
8065
8066 static_assert(
8067 AllArgsDecayedAreUnique<Args...>::value,
8068 "Found duplicate types among the arguments passed to Experimental(...). "
8069 "Types should be listed at most once.");
8070
8071 set(std::forward<Args>(args)...);
8072 }
8073
8084#ifndef NO_DOC
8085 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
8086#else
8087 template<typename... Args>
8088#endif
8089 void set(Args &&...args)
8090 {
8091 using namespace Zivid::Detail::TypeTraits;
8092
8093 using AllArgsAreDescendantNodes =
8094 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
8095 static_assert(
8096 AllArgsAreDescendantNodes::value,
8097 "All arguments passed to set(...) must be descendant nodes.");
8098
8099 static_assert(
8100 AllArgsDecayedAreUnique<Args...>::value,
8101 "Found duplicate types among the arguments passed to set(...). "
8102 "Types should be listed at most once.");
8103
8104 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
8105 }
8106
8118#ifndef NO_DOC
8119 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
8120#else
8121 template<typename... Args>
8122#endif
8123 Experimental copyWith(Args &&...args) const
8124 {
8125 using namespace Zivid::Detail::TypeTraits;
8126
8127 using AllArgsAreDescendantNodes =
8128 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
8129 static_assert(
8130 AllArgsAreDescendantNodes::value,
8131 "All arguments passed to copyWith(...) must be descendant nodes.");
8132
8133 static_assert(
8134 AllArgsDecayedAreUnique<Args...>::value,
8135 "Found duplicate types among the arguments passed to copyWith(...). "
8136 "Types should be listed at most once.");
8137
8138 auto copy{ *this };
8139 copy.set(std::forward<Args>(args)...);
8140 return copy;
8141 }
8142
8144 const Mode &mode() const
8145 {
8146 return m_mode;
8147 }
8148
8151 {
8152 return m_mode;
8153 }
8154
8156 Experimental &set(const Mode &value)
8157 {
8158 m_mode = value;
8159 return *this;
8160 }
8161
8162 template<
8163 typename T,
8164 typename std::enable_if<
8165 std::is_same<
8166 T,
8168 int>::type = 0>
8170 {
8171 return m_mode;
8172 }
8173
8174 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
8176 {
8177 return m_mode;
8178 }
8179
8181 template<typename F>
8182 void forEach(const F &f) const
8183 {
8184 f(m_mode);
8185 }
8186
8188 template<typename F>
8189 void forEach(const F &f)
8190 {
8191 f(m_mode);
8192 }
8193
8195 bool operator==(const Experimental &other) const;
8196
8198 bool operator!=(const Experimental &other) const;
8199
8201 std::string toString() const;
8202
8204 friend std::ostream &operator<<(std::ostream &stream, const Experimental &value)
8205 {
8206 return stream << value.toString();
8207 }
8208
8209 private:
8210 void setFromString(const std::string &value);
8211
8212 void setFromString(const std::string &fullPath, const std::string &value);
8213
8214 std::string getString(const std::string &fullPath) const;
8215
8216 Mode m_mode;
8217
8218 friend struct DataModel::Detail::Befriend<Experimental>;
8219 };
8220
8221 using Descendants = std::tuple<
8225
8228
8242#ifndef NO_DOC
8243 template<
8244 typename... Args,
8245 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
8246 typename std::enable_if<
8247 Zivid::Detail::TypeTraits::
8248 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
8249 int>::type = 0>
8250#else
8251 template<typename... Args>
8252#endif
8253 explicit Removal(Args &&...args)
8254 {
8255 using namespace Zivid::Detail::TypeTraits;
8256
8257 static_assert(
8258 AllArgsDecayedAreUnique<Args...>::value,
8259 "Found duplicate types among the arguments passed to Removal(...). "
8260 "Types should be listed at most once.");
8261
8262 set(std::forward<Args>(args)...);
8263 }
8264
8277#ifndef NO_DOC
8278 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
8279#else
8280 template<typename... Args>
8281#endif
8282 void set(Args &&...args)
8283 {
8284 using namespace Zivid::Detail::TypeTraits;
8285
8286 using AllArgsAreDescendantNodes =
8287 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
8288 static_assert(
8289 AllArgsAreDescendantNodes::value,
8290 "All arguments passed to set(...) must be descendant nodes.");
8291
8292 static_assert(
8293 AllArgsDecayedAreUnique<Args...>::value,
8294 "Found duplicate types among the arguments passed to set(...). "
8295 "Types should be listed at most once.");
8296
8297 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
8298 }
8299
8313#ifndef NO_DOC
8314 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
8315#else
8316 template<typename... Args>
8317#endif
8318 Removal copyWith(Args &&...args) const
8319 {
8320 using namespace Zivid::Detail::TypeTraits;
8321
8322 using AllArgsAreDescendantNodes =
8323 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
8324 static_assert(
8325 AllArgsAreDescendantNodes::value,
8326 "All arguments passed to copyWith(...) must be descendant nodes.");
8327
8328 static_assert(
8329 AllArgsDecayedAreUnique<Args...>::value,
8330 "Found duplicate types among the arguments passed to copyWith(...). "
8331 "Types should be listed at most once.");
8332
8333 auto copy{ *this };
8334 copy.set(std::forward<Args>(args)...);
8335 return copy;
8336 }
8337
8339 const Enabled &isEnabled() const
8340 {
8341 return m_enabled;
8342 }
8343
8346 {
8347 return m_enabled;
8348 }
8349
8351 Removal &set(const Enabled &value)
8352 {
8353 m_enabled = value;
8354 return *this;
8355 }
8356
8359 {
8360 return m_experimental;
8361 }
8362
8365 {
8366 return m_experimental;
8367 }
8368
8370 Removal &set(const Experimental &value)
8371 {
8372 m_experimental = value;
8373 return *this;
8374 }
8375
8378 {
8379 m_experimental.set(value);
8380 return *this;
8381 }
8382
8383 template<
8384 typename T,
8385 typename std::enable_if<
8386 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
8387 int>::type = 0>
8389 {
8390 return m_enabled;
8391 }
8392
8393 template<
8394 typename T,
8395 typename std::enable_if<
8396 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental>::
8397 value,
8398 int>::type = 0>
8400 {
8401 return m_experimental;
8402 }
8403
8404 template<
8405 typename T,
8406 typename std::enable_if<
8407 std::is_same<
8408 T,
8410 int>::type = 0>
8412 {
8413 return m_experimental
8415 }
8416
8417 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
8419 {
8420 return m_enabled;
8421 }
8422
8423 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
8425 {
8426 return m_experimental;
8427 }
8428
8430 template<typename F>
8431 void forEach(const F &f) const
8432 {
8433 f(m_enabled);
8434 f(m_experimental);
8435 }
8436
8438 template<typename F>
8439 void forEach(const F &f)
8440 {
8441 f(m_enabled);
8442 f(m_experimental);
8443 }
8444
8446 bool operator==(const Removal &other) const;
8447
8449 bool operator!=(const Removal &other) const;
8450
8452 std::string toString() const;
8453
8455 friend std::ostream &operator<<(std::ostream &stream, const Removal &value)
8456 {
8457 return stream << value.toString();
8458 }
8459
8460 private:
8461 void setFromString(const std::string &value);
8462
8463 void setFromString(const std::string &fullPath, const std::string &value);
8464
8465 std::string getString(const std::string &fullPath) const;
8466
8467 Enabled m_enabled;
8468 Experimental m_experimental;
8469
8470 friend struct DataModel::Detail::Befriend<Removal>;
8471 };
8472
8473 using Descendants = std::tuple<
8478
8481
8496#ifndef NO_DOC
8497 template<
8498 typename... Args,
8499 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
8500 typename std::enable_if<
8501 Zivid::Detail::TypeTraits::
8502 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
8503 int>::type = 0>
8504#else
8505 template<typename... Args>
8506#endif
8507 explicit Reflection(Args &&...args)
8508 {
8509 using namespace Zivid::Detail::TypeTraits;
8510
8511 static_assert(
8512 AllArgsDecayedAreUnique<Args...>::value,
8513 "Found duplicate types among the arguments passed to Reflection(...). "
8514 "Types should be listed at most once.");
8515
8516 set(std::forward<Args>(args)...);
8517 }
8518
8532#ifndef NO_DOC
8533 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
8534#else
8535 template<typename... Args>
8536#endif
8537 void set(Args &&...args)
8538 {
8539 using namespace Zivid::Detail::TypeTraits;
8540
8541 using AllArgsAreDescendantNodes =
8542 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
8543 static_assert(
8544 AllArgsAreDescendantNodes::value,
8545 "All arguments passed to set(...) must be descendant nodes.");
8546
8547 static_assert(
8548 AllArgsDecayedAreUnique<Args...>::value,
8549 "Found duplicate types among the arguments passed to set(...). "
8550 "Types should be listed at most once.");
8551
8552 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
8553 }
8554
8569#ifndef NO_DOC
8570 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
8571#else
8572 template<typename... Args>
8573#endif
8574 Reflection copyWith(Args &&...args) const
8575 {
8576 using namespace Zivid::Detail::TypeTraits;
8577
8578 using AllArgsAreDescendantNodes =
8579 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
8580 static_assert(
8581 AllArgsAreDescendantNodes::value,
8582 "All arguments passed to copyWith(...) must be descendant nodes.");
8583
8584 static_assert(
8585 AllArgsDecayedAreUnique<Args...>::value,
8586 "Found duplicate types among the arguments passed to copyWith(...). "
8587 "Types should be listed at most once.");
8588
8589 auto copy{ *this };
8590 copy.set(std::forward<Args>(args)...);
8591 return copy;
8592 }
8593
8595 const Removal &removal() const
8596 {
8597 return m_removal;
8598 }
8599
8602 {
8603 return m_removal;
8604 }
8605
8607 Reflection &set(const Removal &value)
8608 {
8609 m_removal = value;
8610 return *this;
8611 }
8612
8615 {
8616 m_removal.set(value);
8617 return *this;
8618 }
8619
8622 {
8623 m_removal.set(value);
8624 return *this;
8625 }
8626
8629 {
8630 m_removal.set(value);
8631 return *this;
8632 }
8633
8634 template<
8635 typename T,
8636 typename std::enable_if<
8637 std::is_same<T, Settings::Processing::Filters::Reflection::Removal>::value,
8638 int>::type = 0>
8640 {
8641 return m_removal;
8642 }
8643
8644 template<
8645 typename T,
8646 typename std::enable_if<
8647 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
8648 int>::type = 0>
8650 {
8652 }
8653
8654 template<
8655 typename T,
8656 typename std::enable_if<
8657 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental>::value,
8658 int>::type = 0>
8660 {
8662 }
8663
8664 template<
8665 typename T,
8666 typename std::enable_if<
8667 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>::
8668 value,
8669 int>::type = 0>
8671 {
8673 }
8674
8675 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
8677 {
8678 return m_removal;
8679 }
8680
8682 template<typename F>
8683 void forEach(const F &f) const
8684 {
8685 f(m_removal);
8686 }
8687
8689 template<typename F>
8690 void forEach(const F &f)
8691 {
8692 f(m_removal);
8693 }
8694
8696 bool operator==(const Reflection &other) const;
8697
8699 bool operator!=(const Reflection &other) const;
8700
8702 std::string toString() const;
8703
8705 friend std::ostream &operator<<(std::ostream &stream, const Reflection &value)
8706 {
8707 return stream << value.toString();
8708 }
8709
8710 private:
8711 void setFromString(const std::string &value);
8712
8713 void setFromString(const std::string &fullPath, const std::string &value);
8714
8715 std::string getString(const std::string &fullPath) const;
8716
8717 Removal m_removal;
8718
8719 friend struct DataModel::Detail::Befriend<Reflection>;
8720 };
8721
8723
8724 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
8726 {
8727 public:
8730
8732 static constexpr const char *path{ "Processing/Filters/Smoothing" };
8733
8735 static constexpr const char *name{ "Smoothing" };
8736
8738 static constexpr const char *description{ R"description(Smoothing filters)description" };
8739
8741
8742 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
8744 {
8745 public:
8748
8750 static constexpr const char *path{ "Processing/Filters/Smoothing/Gaussian" };
8751
8753 static constexpr const char *name{ "Gaussian" };
8754
8756 static constexpr const char *description{
8757 R"description(Gaussian smoothing of the point cloud)description"
8758 };
8759
8761
8762 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
8764 {
8765 public:
8768
8770 static constexpr const char *path{ "Processing/Filters/Smoothing/Gaussian/Enabled" };
8771
8773 static constexpr const char *name{ "Enabled" };
8774
8776 static constexpr const char *description{
8777 R"description(Enable or disable the smoothing filter)description"
8778 };
8779
8781 using ValueType = bool;
8782 static const Enabled yes;
8783 static const Enabled no;
8784
8786 static std::set<bool> validValues()
8787 {
8788 return { false, true };
8789 }
8790
8792 Enabled() = default;
8793
8795 explicit constexpr Enabled(bool value)
8796 : m_opt{ value }
8797 {}
8798
8803 bool value() const;
8804
8806 bool hasValue() const;
8807
8809 void reset();
8810
8812 std::string toString() const;
8813
8815 bool operator==(const Enabled &other) const
8816 {
8817 return m_opt == other.m_opt;
8818 }
8819
8821 bool operator!=(const Enabled &other) const
8822 {
8823 return m_opt != other.m_opt;
8824 }
8825
8827 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
8828 {
8829 return stream << value.toString();
8830 }
8831
8832 private:
8833 void setFromString(const std::string &value);
8834
8835 Zivid::DataModel::Detail::Optional<bool> m_opt;
8836
8837 friend struct DataModel::Detail::Befriend<Enabled>;
8838 };
8839
8841
8842 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
8844 {
8845 public:
8848
8850 static constexpr const char *path{ "Processing/Filters/Smoothing/Gaussian/Sigma" };
8851
8853 static constexpr const char *name{ "Sigma" };
8854
8856 static constexpr const char *description{
8857 R"description(Higher values result in smoother point clouds (Standard deviation of the filter coefficients))description"
8858 };
8859
8861 using ValueType = double;
8862
8864 static constexpr Range<double> validRange()
8865 {
8866 return { 0.5, 5 };
8867 }
8868
8870 Sigma() = default;
8871
8873 explicit constexpr Sigma(double value)
8874 : m_opt{ verifyValue(value) }
8875 {}
8876
8881 double value() const;
8882
8884 bool hasValue() const;
8885
8887 void reset();
8888
8890 std::string toString() const;
8891
8893 bool operator==(const Sigma &other) const
8894 {
8895 return m_opt == other.m_opt;
8896 }
8897
8899 bool operator!=(const Sigma &other) const
8900 {
8901 return m_opt != other.m_opt;
8902 }
8903
8905 bool operator<(const Sigma &other) const
8906 {
8907 return m_opt < other.m_opt;
8908 }
8909
8911 bool operator>(const Sigma &other) const
8912 {
8913 return m_opt > other.m_opt;
8914 }
8915
8917 bool operator<=(const Sigma &other) const
8918 {
8919 return m_opt <= other.m_opt;
8920 }
8921
8923 bool operator>=(const Sigma &other) const
8924 {
8925 return m_opt >= other.m_opt;
8926 }
8927
8929 friend std::ostream &operator<<(std::ostream &stream, const Sigma &value)
8930 {
8931 return stream << value.toString();
8932 }
8933
8934 private:
8935 void setFromString(const std::string &value);
8936
8937 constexpr ValueType static verifyValue(const ValueType &value)
8938 {
8939 return validRange().isInRange(value)
8940 ? value
8941 : throw std::out_of_range{ "Sigma{ " + std::to_string(value)
8942 + " } is not in range ["
8943 + std::to_string(validRange().min()) + ", "
8944 + std::to_string(validRange().max()) + "]" };
8945 }
8946
8947 Zivid::DataModel::Detail::Optional<double> m_opt;
8948
8949 friend struct DataModel::Detail::Befriend<Sigma>;
8950 };
8951
8952 using Descendants = std::tuple<
8955
8958
8971#ifndef NO_DOC
8972 template<
8973 typename... Args,
8974 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
8975 typename std::enable_if<
8976 Zivid::Detail::TypeTraits::
8977 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
8978 int>::type = 0>
8979#else
8980 template<typename... Args>
8981#endif
8982 explicit Gaussian(Args &&...args)
8983 {
8984 using namespace Zivid::Detail::TypeTraits;
8985
8986 static_assert(
8987 AllArgsDecayedAreUnique<Args...>::value,
8988 "Found duplicate types among the arguments passed to Gaussian(...). "
8989 "Types should be listed at most once.");
8990
8991 set(std::forward<Args>(args)...);
8992 }
8993
9005#ifndef NO_DOC
9006 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
9007#else
9008 template<typename... Args>
9009#endif
9010 void set(Args &&...args)
9011 {
9012 using namespace Zivid::Detail::TypeTraits;
9013
9014 using AllArgsAreDescendantNodes =
9015 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
9016 static_assert(
9017 AllArgsAreDescendantNodes::value,
9018 "All arguments passed to set(...) must be descendant nodes.");
9019
9020 static_assert(
9021 AllArgsDecayedAreUnique<Args...>::value,
9022 "Found duplicate types among the arguments passed to set(...). "
9023 "Types should be listed at most once.");
9024
9025 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
9026 }
9027
9040#ifndef NO_DOC
9041 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
9042#else
9043 template<typename... Args>
9044#endif
9045 Gaussian copyWith(Args &&...args) const
9046 {
9047 using namespace Zivid::Detail::TypeTraits;
9048
9049 using AllArgsAreDescendantNodes =
9050 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
9051 static_assert(
9052 AllArgsAreDescendantNodes::value,
9053 "All arguments passed to copyWith(...) must be descendant nodes.");
9054
9055 static_assert(
9056 AllArgsDecayedAreUnique<Args...>::value,
9057 "Found duplicate types among the arguments passed to copyWith(...). "
9058 "Types should be listed at most once.");
9059
9060 auto copy{ *this };
9061 copy.set(std::forward<Args>(args)...);
9062 return copy;
9063 }
9064
9066 const Enabled &isEnabled() const
9067 {
9068 return m_enabled;
9069 }
9070
9073 {
9074 return m_enabled;
9075 }
9076
9078 Gaussian &set(const Enabled &value)
9079 {
9080 m_enabled = value;
9081 return *this;
9082 }
9083
9085 const Sigma &sigma() const
9086 {
9087 return m_sigma;
9088 }
9089
9092 {
9093 return m_sigma;
9094 }
9095
9097 Gaussian &set(const Sigma &value)
9098 {
9099 m_sigma = value;
9100 return *this;
9101 }
9102
9103 template<
9104 typename T,
9105 typename std::enable_if<
9106 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
9107 int>::type = 0>
9109 {
9110 return m_enabled;
9111 }
9112
9113 template<
9114 typename T,
9115 typename std::enable_if<
9116 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
9117 int>::type = 0>
9119 {
9120 return m_sigma;
9121 }
9122
9123 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
9125 {
9126 return m_enabled;
9127 }
9128
9129 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
9131 {
9132 return m_sigma;
9133 }
9134
9136 template<typename F>
9137 void forEach(const F &f) const
9138 {
9139 f(m_enabled);
9140 f(m_sigma);
9141 }
9142
9144 template<typename F>
9145 void forEach(const F &f)
9146 {
9147 f(m_enabled);
9148 f(m_sigma);
9149 }
9150
9152 bool operator==(const Gaussian &other) const;
9153
9155 bool operator!=(const Gaussian &other) const;
9156
9158 std::string toString() const;
9159
9161 friend std::ostream &operator<<(std::ostream &stream, const Gaussian &value)
9162 {
9163 return stream << value.toString();
9164 }
9165
9166 private:
9167 void setFromString(const std::string &value);
9168
9169 void setFromString(const std::string &fullPath, const std::string &value);
9170
9171 std::string getString(const std::string &fullPath) const;
9172
9173 Enabled m_enabled;
9174 Sigma m_sigma;
9175
9176 friend struct DataModel::Detail::Befriend<Gaussian>;
9177 };
9178
9179 using Descendants = std::tuple<
9183
9186
9200#ifndef NO_DOC
9201 template<
9202 typename... Args,
9203 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
9204 typename std::enable_if<
9205 Zivid::Detail::TypeTraits::
9206 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
9207 int>::type = 0>
9208#else
9209 template<typename... Args>
9210#endif
9211 explicit Smoothing(Args &&...args)
9212 {
9213 using namespace Zivid::Detail::TypeTraits;
9214
9215 static_assert(
9216 AllArgsDecayedAreUnique<Args...>::value,
9217 "Found duplicate types among the arguments passed to Smoothing(...). "
9218 "Types should be listed at most once.");
9219
9220 set(std::forward<Args>(args)...);
9221 }
9222
9235#ifndef NO_DOC
9236 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
9237#else
9238 template<typename... Args>
9239#endif
9240 void set(Args &&...args)
9241 {
9242 using namespace Zivid::Detail::TypeTraits;
9243
9244 using AllArgsAreDescendantNodes =
9245 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
9246 static_assert(
9247 AllArgsAreDescendantNodes::value,
9248 "All arguments passed to set(...) must be descendant nodes.");
9249
9250 static_assert(
9251 AllArgsDecayedAreUnique<Args...>::value,
9252 "Found duplicate types among the arguments passed to set(...). "
9253 "Types should be listed at most once.");
9254
9255 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
9256 }
9257
9271#ifndef NO_DOC
9272 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
9273#else
9274 template<typename... Args>
9275#endif
9276 Smoothing copyWith(Args &&...args) const
9277 {
9278 using namespace Zivid::Detail::TypeTraits;
9279
9280 using AllArgsAreDescendantNodes =
9281 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
9282 static_assert(
9283 AllArgsAreDescendantNodes::value,
9284 "All arguments passed to copyWith(...) must be descendant nodes.");
9285
9286 static_assert(
9287 AllArgsDecayedAreUnique<Args...>::value,
9288 "Found duplicate types among the arguments passed to copyWith(...). "
9289 "Types should be listed at most once.");
9290
9291 auto copy{ *this };
9292 copy.set(std::forward<Args>(args)...);
9293 return copy;
9294 }
9295
9297 const Gaussian &gaussian() const
9298 {
9299 return m_gaussian;
9300 }
9301
9304 {
9305 return m_gaussian;
9306 }
9307
9309 Smoothing &set(const Gaussian &value)
9310 {
9311 m_gaussian = value;
9312 return *this;
9313 }
9314
9317 {
9318 m_gaussian.set(value);
9319 return *this;
9320 }
9321
9324 {
9325 m_gaussian.set(value);
9326 return *this;
9327 }
9328
9329 template<
9330 typename T,
9331 typename std::enable_if<
9332 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian>::value,
9333 int>::type = 0>
9335 {
9336 return m_gaussian;
9337 }
9338
9339 template<
9340 typename T,
9341 typename std::enable_if<
9342 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
9343 int>::type = 0>
9345 {
9347 }
9348
9349 template<
9350 typename T,
9351 typename std::enable_if<
9352 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
9353 int>::type = 0>
9355 {
9357 }
9358
9359 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
9361 {
9362 return m_gaussian;
9363 }
9364
9366 template<typename F>
9367 void forEach(const F &f) const
9368 {
9369 f(m_gaussian);
9370 }
9371
9373 template<typename F>
9374 void forEach(const F &f)
9375 {
9376 f(m_gaussian);
9377 }
9378
9380 bool operator==(const Smoothing &other) const;
9381
9383 bool operator!=(const Smoothing &other) const;
9384
9386 std::string toString() const;
9387
9389 friend std::ostream &operator<<(std::ostream &stream, const Smoothing &value)
9390 {
9391 return stream << value.toString();
9392 }
9393
9394 private:
9395 void setFromString(const std::string &value);
9396
9397 void setFromString(const std::string &fullPath, const std::string &value);
9398
9399 std::string getString(const std::string &fullPath) const;
9400
9401 Gaussian m_gaussian;
9402
9403 friend struct DataModel::Detail::Befriend<Smoothing>;
9404 };
9405
9406 using Descendants = std::tuple<
9441
9444
9489#ifndef NO_DOC
9490 template<
9491 typename... Args,
9492 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
9493 typename std::enable_if<
9494 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
9495 value,
9496 int>::type = 0>
9497#else
9498 template<typename... Args>
9499#endif
9500 explicit Filters(Args &&...args)
9501 {
9502 using namespace Zivid::Detail::TypeTraits;
9503
9504 static_assert(
9505 AllArgsDecayedAreUnique<Args...>::value,
9506 "Found duplicate types among the arguments passed to Filters(...). "
9507 "Types should be listed at most once.");
9508
9509 set(std::forward<Args>(args)...);
9510 }
9511
9555#ifndef NO_DOC
9556 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
9557#else
9558 template<typename... Args>
9559#endif
9560 void set(Args &&...args)
9561 {
9562 using namespace Zivid::Detail::TypeTraits;
9563
9564 using AllArgsAreDescendantNodes =
9565 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
9566 static_assert(
9567 AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
9568
9569 static_assert(
9570 AllArgsDecayedAreUnique<Args...>::value,
9571 "Found duplicate types among the arguments passed to set(...). "
9572 "Types should be listed at most once.");
9573
9574 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
9575 }
9576
9621#ifndef NO_DOC
9622 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
9623#else
9624 template<typename... Args>
9625#endif
9626 Filters copyWith(Args &&...args) const
9627 {
9628 using namespace Zivid::Detail::TypeTraits;
9629
9630 using AllArgsAreDescendantNodes =
9631 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
9632 static_assert(
9633 AllArgsAreDescendantNodes::value,
9634 "All arguments passed to copyWith(...) must be descendant nodes.");
9635
9636 static_assert(
9637 AllArgsDecayedAreUnique<Args...>::value,
9638 "Found duplicate types among the arguments passed to copyWith(...). "
9639 "Types should be listed at most once.");
9640
9641 auto copy{ *this };
9642 copy.set(std::forward<Args>(args)...);
9643 return copy;
9644 }
9645
9647 const Cluster &cluster() const
9648 {
9649 return m_cluster;
9650 }
9651
9654 {
9655 return m_cluster;
9656 }
9657
9659 Filters &set(const Cluster &value)
9660 {
9661 m_cluster = value;
9662 return *this;
9663 }
9664
9667 {
9668 m_cluster.set(value);
9669 return *this;
9670 }
9671
9674 {
9675 m_cluster.set(value);
9676 return *this;
9677 }
9678
9681 {
9682 m_cluster.set(value);
9683 return *this;
9684 }
9685
9688 {
9689 m_cluster.set(value);
9690 return *this;
9691 }
9692
9695 {
9696 return m_experimental;
9697 }
9698
9701 {
9702 return m_experimental;
9703 }
9704
9706 Filters &set(const Experimental &value)
9707 {
9708 m_experimental = value;
9709 return *this;
9710 }
9711
9714 {
9715 m_experimental.set(value);
9716 return *this;
9717 }
9718
9721 {
9722 m_experimental.set(value);
9723 return *this;
9724 }
9725
9728 {
9729 m_experimental.set(value);
9730 return *this;
9731 }
9732
9735 {
9736 m_experimental.set(value);
9737 return *this;
9738 }
9739
9742 {
9743 m_experimental.set(value);
9744 return *this;
9745 }
9746
9749 {
9750 m_experimental.set(value);
9751 return *this;
9752 }
9753
9756 {
9757 m_experimental.set(value);
9758 return *this;
9759 }
9760
9763 {
9764 m_experimental.set(value);
9765 return *this;
9766 }
9767
9770 {
9771 m_experimental.set(value);
9772 return *this;
9773 }
9774
9777 {
9778 m_experimental.set(value);
9779 return *this;
9780 }
9781
9784 {
9785 m_experimental.set(value);
9786 return *this;
9787 }
9788
9790 const Noise &noise() const
9791 {
9792 return m_noise;
9793 }
9794
9797 {
9798 return m_noise;
9799 }
9800
9802 Filters &set(const Noise &value)
9803 {
9804 m_noise = value;
9805 return *this;
9806 }
9807
9810 {
9811 m_noise.set(value);
9812 return *this;
9813 }
9814
9817 {
9818 m_noise.set(value);
9819 return *this;
9820 }
9821
9824 {
9825 m_noise.set(value);
9826 return *this;
9827 }
9828
9830 const Outlier &outlier() const
9831 {
9832 return m_outlier;
9833 }
9834
9837 {
9838 return m_outlier;
9839 }
9840
9842 Filters &set(const Outlier &value)
9843 {
9844 m_outlier = value;
9845 return *this;
9846 }
9847
9850 {
9851 m_outlier.set(value);
9852 return *this;
9853 }
9854
9857 {
9858 m_outlier.set(value);
9859 return *this;
9860 }
9861
9864 {
9865 m_outlier.set(value);
9866 return *this;
9867 }
9868
9870 const Reflection &reflection() const
9871 {
9872 return m_reflection;
9873 }
9874
9877 {
9878 return m_reflection;
9879 }
9880
9882 Filters &set(const Reflection &value)
9883 {
9884 m_reflection = value;
9885 return *this;
9886 }
9887
9890 {
9891 m_reflection.set(value);
9892 return *this;
9893 }
9894
9897 {
9898 m_reflection.set(value);
9899 return *this;
9900 }
9901
9904 {
9905 m_reflection.set(value);
9906 return *this;
9907 }
9908
9911 {
9912 m_reflection.set(value);
9913 return *this;
9914 }
9915
9917 const Smoothing &smoothing() const
9918 {
9919 return m_smoothing;
9920 }
9921
9924 {
9925 return m_smoothing;
9926 }
9927
9929 Filters &set(const Smoothing &value)
9930 {
9931 m_smoothing = value;
9932 return *this;
9933 }
9934
9937 {
9938 m_smoothing.set(value);
9939 return *this;
9940 }
9941
9944 {
9945 m_smoothing.set(value);
9946 return *this;
9947 }
9948
9951 {
9952 m_smoothing.set(value);
9953 return *this;
9954 }
9955
9956 template<
9957 typename T,
9958 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Cluster>::value, int>::type =
9959 0>
9961 {
9962 return m_cluster;
9963 }
9964
9965 template<
9966 typename T,
9967 typename std::enable_if<
9968 std::is_same<T, Settings::Processing::Filters::Cluster::Removal>::value,
9969 int>::type = 0>
9971 {
9973 }
9974
9975 template<
9976 typename T,
9977 typename std::enable_if<
9978 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::Enabled>::value,
9979 int>::type = 0>
9981 {
9983 }
9984
9985 template<
9986 typename T,
9987 typename std::enable_if<
9988 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>::value,
9989 int>::type = 0>
9991 {
9993 }
9994
9995 template<
9996 typename T,
9997 typename std::enable_if<
9998 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MinArea>::value,
9999 int>::type = 0>
10001 {
10003 }
10004
10005 template<
10006 typename T,
10007 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Experimental>::value, int>::
10008 type = 0>
10010 {
10011 return m_experimental;
10012 }
10013
10014 template<
10015 typename T,
10016 typename std::enable_if<
10017 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
10018 int>::type = 0>
10020 {
10022 }
10023
10024 template<
10025 typename T,
10026 typename std::enable_if<
10027 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::
10028 value,
10029 int>::type = 0>
10031 {
10032 return m_experimental
10034 }
10035
10036 template<
10037 typename T,
10038 typename std::enable_if<
10039 std::is_same<
10040 T,
10042 value,
10043 int>::type = 0>
10045 {
10046 return m_experimental
10048 }
10049
10050 template<
10051 typename T,
10052 typename std::enable_if<
10053 std::is_same<
10054 T,
10056 value,
10057 int>::type = 0>
10059 {
10060 return m_experimental
10062 }
10063
10064 template<
10065 typename T,
10066 typename std::enable_if<
10067 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::
10068 value,
10069 int>::type = 0>
10071 {
10072 return m_experimental
10074 }
10075
10076 template<
10077 typename T,
10078 typename std::enable_if<
10079 std::is_same<
10080 T,
10082 int>::type = 0>
10084 {
10085 return m_experimental
10087 }
10088
10089 template<
10090 typename T,
10091 typename std::enable_if<
10092 std::is_same<
10093 T,
10095 int>::type = 0>
10097 {
10098 return m_experimental
10100 }
10101
10102 template<
10103 typename T,
10104 typename std::enable_if<
10105 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling>::value,
10106 int>::type = 0>
10108 {
10110 }
10111
10112 template<
10113 typename T,
10114 typename std::enable_if<
10115 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Enabled>::value,
10116 int>::type = 0>
10118 {
10120 }
10121
10122 template<
10123 typename T,
10124 typename std::enable_if<
10125 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>::value,
10126 int>::type = 0>
10128 {
10130 }
10131
10132 template<
10133 typename T,
10134 typename std::enable_if<
10135 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Strictness>::value,
10136 int>::type = 0>
10138 {
10140 }
10141
10142 template<
10143 typename T,
10144 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise>::value, int>::type =
10145 0>
10147 {
10148 return m_noise;
10149 }
10150
10151 template<
10152 typename T,
10153 typename std::
10154 enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Removal>::value, int>::type = 0>
10156 {
10158 }
10159
10160 template<
10161 typename T,
10162 typename std::enable_if<
10163 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
10164 int>::type = 0>
10166 {
10168 }
10169
10170 template<
10171 typename T,
10172 typename std::enable_if<
10173 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
10174 int>::type = 0>
10176 {
10178 }
10179
10180 template<
10181 typename T,
10182 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier>::value, int>::type =
10183 0>
10185 {
10186 return m_outlier;
10187 }
10188
10189 template<
10190 typename T,
10191 typename std::enable_if<
10192 std::is_same<T, Settings::Processing::Filters::Outlier::Removal>::value,
10193 int>::type = 0>
10195 {
10197 }
10198
10199 template<
10200 typename T,
10201 typename std::enable_if<
10202 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
10203 int>::type = 0>
10205 {
10207 }
10208
10209 template<
10210 typename T,
10211 typename std::enable_if<
10212 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
10213 int>::type = 0>
10215 {
10217 }
10218
10219 template<
10220 typename T,
10221 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection>::value, int>::
10222 type = 0>
10224 {
10225 return m_reflection;
10226 }
10227
10228 template<
10229 typename T,
10230 typename std::enable_if<
10231 std::is_same<T, Settings::Processing::Filters::Reflection::Removal>::value,
10232 int>::type = 0>
10234 {
10236 }
10237
10238 template<
10239 typename T,
10240 typename std::enable_if<
10241 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
10242 int>::type = 0>
10244 {
10246 }
10247
10248 template<
10249 typename T,
10250 typename std::enable_if<
10251 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental>::value,
10252 int>::type = 0>
10254 {
10256 }
10257
10258 template<
10259 typename T,
10260 typename std::enable_if<
10261 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>::value,
10262 int>::type = 0>
10264 {
10266 }
10267
10268 template<
10269 typename T,
10270 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing>::value, int>::
10271 type = 0>
10273 {
10274 return m_smoothing;
10275 }
10276
10277 template<
10278 typename T,
10279 typename std::enable_if<
10280 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian>::value,
10281 int>::type = 0>
10283 {
10285 }
10286
10287 template<
10288 typename T,
10289 typename std::enable_if<
10290 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
10291 int>::type = 0>
10293 {
10295 }
10296
10297 template<
10298 typename T,
10299 typename std::enable_if<
10300 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
10301 int>::type = 0>
10303 {
10305 }
10306
10307 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
10309 {
10310 return m_cluster;
10311 }
10312
10313 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
10315 {
10316 return m_experimental;
10317 }
10318
10319 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
10321 {
10322 return m_noise;
10323 }
10324
10325 template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
10327 {
10328 return m_outlier;
10329 }
10330
10331 template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
10333 {
10334 return m_reflection;
10335 }
10336
10337 template<size_t i, typename std::enable_if<i == 5, int>::type = 0>
10339 {
10340 return m_smoothing;
10341 }
10342
10344 template<typename F>
10345 void forEach(const F &f) const
10346 {
10347 f(m_cluster);
10348 f(m_experimental);
10349 f(m_noise);
10350 f(m_outlier);
10351 f(m_reflection);
10352 f(m_smoothing);
10353 }
10354
10356 template<typename F>
10357 void forEach(const F &f)
10358 {
10359 f(m_cluster);
10360 f(m_experimental);
10361 f(m_noise);
10362 f(m_outlier);
10363 f(m_reflection);
10364 f(m_smoothing);
10365 }
10366
10368 bool operator==(const Filters &other) const;
10369
10371 bool operator!=(const Filters &other) const;
10372
10374 std::string toString() const;
10375
10377 friend std::ostream &operator<<(std::ostream &stream, const Filters &value)
10378 {
10379 return stream << value.toString();
10380 }
10381
10382 private:
10383 void setFromString(const std::string &value);
10384
10385 void setFromString(const std::string &fullPath, const std::string &value);
10386
10387 std::string getString(const std::string &fullPath) const;
10388
10389 Cluster m_cluster;
10390 Experimental m_experimental;
10391 Noise m_noise;
10392 Outlier m_outlier;
10393 Reflection m_reflection;
10394 Smoothing m_smoothing;
10395
10396 friend struct DataModel::Detail::Befriend<Filters>;
10397 };
10398
10399 using Descendants = std::tuple<
10443
10446
10500#ifndef NO_DOC
10501 template<
10502 typename... Args,
10503 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
10504 typename std::enable_if<
10505 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
10506 value,
10507 int>::type = 0>
10508#else
10509 template<typename... Args>
10510#endif
10511 explicit Processing(Args &&...args)
10512 {
10513 using namespace Zivid::Detail::TypeTraits;
10514
10515 static_assert(
10516 AllArgsDecayedAreUnique<Args...>::value,
10517 "Found duplicate types among the arguments passed to Processing(...). "
10518 "Types should be listed at most once.");
10519
10520 set(std::forward<Args>(args)...);
10521 }
10522
10575#ifndef NO_DOC
10576 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
10577#else
10578 template<typename... Args>
10579#endif
10580 void set(Args &&...args)
10581 {
10582 using namespace Zivid::Detail::TypeTraits;
10583
10584 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
10585 static_assert(
10586 AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
10587
10588 static_assert(
10589 AllArgsDecayedAreUnique<Args...>::value,
10590 "Found duplicate types among the arguments passed to set(...). "
10591 "Types should be listed at most once.");
10592
10593 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
10594 }
10595
10649#ifndef NO_DOC
10650 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
10651#else
10652 template<typename... Args>
10653#endif
10654 Processing copyWith(Args &&...args) const
10655 {
10656 using namespace Zivid::Detail::TypeTraits;
10657
10658 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
10659 static_assert(
10660 AllArgsAreDescendantNodes::value,
10661 "All arguments passed to copyWith(...) must be descendant nodes.");
10662
10663 static_assert(
10664 AllArgsDecayedAreUnique<Args...>::value,
10665 "Found duplicate types among the arguments passed to copyWith(...). "
10666 "Types should be listed at most once.");
10667
10668 auto copy{ *this };
10669 copy.set(std::forward<Args>(args)...);
10670 return copy;
10671 }
10672
10674 const Color &color() const
10675 {
10676 return m_color;
10677 }
10678
10681 {
10682 return m_color;
10683 }
10684
10686 Processing &set(const Color &value)
10687 {
10688 m_color = value;
10689 return *this;
10690 }
10691
10694 {
10695 m_color.set(value);
10696 return *this;
10697 }
10698
10701 {
10702 m_color.set(value);
10703 return *this;
10704 }
10705
10708 {
10709 m_color.set(value);
10710 return *this;
10711 }
10712
10715 {
10716 m_color.set(value);
10717 return *this;
10718 }
10719
10722 {
10723 m_color.set(value);
10724 return *this;
10725 }
10726
10729 {
10730 m_color.set(value);
10731 return *this;
10732 }
10733
10736 {
10737 m_color.set(value);
10738 return *this;
10739 }
10740
10742 const Filters &filters() const
10743 {
10744 return m_filters;
10745 }
10746
10749 {
10750 return m_filters;
10751 }
10752
10754 Processing &set(const Filters &value)
10755 {
10756 m_filters = value;
10757 return *this;
10758 }
10759
10762 {
10763 m_filters.set(value);
10764 return *this;
10765 }
10766
10769 {
10770 m_filters.set(value);
10771 return *this;
10772 }
10773
10776 {
10777 m_filters.set(value);
10778 return *this;
10779 }
10780
10783 {
10784 m_filters.set(value);
10785 return *this;
10786 }
10787
10790 {
10791 m_filters.set(value);
10792 return *this;
10793 }
10794
10797 {
10798 m_filters.set(value);
10799 return *this;
10800 }
10801
10804 {
10805 m_filters.set(value);
10806 return *this;
10807 }
10808
10811 {
10812 m_filters.set(value);
10813 return *this;
10814 }
10815
10818 {
10819 m_filters.set(value);
10820 return *this;
10821 }
10822
10825 {
10826 m_filters.set(value);
10827 return *this;
10828 }
10829
10832 {
10833 m_filters.set(value);
10834 return *this;
10835 }
10836
10839 {
10840 m_filters.set(value);
10841 return *this;
10842 }
10843
10846 {
10847 m_filters.set(value);
10848 return *this;
10849 }
10850
10853 {
10854 m_filters.set(value);
10855 return *this;
10856 }
10857
10860 {
10861 m_filters.set(value);
10862 return *this;
10863 }
10864
10867 {
10868 m_filters.set(value);
10869 return *this;
10870 }
10871
10874 {
10875 m_filters.set(value);
10876 return *this;
10877 }
10878
10881 {
10882 m_filters.set(value);
10883 return *this;
10884 }
10885
10888 {
10889 m_filters.set(value);
10890 return *this;
10891 }
10892
10895 {
10896 m_filters.set(value);
10897 return *this;
10898 }
10899
10902 {
10903 m_filters.set(value);
10904 return *this;
10905 }
10906
10909 {
10910 m_filters.set(value);
10911 return *this;
10912 }
10913
10916 {
10917 m_filters.set(value);
10918 return *this;
10919 }
10920
10923 {
10924 m_filters.set(value);
10925 return *this;
10926 }
10927
10930 {
10931 m_filters.set(value);
10932 return *this;
10933 }
10934
10937 {
10938 m_filters.set(value);
10939 return *this;
10940 }
10941
10944 {
10945 m_filters.set(value);
10946 return *this;
10947 }
10948
10951 {
10952 m_filters.set(value);
10953 return *this;
10954 }
10955
10958 {
10959 m_filters.set(value);
10960 return *this;
10961 }
10962
10965 {
10966 m_filters.set(value);
10967 return *this;
10968 }
10969
10972 {
10973 m_filters.set(value);
10974 return *this;
10975 }
10976
10979 {
10980 m_filters.set(value);
10981 return *this;
10982 }
10983
10986 {
10987 m_filters.set(value);
10988 return *this;
10989 }
10990
10993 {
10994 m_filters.set(value);
10995 return *this;
10996 }
10997
10998 template<
10999 typename T,
11000 typename std::enable_if<std::is_same<T, Settings::Processing::Color>::value, int>::type = 0>
11002 {
11003 return m_color;
11004 }
11005
11006 template<
11007 typename T,
11008 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance>::value, int>::type = 0>
11010 {
11011 return m_color.get<Settings::Processing::Color::Balance>();
11012 }
11013
11014 template<
11015 typename T,
11016 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Blue>::value, int>::type =
11017 0>
11019 {
11020 return m_color.get<Settings::Processing::Color::Balance::Blue>();
11021 }
11022
11023 template<
11024 typename T,
11025 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Green>::value, int>::
11026 type = 0>
11028 {
11029 return m_color.get<Settings::Processing::Color::Balance::Green>();
11030 }
11031
11032 template<
11033 typename T,
11034 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Red>::value, int>::type =
11035 0>
11037 {
11038 return m_color.get<Settings::Processing::Color::Balance::Red>();
11039 }
11040
11041 template<
11042 typename T,
11043 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental>::value, int>::type =
11044 0>
11046 {
11048 }
11049
11050 template<
11051 typename T,
11052 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental::Mode>::value, int>::
11053 type = 0>
11055 {
11057 }
11058
11059 template<
11060 typename T,
11061 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Gamma>::value, int>::type = 0>
11063 {
11064 return m_color.get<Settings::Processing::Color::Gamma>();
11065 }
11066
11067 template<
11068 typename T,
11069 typename std::enable_if<std::is_same<T, Settings::Processing::Filters>::value, int>::type = 0>
11071 {
11072 return m_filters;
11073 }
11074
11075 template<
11076 typename T,
11077 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Cluster>::value, int>::type = 0>
11079 {
11080 return m_filters.get<Settings::Processing::Filters::Cluster>();
11081 }
11082
11083 template<
11084 typename T,
11085 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Cluster::Removal>::value, int>::
11086 type = 0>
11088 {
11090 }
11091
11092 template<
11093 typename T,
11094 typename std::enable_if<
11095 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::Enabled>::value,
11096 int>::type = 0>
11098 {
11100 }
11101
11102 template<
11103 typename T,
11104 typename std::enable_if<
11105 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>::value,
11106 int>::type = 0>
11108 {
11110 }
11111
11112 template<
11113 typename T,
11114 typename std::enable_if<
11115 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MinArea>::value,
11116 int>::type = 0>
11118 {
11120 }
11121
11122 template<
11123 typename T,
11124 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Experimental>::value, int>::
11125 type = 0>
11127 {
11129 }
11130
11131 template<
11132 typename T,
11133 typename std::enable_if<
11134 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
11135 int>::type = 0>
11137 {
11139 }
11140
11141 template<
11142 typename T,
11143 typename std::enable_if<
11144 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::value,
11145 int>::type = 0>
11147 {
11149 }
11150
11151 template<
11152 typename T,
11153 typename std::enable_if<
11154 std::is_same<
11155 T,
11157 int>::type = 0>
11159 {
11160 return m_filters
11162 }
11163
11164 template<
11165 typename T,
11166 typename std::enable_if<
11167 std::is_same<
11168 T,
11170 int>::type = 0>
11172 {
11173 return m_filters
11175 }
11176
11177 template<
11178 typename T,
11179 typename std::enable_if<
11180 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::value,
11181 int>::type = 0>
11183 {
11185 }
11186
11187 template<
11188 typename T,
11189 typename std::enable_if<
11190 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>::
11191 value,
11192 int>::type = 0>
11194 {
11195 return m_filters
11197 }
11198
11199 template<
11200 typename T,
11201 typename std::enable_if<
11202 std::is_same<
11203 T,
11205 int>::type = 0>
11207 {
11208 return m_filters
11210 }
11211
11212 template<
11213 typename T,
11214 typename std::enable_if<
11215 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling>::value,
11216 int>::type = 0>
11218 {
11220 }
11221
11222 template<
11223 typename T,
11224 typename std::enable_if<
11225 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Enabled>::value,
11226 int>::type = 0>
11228 {
11230 }
11231
11232 template<
11233 typename T,
11234 typename std::enable_if<
11235 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>::value,
11236 int>::type = 0>
11238 {
11240 }
11241
11242 template<
11243 typename T,
11244 typename std::enable_if<
11245 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Strictness>::value,
11246 int>::type = 0>
11248 {
11250 }
11251
11252 template<
11253 typename T,
11254 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise>::value, int>::type = 0>
11256 {
11257 return m_filters.get<Settings::Processing::Filters::Noise>();
11258 }
11259
11260 template<
11261 typename T,
11262 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Removal>::value, int>::
11263 type = 0>
11265 {
11267 }
11268
11269 template<
11270 typename T,
11271 typename std::enable_if<
11272 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
11273 int>::type = 0>
11275 {
11277 }
11278
11279 template<
11280 typename T,
11281 typename std::enable_if<
11282 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
11283 int>::type = 0>
11285 {
11287 }
11288
11289 template<
11290 typename T,
11291 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier>::value, int>::type = 0>
11293 {
11294 return m_filters.get<Settings::Processing::Filters::Outlier>();
11295 }
11296
11297 template<
11298 typename T,
11299 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier::Removal>::value, int>::
11300 type = 0>
11302 {
11304 }
11305
11306 template<
11307 typename T,
11308 typename std::enable_if<
11309 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
11310 int>::type = 0>
11312 {
11314 }
11315
11316 template<
11317 typename T,
11318 typename std::enable_if<
11319 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
11320 int>::type = 0>
11322 {
11324 }
11325
11326 template<
11327 typename T,
11328 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection>::value, int>::type =
11329 0>
11331 {
11333 }
11334
11335 template<
11336 typename T,
11337 typename std::enable_if<
11338 std::is_same<T, Settings::Processing::Filters::Reflection::Removal>::value,
11339 int>::type = 0>
11341 {
11343 }
11344
11345 template<
11346 typename T,
11347 typename std::enable_if<
11348 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
11349 int>::type = 0>
11351 {
11353 }
11354
11355 template<
11356 typename T,
11357 typename std::enable_if<
11358 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental>::value,
11359 int>::type = 0>
11361 {
11363 }
11364
11365 template<
11366 typename T,
11367 typename std::enable_if<
11368 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>::value,
11369 int>::type = 0>
11371 {
11373 }
11374
11375 template<
11376 typename T,
11377 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing>::value, int>::type =
11378 0>
11380 {
11382 }
11383
11384 template<
11385 typename T,
11386 typename std::enable_if<
11387 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian>::value,
11388 int>::type = 0>
11390 {
11392 }
11393
11394 template<
11395 typename T,
11396 typename std::enable_if<
11397 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
11398 int>::type = 0>
11400 {
11402 }
11403
11404 template<
11405 typename T,
11406 typename std::enable_if<
11407 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
11408 int>::type = 0>
11410 {
11412 }
11413
11414 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
11416 {
11417 return m_color;
11418 }
11419
11420 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
11422 {
11423 return m_filters;
11424 }
11425
11427 template<typename F>
11428 void forEach(const F &f) const
11429 {
11430 f(m_color);
11431 f(m_filters);
11432 }
11433
11435 template<typename F>
11436 void forEach(const F &f)
11437 {
11438 f(m_color);
11439 f(m_filters);
11440 }
11441
11443 bool operator==(const Processing &other) const;
11444
11446 bool operator!=(const Processing &other) const;
11447
11449 std::string toString() const;
11450
11452 friend std::ostream &operator<<(std::ostream &stream, const Processing &value)
11453 {
11454 return stream << value.toString();
11455 }
11456
11457 private:
11458 void setFromString(const std::string &value);
11459
11460 void setFromString(const std::string &fullPath, const std::string &value);
11461
11462 std::string getString(const std::string &fullPath) const;
11463
11464 Color m_color;
11465 Filters m_filters;
11466
11467 friend struct DataModel::Detail::Befriend<Processing>;
11468 };
11469
11472
11473 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
11475 {
11476 public:
11479
11481 static constexpr const char *path{ "RegionOfInterest" };
11482
11484 static constexpr const char *name{ "RegionOfInterest" };
11485
11487 static constexpr const char *description{ R"description(Removes points outside the region of interest.
11488)description" };
11489
11501
11502 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
11504 {
11505 public:
11508
11510 static constexpr const char *path{ "RegionOfInterest/Box" };
11511
11513 static constexpr const char *name{ "Box" };
11514
11516 static constexpr const char *description{ R"description(Removes the points outside the box.
11517
11518The box is defined by three points: O, A and B. These points define two vectors,
11519OA that goes from PointO to PointA, and OB that goes from PointO to PointB.
11520This gives 4 points O, A, B and (O + OA + OB), that together form a
11521parallelogram in 3D.
11522
11523Two extents can be provided, to extrude the parallelogram along the surface
11524normal vector of the parallelogram plane. This creates a 3D volume (parallelepiped).
11525The surface normal vector is defined by the cross product OA x OB.
11526)description" };
11527
11529
11530 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
11532 {
11533 public:
11536
11538 static constexpr const char *path{ "RegionOfInterest/Box/Enabled" };
11539
11541 static constexpr const char *name{ "Enabled" };
11542
11544 static constexpr const char *description{ R"description(Enabled)description" };
11545
11547 using ValueType = bool;
11548 static const Enabled yes;
11549 static const Enabled no;
11550
11552 static std::set<bool> validValues()
11553 {
11554 return { false, true };
11555 }
11556
11558 Enabled() = default;
11559
11561 explicit constexpr Enabled(bool value)
11562 : m_opt{ value }
11563 {}
11564
11569 bool value() const;
11570
11572 bool hasValue() const;
11573
11575 void reset();
11576
11578 std::string toString() const;
11579
11581 bool operator==(const Enabled &other) const
11582 {
11583 return m_opt == other.m_opt;
11584 }
11585
11587 bool operator!=(const Enabled &other) const
11588 {
11589 return m_opt != other.m_opt;
11590 }
11591
11593 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
11594 {
11595 return stream << value.toString();
11596 }
11597
11598 private:
11599 void setFromString(const std::string &value);
11600
11601 Zivid::DataModel::Detail::Optional<bool> m_opt;
11602
11603 friend struct DataModel::Detail::Befriend<Enabled>;
11604 };
11605
11607
11608 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
11610 {
11611 public:
11614
11616 static constexpr const char *path{ "RegionOfInterest/Box/Extents" };
11617
11619 static constexpr const char *name{ "Extents" };
11620
11622 static constexpr const char *description{
11623 R"description(Two points on the normal describing the direction and distance from the plane from which the normal is derived.)description"
11624 };
11625
11628
11630 Extents() = default;
11631
11633 explicit constexpr Extents(Zivid::Range<double> value)
11634 : m_opt{ value }
11635 {}
11636
11642
11644 bool hasValue() const;
11645
11647 void reset();
11648
11650 std::string toString() const;
11651
11653 explicit constexpr Extents(double minValue, double maxValue)
11654 : Extents{ Zivid::Range<double>{ minValue, maxValue } }
11655 {}
11656
11658 bool operator==(const Extents &other) const
11659 {
11660 return m_opt == other.m_opt;
11661 }
11662
11664 bool operator!=(const Extents &other) const
11665 {
11666 return m_opt != other.m_opt;
11667 }
11668
11670 friend std::ostream &operator<<(std::ostream &stream, const Extents &value)
11671 {
11672 return stream << value.toString();
11673 }
11674
11675 private:
11676 void setFromString(const std::string &value);
11677
11678 Zivid::DataModel::Detail::Optional<Zivid::Range<double>> m_opt;
11679
11680 friend struct DataModel::Detail::Befriend<Extents>;
11681 };
11682
11684
11685 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
11687 {
11688 public:
11691
11693 static constexpr const char *path{ "RegionOfInterest/Box/PointA" };
11694
11696 static constexpr const char *name{ "PointA" };
11697
11699 static constexpr const char *description{
11700 R"description(A point such that the vector from PointO to PointA describes the first edge of the parallelogram)description"
11701 };
11702
11705
11707 PointA() = default;
11708
11710 explicit constexpr PointA(Zivid::PointXYZ value)
11711 : m_opt{ value }
11712 {}
11713
11719
11721 bool hasValue() const;
11722
11724 void reset();
11725
11727 std::string toString() const;
11728
11730 explicit constexpr PointA(float x, float y, float z)
11731 : PointA{ Zivid::PointXYZ{ x, y, z } }
11732 {}
11733
11735 bool operator==(const PointA &other) const
11736 {
11737 return m_opt == other.m_opt;
11738 }
11739
11741 bool operator!=(const PointA &other) const
11742 {
11743 return m_opt != other.m_opt;
11744 }
11745
11747 friend std::ostream &operator<<(std::ostream &stream, const PointA &value)
11748 {
11749 return stream << value.toString();
11750 }
11751
11752 private:
11753 void setFromString(const std::string &value);
11754
11755 Zivid::DataModel::Detail::Optional<Zivid::PointXYZ> m_opt;
11756
11757 friend struct DataModel::Detail::Befriend<PointA>;
11758 };
11759
11761
11762 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
11764 {
11765 public:
11768
11770 static constexpr const char *path{ "RegionOfInterest/Box/PointB" };
11771
11773 static constexpr const char *name{ "PointB" };
11774
11776 static constexpr const char *description{
11777 R"description(A point such that the vector from PointO to PointB describes the second edge of the parallelogram)description"
11778 };
11779
11782
11784 PointB() = default;
11785
11787 explicit constexpr PointB(Zivid::PointXYZ value)
11788 : m_opt{ value }
11789 {}
11790
11796
11798 bool hasValue() const;
11799
11801 void reset();
11802
11804 std::string toString() const;
11805
11807 explicit constexpr PointB(float x, float y, float z)
11808 : PointB{ Zivid::PointXYZ{ x, y, z } }
11809 {}
11810
11812 bool operator==(const PointB &other) const
11813 {
11814 return m_opt == other.m_opt;
11815 }
11816
11818 bool operator!=(const PointB &other) const
11819 {
11820 return m_opt != other.m_opt;
11821 }
11822
11824 friend std::ostream &operator<<(std::ostream &stream, const PointB &value)
11825 {
11826 return stream << value.toString();
11827 }
11828
11829 private:
11830 void setFromString(const std::string &value);
11831
11832 Zivid::DataModel::Detail::Optional<Zivid::PointXYZ> m_opt;
11833
11834 friend struct DataModel::Detail::Befriend<PointB>;
11835 };
11836
11838
11839 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
11841 {
11842 public:
11845
11847 static constexpr const char *path{ "RegionOfInterest/Box/PointO" };
11848
11850 static constexpr const char *name{ "PointO" };
11851
11853 static constexpr const char *description{
11854 R"description(The point at the intersection of two adjacent edges defining a parallelogram)description"
11855 };
11856
11859
11861 PointO() = default;
11862
11864 explicit constexpr PointO(Zivid::PointXYZ value)
11865 : m_opt{ value }
11866 {}
11867
11873
11875 bool hasValue() const;
11876
11878 void reset();
11879
11881 std::string toString() const;
11882
11884 explicit constexpr PointO(float x, float y, float z)
11885 : PointO{ Zivid::PointXYZ{ x, y, z } }
11886 {}
11887
11889 bool operator==(const PointO &other) const
11890 {
11891 return m_opt == other.m_opt;
11892 }
11893
11895 bool operator!=(const PointO &other) const
11896 {
11897 return m_opt != other.m_opt;
11898 }
11899
11901 friend std::ostream &operator<<(std::ostream &stream, const PointO &value)
11902 {
11903 return stream << value.toString();
11904 }
11905
11906 private:
11907 void setFromString(const std::string &value);
11908
11909 Zivid::DataModel::Detail::Optional<Zivid::PointXYZ> m_opt;
11910
11911 friend struct DataModel::Detail::Befriend<PointO>;
11912 };
11913
11914 using Descendants = std::tuple<
11920
11923
11939#ifndef NO_DOC
11940 template<
11941 typename... Args,
11942 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
11943 typename std::enable_if<
11944 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
11945 value,
11946 int>::type = 0>
11947#else
11948 template<typename... Args>
11949#endif
11950 explicit Box(Args &&...args)
11951 {
11952 using namespace Zivid::Detail::TypeTraits;
11953
11954 static_assert(
11955 AllArgsDecayedAreUnique<Args...>::value,
11956 "Found duplicate types among the arguments passed to Box(...). "
11957 "Types should be listed at most once.");
11958
11959 set(std::forward<Args>(args)...);
11960 }
11961
11976#ifndef NO_DOC
11977 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
11978#else
11979 template<typename... Args>
11980#endif
11981 void set(Args &&...args)
11982 {
11983 using namespace Zivid::Detail::TypeTraits;
11984
11985 using AllArgsAreDescendantNodes =
11986 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
11987 static_assert(
11988 AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
11989
11990 static_assert(
11991 AllArgsDecayedAreUnique<Args...>::value,
11992 "Found duplicate types among the arguments passed to set(...). "
11993 "Types should be listed at most once.");
11994
11995 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
11996 }
11997
12013#ifndef NO_DOC
12014 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
12015#else
12016 template<typename... Args>
12017#endif
12018 Box copyWith(Args &&...args) const
12019 {
12020 using namespace Zivid::Detail::TypeTraits;
12021
12022 using AllArgsAreDescendantNodes =
12023 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
12024 static_assert(
12025 AllArgsAreDescendantNodes::value,
12026 "All arguments passed to copyWith(...) must be descendant nodes.");
12027
12028 static_assert(
12029 AllArgsDecayedAreUnique<Args...>::value,
12030 "Found duplicate types among the arguments passed to copyWith(...). "
12031 "Types should be listed at most once.");
12032
12033 auto copy{ *this };
12034 copy.set(std::forward<Args>(args)...);
12035 return copy;
12036 }
12037
12039 const Enabled &isEnabled() const
12040 {
12041 return m_enabled;
12042 }
12043
12046 {
12047 return m_enabled;
12048 }
12049
12051 Box &set(const Enabled &value)
12052 {
12053 m_enabled = value;
12054 return *this;
12055 }
12056
12058 const Extents &extents() const
12059 {
12060 return m_extents;
12061 }
12062
12065 {
12066 return m_extents;
12067 }
12068
12070 Box &set(const Extents &value)
12071 {
12072 m_extents = value;
12073 return *this;
12074 }
12075
12077 const PointA &pointA() const
12078 {
12079 return m_pointA;
12080 }
12081
12084 {
12085 return m_pointA;
12086 }
12087
12089 Box &set(const PointA &value)
12090 {
12091 m_pointA = value;
12092 return *this;
12093 }
12094
12096 const PointB &pointB() const
12097 {
12098 return m_pointB;
12099 }
12100
12103 {
12104 return m_pointB;
12105 }
12106
12108 Box &set(const PointB &value)
12109 {
12110 m_pointB = value;
12111 return *this;
12112 }
12113
12115 const PointO &pointO() const
12116 {
12117 return m_pointO;
12118 }
12119
12122 {
12123 return m_pointO;
12124 }
12125
12127 Box &set(const PointO &value)
12128 {
12129 m_pointO = value;
12130 return *this;
12131 }
12132
12133 template<
12134 typename T,
12135 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::Enabled>::value, int>::
12136 type = 0>
12138 {
12139 return m_enabled;
12140 }
12141
12142 template<
12143 typename T,
12144 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::Extents>::value, int>::
12145 type = 0>
12147 {
12148 return m_extents;
12149 }
12150
12151 template<
12152 typename T,
12153 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointA>::value, int>::
12154 type = 0>
12156 {
12157 return m_pointA;
12158 }
12159
12160 template<
12161 typename T,
12162 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointB>::value, int>::
12163 type = 0>
12165 {
12166 return m_pointB;
12167 }
12168
12169 template<
12170 typename T,
12171 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointO>::value, int>::
12172 type = 0>
12174 {
12175 return m_pointO;
12176 }
12177
12178 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
12180 {
12181 return m_enabled;
12182 }
12183
12184 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
12186 {
12187 return m_extents;
12188 }
12189
12190 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
12192 {
12193 return m_pointA;
12194 }
12195
12196 template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
12198 {
12199 return m_pointB;
12200 }
12201
12202 template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
12204 {
12205 return m_pointO;
12206 }
12207
12209 template<typename F>
12210 void forEach(const F &f) const
12211 {
12212 f(m_enabled);
12213 f(m_extents);
12214 f(m_pointA);
12215 f(m_pointB);
12216 f(m_pointO);
12217 }
12218
12220 template<typename F>
12221 void forEach(const F &f)
12222 {
12223 f(m_enabled);
12224 f(m_extents);
12225 f(m_pointA);
12226 f(m_pointB);
12227 f(m_pointO);
12228 }
12229
12231 bool operator==(const Box &other) const;
12232
12234 bool operator!=(const Box &other) const;
12235
12237 std::string toString() const;
12238
12240 friend std::ostream &operator<<(std::ostream &stream, const Box &value)
12241 {
12242 return stream << value.toString();
12243 }
12244
12245 private:
12246 void setFromString(const std::string &value);
12247
12248 void setFromString(const std::string &fullPath, const std::string &value);
12249
12250 std::string getString(const std::string &fullPath) const;
12251
12252 Enabled m_enabled;
12253 Extents m_extents;
12254 PointA m_pointA;
12255 PointB m_pointB;
12256 PointO m_pointO;
12257
12258 friend struct DataModel::Detail::Befriend<Box>;
12259 };
12260
12264
12265 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
12267 {
12268 public:
12271
12273 static constexpr const char *path{ "RegionOfInterest/Depth" };
12274
12276 static constexpr const char *name{ "Depth" };
12277
12279 static constexpr const char *description{
12280 R"description(Removes points that reside outside of a depth range, meaning that their Z coordinate
12281falls above a given maximum or below a given minimum.
12282)description"
12283 };
12284
12286
12287 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
12289 {
12290 public:
12293
12295 static constexpr const char *path{ "RegionOfInterest/Depth/Enabled" };
12296
12298 static constexpr const char *name{ "Enabled" };
12299
12301 static constexpr const char *description{ R"description(Enabled)description" };
12302
12304 using ValueType = bool;
12305 static const Enabled yes;
12306 static const Enabled no;
12307
12309 static std::set<bool> validValues()
12310 {
12311 return { false, true };
12312 }
12313
12315 Enabled() = default;
12316
12318 explicit constexpr Enabled(bool value)
12319 : m_opt{ value }
12320 {}
12321
12326 bool value() const;
12327
12329 bool hasValue() const;
12330
12332 void reset();
12333
12335 std::string toString() const;
12336
12338 bool operator==(const Enabled &other) const
12339 {
12340 return m_opt == other.m_opt;
12341 }
12342
12344 bool operator!=(const Enabled &other) const
12345 {
12346 return m_opt != other.m_opt;
12347 }
12348
12350 friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
12351 {
12352 return stream << value.toString();
12353 }
12354
12355 private:
12356 void setFromString(const std::string &value);
12357
12358 Zivid::DataModel::Detail::Optional<bool> m_opt;
12359
12360 friend struct DataModel::Detail::Befriend<Enabled>;
12361 };
12362
12364
12365 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
12367 {
12368 public:
12371
12373 static constexpr const char *path{ "RegionOfInterest/Depth/Range" };
12374
12376 static constexpr const char *name{ "Range" };
12377
12379 static constexpr const char *description{
12380 R"description(Specify the minimum and maximum Z value that will be included.)description"
12381 };
12382
12385
12387 Range() = default;
12388
12390 explicit constexpr Range(Zivid::Range<double> value)
12391 : m_opt{ value }
12392 {}
12393
12399
12401 bool hasValue() const;
12402
12404 void reset();
12405
12407 std::string toString() const;
12408
12410 explicit constexpr Range(double minValue, double maxValue)
12411 : Range{ Zivid::Range<double>{ minValue, maxValue } }
12412 {}
12413
12415 bool operator==(const Range &other) const
12416 {
12417 return m_opt == other.m_opt;
12418 }
12419
12421 bool operator!=(const Range &other) const
12422 {
12423 return m_opt != other.m_opt;
12424 }
12425
12427 friend std::ostream &operator<<(std::ostream &stream, const Range &value)
12428 {
12429 return stream << value.toString();
12430 }
12431
12432 private:
12433 void setFromString(const std::string &value);
12434
12435 Zivid::DataModel::Detail::Optional<Zivid::Range<double>> m_opt;
12436
12437 friend struct DataModel::Detail::Befriend<Range>;
12438 };
12439
12441 std::tuple<Settings::RegionOfInterest::Depth::Enabled, Settings::RegionOfInterest::Depth::Range>;
12442
12445
12458#ifndef NO_DOC
12459 template<
12460 typename... Args,
12461 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
12462 typename std::enable_if<
12463 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
12464 value,
12465 int>::type = 0>
12466#else
12467 template<typename... Args>
12468#endif
12469 explicit Depth(Args &&...args)
12470 {
12471 using namespace Zivid::Detail::TypeTraits;
12472
12473 static_assert(
12474 AllArgsDecayedAreUnique<Args...>::value,
12475 "Found duplicate types among the arguments passed to Depth(...). "
12476 "Types should be listed at most once.");
12477
12478 set(std::forward<Args>(args)...);
12479 }
12480
12492#ifndef NO_DOC
12493 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
12494#else
12495 template<typename... Args>
12496#endif
12497 void set(Args &&...args)
12498 {
12499 using namespace Zivid::Detail::TypeTraits;
12500
12501 using AllArgsAreDescendantNodes =
12502 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
12503 static_assert(
12504 AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
12505
12506 static_assert(
12507 AllArgsDecayedAreUnique<Args...>::value,
12508 "Found duplicate types among the arguments passed to set(...). "
12509 "Types should be listed at most once.");
12510
12511 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
12512 }
12513
12526#ifndef NO_DOC
12527 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
12528#else
12529 template<typename... Args>
12530#endif
12531 Depth copyWith(Args &&...args) const
12532 {
12533 using namespace Zivid::Detail::TypeTraits;
12534
12535 using AllArgsAreDescendantNodes =
12536 AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
12537 static_assert(
12538 AllArgsAreDescendantNodes::value,
12539 "All arguments passed to copyWith(...) must be descendant nodes.");
12540
12541 static_assert(
12542 AllArgsDecayedAreUnique<Args...>::value,
12543 "Found duplicate types among the arguments passed to copyWith(...). "
12544 "Types should be listed at most once.");
12545
12546 auto copy{ *this };
12547 copy.set(std::forward<Args>(args)...);
12548 return copy;
12549 }
12550
12552 const Enabled &isEnabled() const
12553 {
12554 return m_enabled;
12555 }
12556
12559 {
12560 return m_enabled;
12561 }
12562
12564 Depth &set(const Enabled &value)
12565 {
12566 m_enabled = value;
12567 return *this;
12568 }
12569
12571 const Range &range() const
12572 {
12573 return m_range;
12574 }
12575
12578 {
12579 return m_range;
12580 }
12581
12583 Depth &set(const Range &value)
12584 {
12585 m_range = value;
12586 return *this;
12587 }
12588
12589 template<
12590 typename T,
12591 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth::Enabled>::value, int>::
12592 type = 0>
12594 {
12595 return m_enabled;
12596 }
12597
12598 template<
12599 typename T,
12600 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth::Range>::value, int>::
12601 type = 0>
12603 {
12604 return m_range;
12605 }
12606
12607 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
12609 {
12610 return m_enabled;
12611 }
12612
12613 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
12615 {
12616 return m_range;
12617 }
12618
12620 template<typename F>
12621 void forEach(const F &f) const
12622 {
12623 f(m_enabled);
12624 f(m_range);
12625 }
12626
12628 template<typename F>
12629 void forEach(const F &f)
12630 {
12631 f(m_enabled);
12632 f(m_range);
12633 }
12634
12636 bool operator==(const Depth &other) const;
12637
12639 bool operator!=(const Depth &other) const;
12640
12642 std::string toString() const;
12643
12645 friend std::ostream &operator<<(std::ostream &stream, const Depth &value)
12646 {
12647 return stream << value.toString();
12648 }
12649
12650 private:
12651 void setFromString(const std::string &value);
12652
12653 void setFromString(const std::string &fullPath, const std::string &value);
12654
12655 std::string getString(const std::string &fullPath) const;
12656
12657 Enabled m_enabled;
12658 Range m_range;
12659
12660 friend struct DataModel::Detail::Befriend<Depth>;
12661 };
12662
12663 using Descendants = std::tuple<
12673
12676
12696#ifndef NO_DOC
12697 template<
12698 typename... Args,
12699 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
12700 typename std::enable_if<
12701 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
12702 value,
12703 int>::type = 0>
12704#else
12705 template<typename... Args>
12706#endif
12707 explicit RegionOfInterest(Args &&...args)
12708 {
12709 using namespace Zivid::Detail::TypeTraits;
12710
12711 static_assert(
12712 AllArgsDecayedAreUnique<Args...>::value,
12713 "Found duplicate types among the arguments passed to RegionOfInterest(...). "
12714 "Types should be listed at most once.");
12715
12716 set(std::forward<Args>(args)...);
12717 }
12718
12737#ifndef NO_DOC
12738 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
12739#else
12740 template<typename... Args>
12741#endif
12742 void set(Args &&...args)
12743 {
12744 using namespace Zivid::Detail::TypeTraits;
12745
12746 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
12747 static_assert(
12748 AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
12749
12750 static_assert(
12751 AllArgsDecayedAreUnique<Args...>::value,
12752 "Found duplicate types among the arguments passed to set(...). "
12753 "Types should be listed at most once.");
12754
12755 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
12756 }
12757
12777#ifndef NO_DOC
12778 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
12779#else
12780 template<typename... Args>
12781#endif
12782 RegionOfInterest copyWith(Args &&...args) const
12783 {
12784 using namespace Zivid::Detail::TypeTraits;
12785
12786 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
12787 static_assert(
12788 AllArgsAreDescendantNodes::value,
12789 "All arguments passed to copyWith(...) must be descendant nodes.");
12790
12791 static_assert(
12792 AllArgsDecayedAreUnique<Args...>::value,
12793 "Found duplicate types among the arguments passed to copyWith(...). "
12794 "Types should be listed at most once.");
12795
12796 auto copy{ *this };
12797 copy.set(std::forward<Args>(args)...);
12798 return copy;
12799 }
12800
12802 const Box &box() const
12803 {
12804 return m_box;
12805 }
12806
12809 {
12810 return m_box;
12811 }
12812
12814 RegionOfInterest &set(const Box &value)
12815 {
12816 m_box = value;
12817 return *this;
12818 }
12819
12822 {
12823 m_box.set(value);
12824 return *this;
12825 }
12826
12829 {
12830 m_box.set(value);
12831 return *this;
12832 }
12833
12836 {
12837 m_box.set(value);
12838 return *this;
12839 }
12840
12843 {
12844 m_box.set(value);
12845 return *this;
12846 }
12847
12850 {
12851 m_box.set(value);
12852 return *this;
12853 }
12854
12856 const Depth &depth() const
12857 {
12858 return m_depth;
12859 }
12860
12863 {
12864 return m_depth;
12865 }
12866
12869 {
12870 m_depth = value;
12871 return *this;
12872 }
12873
12876 {
12877 m_depth.set(value);
12878 return *this;
12879 }
12880
12883 {
12884 m_depth.set(value);
12885 return *this;
12886 }
12887
12888 template<
12889 typename T,
12890 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box>::value, int>::type = 0>
12892 {
12893 return m_box;
12894 }
12895
12896 template<
12897 typename T,
12898 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::Enabled>::value, int>::type =
12899 0>
12901 {
12902 return m_box.get<Settings::RegionOfInterest::Box::Enabled>();
12903 }
12904
12905 template<
12906 typename T,
12907 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::Extents>::value, int>::type =
12908 0>
12910 {
12911 return m_box.get<Settings::RegionOfInterest::Box::Extents>();
12912 }
12913
12914 template<
12915 typename T,
12916 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointA>::value, int>::type = 0>
12918 {
12919 return m_box.get<Settings::RegionOfInterest::Box::PointA>();
12920 }
12921
12922 template<
12923 typename T,
12924 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointB>::value, int>::type = 0>
12926 {
12927 return m_box.get<Settings::RegionOfInterest::Box::PointB>();
12928 }
12929
12930 template<
12931 typename T,
12932 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointO>::value, int>::type = 0>
12934 {
12935 return m_box.get<Settings::RegionOfInterest::Box::PointO>();
12936 }
12937
12938 template<
12939 typename T,
12940 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth>::value, int>::type = 0>
12942 {
12943 return m_depth;
12944 }
12945
12946 template<
12947 typename T,
12948 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth::Enabled>::value, int>::type =
12949 0>
12951 {
12952 return m_depth.get<Settings::RegionOfInterest::Depth::Enabled>();
12953 }
12954
12955 template<
12956 typename T,
12957 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth::Range>::value, int>::type =
12958 0>
12960 {
12961 return m_depth.get<Settings::RegionOfInterest::Depth::Range>();
12962 }
12963
12964 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
12966 {
12967 return m_box;
12968 }
12969
12970 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
12972 {
12973 return m_depth;
12974 }
12975
12977 template<typename F>
12978 void forEach(const F &f) const
12979 {
12980 f(m_box);
12981 f(m_depth);
12982 }
12983
12985 template<typename F>
12986 void forEach(const F &f)
12987 {
12988 f(m_box);
12989 f(m_depth);
12990 }
12991
12993 bool operator==(const RegionOfInterest &other) const;
12994
12996 bool operator!=(const RegionOfInterest &other) const;
12997
12999 std::string toString() const;
13000
13002 friend std::ostream &operator<<(std::ostream &stream, const RegionOfInterest &value)
13003 {
13004 return stream << value.toString();
13005 }
13006
13007 private:
13008 void setFromString(const std::string &value);
13009
13010 void setFromString(const std::string &fullPath, const std::string &value);
13011
13012 std::string getString(const std::string &fullPath) const;
13013
13014 Box m_box;
13015 Depth m_depth;
13016
13017 friend struct DataModel::Detail::Befriend<RegionOfInterest>;
13018 };
13019
13020 using Descendants = std::tuple<
13080
13083
13085 explicit Settings(const std::string &fileName);
13086
13156#ifndef NO_DOC
13157 template<
13158 typename... Args,
13159 typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
13160 typename std::enable_if<
13161 Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
13162 int>::type = 0>
13163#else
13164 template<typename... Args>
13165#endif
13166 explicit Settings(Args &&...args)
13167 {
13168 using namespace Zivid::Detail::TypeTraits;
13169
13170 static_assert(
13171 AllArgsDecayedAreUnique<Args...>::value,
13172 "Found duplicate types among the arguments passed to Settings(...). "
13173 "Types should be listed at most once.");
13174
13175 set(std::forward<Args>(args)...);
13176 }
13177
13246#ifndef NO_DOC
13247 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
13248#else
13249 template<typename... Args>
13250#endif
13251 void set(Args &&...args)
13252 {
13253 using namespace Zivid::Detail::TypeTraits;
13254
13255 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
13256 static_assert(
13257 AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
13258
13259 static_assert(
13260 AllArgsDecayedAreUnique<Args...>::value,
13261 "Found duplicate types among the arguments passed to set(...). "
13262 "Types should be listed at most once.");
13263
13264 Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
13265 }
13266
13336#ifndef NO_DOC
13337 template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
13338#else
13339 template<typename... Args>
13340#endif
13341 Settings copyWith(Args &&...args) const
13342 {
13343 using namespace Zivid::Detail::TypeTraits;
13344
13345 using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
13346 static_assert(
13347 AllArgsAreDescendantNodes::value, "All arguments passed to copyWith(...) must be descendant nodes.");
13348
13349 static_assert(
13350 AllArgsDecayedAreUnique<Args...>::value,
13351 "Found duplicate types among the arguments passed to copyWith(...). "
13352 "Types should be listed at most once.");
13353
13354 auto copy{ *this };
13355 copy.set(std::forward<Args>(args)...);
13356 return copy;
13357 }
13358
13361 {
13362 return m_acquisitions;
13363 }
13364
13367 {
13368 return m_acquisitions;
13369 }
13370
13373 {
13374 m_acquisitions = value;
13375 return *this;
13376 }
13377
13380 {
13381 return m_diagnostics;
13382 }
13383
13386 {
13387 return m_diagnostics;
13388 }
13389
13391 Settings &set(const Diagnostics &value)
13392 {
13393 m_diagnostics = value;
13394 return *this;
13395 }
13396
13399 {
13400 m_diagnostics.set(value);
13401 return *this;
13402 }
13403
13406 {
13407 return m_experimental;
13408 }
13409
13412 {
13413 return m_experimental;
13414 }
13415
13418 {
13419 m_experimental = value;
13420 return *this;
13421 }
13422
13425 {
13426 m_experimental.set(value);
13427 return *this;
13428 }
13429
13431 const Processing &processing() const
13432 {
13433 return m_processing;
13434 }
13435
13438 {
13439 return m_processing;
13440 }
13441
13443 Settings &set(const Processing &value)
13444 {
13445 m_processing = value;
13446 return *this;
13447 }
13448
13451 {
13452 m_processing.set(value);
13453 return *this;
13454 }
13455
13458 {
13459 m_processing.set(value);
13460 return *this;
13461 }
13462
13465 {
13466 m_processing.set(value);
13467 return *this;
13468 }
13469
13472 {
13473 m_processing.set(value);
13474 return *this;
13475 }
13476
13479 {
13480 m_processing.set(value);
13481 return *this;
13482 }
13483
13486 {
13487 m_processing.set(value);
13488 return *this;
13489 }
13490
13493 {
13494 m_processing.set(value);
13495 return *this;
13496 }
13497
13500 {
13501 m_processing.set(value);
13502 return *this;
13503 }
13504
13507 {
13508 m_processing.set(value);
13509 return *this;
13510 }
13511
13514 {
13515 m_processing.set(value);
13516 return *this;
13517 }
13518
13521 {
13522 m_processing.set(value);
13523 return *this;
13524 }
13525
13528 {
13529 m_processing.set(value);
13530 return *this;
13531 }
13532
13535 {
13536 m_processing.set(value);
13537 return *this;
13538 }
13539
13542 {
13543 m_processing.set(value);
13544 return *this;
13545 }
13546
13549 {
13550 m_processing.set(value);
13551 return *this;
13552 }
13553
13556 {
13557 m_processing.set(value);
13558 return *this;
13559 }
13560
13563 {
13564 m_processing.set(value);
13565 return *this;
13566 }
13567
13570 {
13571 m_processing.set(value);
13572 return *this;
13573 }
13574
13577 {
13578 m_processing.set(value);
13579 return *this;
13580 }
13581
13584 {
13585 m_processing.set(value);
13586 return *this;
13587 }
13588
13591 {
13592 m_processing.set(value);
13593 return *this;
13594 }
13595
13598 {
13599 m_processing.set(value);
13600 return *this;
13601 }
13602
13605 {
13606 m_processing.set(value);
13607 return *this;
13608 }
13609
13612 {
13613 m_processing.set(value);
13614 return *this;
13615 }
13616
13619 {
13620 m_processing.set(value);
13621 return *this;
13622 }
13623
13626 {
13627 m_processing.set(value);
13628 return *this;
13629 }
13630
13633 {
13634 m_processing.set(value);
13635 return *this;
13636 }
13637
13640 {
13641 m_processing.set(value);
13642 return *this;
13643 }
13644
13647 {
13648 m_processing.set(value);
13649 return *this;
13650 }
13651
13654 {
13655 m_processing.set(value);
13656 return *this;
13657 }
13658
13661 {
13662 m_processing.set(value);
13663 return *this;
13664 }
13665
13668 {
13669 m_processing.set(value);
13670 return *this;
13671 }
13672
13675 {
13676 m_processing.set(value);
13677 return *this;
13678 }
13679
13682 {
13683 m_processing.set(value);
13684 return *this;
13685 }
13686
13689 {
13690 m_processing.set(value);
13691 return *this;
13692 }
13693
13696 {
13697 m_processing.set(value);
13698 return *this;
13699 }
13700
13703 {
13704 m_processing.set(value);
13705 return *this;
13706 }
13707
13710 {
13711 m_processing.set(value);
13712 return *this;
13713 }
13714
13717 {
13718 m_processing.set(value);
13719 return *this;
13720 }
13721
13724 {
13725 m_processing.set(value);
13726 return *this;
13727 }
13728
13731 {
13732 m_processing.set(value);
13733 return *this;
13734 }
13735
13738 {
13739 m_processing.set(value);
13740 return *this;
13741 }
13742
13745 {
13746 m_processing.set(value);
13747 return *this;
13748 }
13749
13752 {
13753 return m_regionOfInterest;
13754 }
13755
13758 {
13759 return m_regionOfInterest;
13760 }
13761
13764 {
13765 m_regionOfInterest = value;
13766 return *this;
13767 }
13768
13771 {
13772 m_regionOfInterest.set(value);
13773 return *this;
13774 }
13775
13778 {
13779 m_regionOfInterest.set(value);
13780 return *this;
13781 }
13782
13785 {
13786 m_regionOfInterest.set(value);
13787 return *this;
13788 }
13789
13792 {
13793 m_regionOfInterest.set(value);
13794 return *this;
13795 }
13796
13799 {
13800 m_regionOfInterest.set(value);
13801 return *this;
13802 }
13803
13806 {
13807 m_regionOfInterest.set(value);
13808 return *this;
13809 }
13810
13813 {
13814 m_regionOfInterest.set(value);
13815 return *this;
13816 }
13817
13820 {
13821 m_regionOfInterest.set(value);
13822 return *this;
13823 }
13824
13827 {
13828 m_regionOfInterest.set(value);
13829 return *this;
13830 }
13831
13832 template<typename T, typename std::enable_if<std::is_same<T, Settings::Acquisitions>::value, int>::type = 0>
13834 {
13835 return m_acquisitions;
13836 }
13837
13838 template<typename T, typename std::enable_if<std::is_same<T, Settings::Diagnostics>::value, int>::type = 0>
13840 {
13841 return m_diagnostics;
13842 }
13843
13844 template<
13845 typename T,
13846 typename std::enable_if<std::is_same<T, Settings::Diagnostics::Enabled>::value, int>::type = 0>
13848 {
13849 return m_diagnostics.get<Settings::Diagnostics::Enabled>();
13850 }
13851
13852 template<typename T, typename std::enable_if<std::is_same<T, Settings::Experimental>::value, int>::type = 0>
13854 {
13855 return m_experimental;
13856 }
13857
13858 template<
13859 typename T,
13860 typename std::enable_if<std::is_same<T, Settings::Experimental::Engine>::value, int>::type = 0>
13862 {
13863 return m_experimental.get<Settings::Experimental::Engine>();
13864 }
13865
13866 template<typename T, typename std::enable_if<std::is_same<T, Settings::Processing>::value, int>::type = 0>
13868 {
13869 return m_processing;
13870 }
13871
13872 template<
13873 typename T,
13874 typename std::enable_if<std::is_same<T, Settings::Processing::Color>::value, int>::type = 0>
13876 {
13877 return m_processing.get<Settings::Processing::Color>();
13878 }
13879
13880 template<
13881 typename T,
13882 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance>::value, int>::type = 0>
13884 {
13885 return m_processing.get<Settings::Processing::Color::Balance>();
13886 }
13887
13888 template<
13889 typename T,
13890 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Blue>::value, int>::type = 0>
13892 {
13893 return m_processing.get<Settings::Processing::Color::Balance::Blue>();
13894 }
13895
13896 template<
13897 typename T,
13898 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Green>::value, int>::type = 0>
13900 {
13901 return m_processing.get<Settings::Processing::Color::Balance::Green>();
13902 }
13903
13904 template<
13905 typename T,
13906 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Red>::value, int>::type = 0>
13908 {
13909 return m_processing.get<Settings::Processing::Color::Balance::Red>();
13910 }
13911
13912 template<
13913 typename T,
13914 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental>::value, int>::type = 0>
13916 {
13917 return m_processing.get<Settings::Processing::Color::Experimental>();
13918 }
13919
13920 template<
13921 typename T,
13922 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental::Mode>::value, int>::
13923 type = 0>
13925 {
13926 return m_processing.get<Settings::Processing::Color::Experimental::Mode>();
13927 }
13928
13929 template<
13930 typename T,
13931 typename std::enable_if<std::is_same<T, Settings::Processing::Color::Gamma>::value, int>::type = 0>
13933 {
13934 return m_processing.get<Settings::Processing::Color::Gamma>();
13935 }
13936
13937 template<
13938 typename T,
13939 typename std::enable_if<std::is_same<T, Settings::Processing::Filters>::value, int>::type = 0>
13941 {
13942 return m_processing.get<Settings::Processing::Filters>();
13943 }
13944
13945 template<
13946 typename T,
13947 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Cluster>::value, int>::type = 0>
13949 {
13950 return m_processing.get<Settings::Processing::Filters::Cluster>();
13951 }
13952
13953 template<
13954 typename T,
13955 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Cluster::Removal>::value, int>::
13956 type = 0>
13958 {
13960 }
13961
13962 template<
13963 typename T,
13964 typename std::enable_if<
13965 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::Enabled>::value,
13966 int>::type = 0>
13968 {
13970 }
13971
13972 template<
13973 typename T,
13974 typename std::enable_if<
13975 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>::value,
13976 int>::type = 0>
13978 {
13980 }
13981
13982 template<
13983 typename T,
13984 typename std::enable_if<
13985 std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MinArea>::value,
13986 int>::type = 0>
13988 {
13990 }
13991
13992 template<
13993 typename T,
13994 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Experimental>::value, int>::type = 0>
13996 {
13997 return m_processing.get<Settings::Processing::Filters::Experimental>();
13998 }
13999
14000 template<
14001 typename T,
14002 typename std::enable_if<
14003 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
14004 int>::type = 0>
14006 {
14008 }
14009
14010 template<
14011 typename T,
14012 typename std::enable_if<
14013 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::value,
14014 int>::type = 0>
14016 {
14018 }
14019
14020 template<
14021 typename T,
14022 typename std::enable_if<
14023 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>::
14024 value,
14025 int>::type = 0>
14027 {
14028 return m_processing
14030 }
14031
14032 template<
14033 typename T,
14034 typename std::enable_if<
14035 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>::
14036 value,
14037 int>::type = 0>
14039 {
14040 return m_processing
14042 }
14043
14044 template<
14045 typename T,
14046 typename std::enable_if<
14047 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::value,
14048 int>::type = 0>
14050 {
14052 }
14053
14054 template<
14055 typename T,
14056 typename std::enable_if<
14057 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>::
14058 value,
14059 int>::type = 0>
14061 {
14062 return m_processing
14064 }
14065
14066 template<
14067 typename T,
14068 typename std::enable_if<
14069 std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>::
14070 value,
14071 int>::type = 0>
14073 {
14074 return m_processing
14076 }
14077
14078 template<
14079 typename T,
14080 typename std::enable_if<
14081 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling>::value,
14082 int>::type = 0>
14084 {
14086 }
14087
14088 template<
14089 typename T,
14090 typename std::enable_if<
14091 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Enabled>::value,
14092 int>::type = 0>
14094 {
14096 }
14097
14098 template<
14099 typename T,
14100 typename std::enable_if<
14101 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>::value,
14102 int>::type = 0>
14104 {
14106 }
14107
14108 template<
14109 typename T,
14110 typename std::enable_if<
14111 std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Strictness>::value,
14112 int>::type = 0>
14114 {
14116 }
14117
14118 template<
14119 typename T,
14120 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise>::value, int>::type = 0>
14122 {
14123 return m_processing.get<Settings::Processing::Filters::Noise>();
14124 }
14125
14126 template<
14127 typename T,
14128 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Removal>::value, int>::type =
14129 0>
14131 {
14133 }
14134
14135 template<
14136 typename T,
14137 typename std::enable_if<
14138 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
14139 int>::type = 0>
14141 {
14143 }
14144
14145 template<
14146 typename T,
14147 typename std::enable_if<
14148 std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
14149 int>::type = 0>
14151 {
14153 }
14154
14155 template<
14156 typename T,
14157 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier>::value, int>::type = 0>
14159 {
14160 return m_processing.get<Settings::Processing::Filters::Outlier>();
14161 }
14162
14163 template<
14164 typename T,
14165 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier::Removal>::value, int>::
14166 type = 0>
14168 {
14170 }
14171
14172 template<
14173 typename T,
14174 typename std::enable_if<
14175 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
14176 int>::type = 0>
14178 {
14180 }
14181
14182 template<
14183 typename T,
14184 typename std::enable_if<
14185 std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
14186 int>::type = 0>
14188 {
14190 }
14191
14192 template<
14193 typename T,
14194 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection>::value, int>::type = 0>
14196 {
14197 return m_processing.get<Settings::Processing::Filters::Reflection>();
14198 }
14199
14200 template<
14201 typename T,
14202 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection::Removal>::value, int>::
14203 type = 0>
14205 {
14207 }
14208
14209 template<
14210 typename T,
14211 typename std::enable_if<
14212 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
14213 int>::type = 0>
14215 {
14217 }
14218
14219 template<
14220 typename T,
14221 typename std::enable_if<
14222 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental>::value,
14223 int>::type = 0>
14225 {
14227 }
14228
14229 template<
14230 typename T,
14231 typename std::enable_if<
14232 std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>::value,
14233 int>::type = 0>
14235 {
14237 }
14238
14239 template<
14240 typename T,
14241 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing>::value, int>::type = 0>
14243 {
14244 return m_processing.get<Settings::Processing::Filters::Smoothing>();
14245 }
14246
14247 template<
14248 typename T,
14249 typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian>::value, int>::
14250 type = 0>
14252 {
14254 }
14255
14256 template<
14257 typename T,
14258 typename std::enable_if<
14259 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
14260 int>::type = 0>
14262 {
14264 }
14265
14266 template<
14267 typename T,
14268 typename std::enable_if<
14269 std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
14270 int>::type = 0>
14272 {
14274 }
14275
14276 template<typename T, typename std::enable_if<std::is_same<T, Settings::RegionOfInterest>::value, int>::type = 0>
14278 {
14279 return m_regionOfInterest;
14280 }
14281
14282 template<
14283 typename T,
14284 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box>::value, int>::type = 0>
14286 {
14287 return m_regionOfInterest.get<Settings::RegionOfInterest::Box>();
14288 }
14289
14290 template<
14291 typename T,
14292 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::Enabled>::value, int>::type = 0>
14294 {
14295 return m_regionOfInterest.get<Settings::RegionOfInterest::Box::Enabled>();
14296 }
14297
14298 template<
14299 typename T,
14300 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::Extents>::value, int>::type = 0>
14302 {
14303 return m_regionOfInterest.get<Settings::RegionOfInterest::Box::Extents>();
14304 }
14305
14306 template<
14307 typename T,
14308 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointA>::value, int>::type = 0>
14310 {
14311 return m_regionOfInterest.get<Settings::RegionOfInterest::Box::PointA>();
14312 }
14313
14314 template<
14315 typename T,
14316 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointB>::value, int>::type = 0>
14318 {
14319 return m_regionOfInterest.get<Settings::RegionOfInterest::Box::PointB>();
14320 }
14321
14322 template<
14323 typename T,
14324 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointO>::value, int>::type = 0>
14326 {
14327 return m_regionOfInterest.get<Settings::RegionOfInterest::Box::PointO>();
14328 }
14329
14330 template<
14331 typename T,
14332 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth>::value, int>::type = 0>
14334 {
14335 return m_regionOfInterest.get<Settings::RegionOfInterest::Depth>();
14336 }
14337
14338 template<
14339 typename T,
14340 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth::Enabled>::value, int>::type = 0>
14342 {
14343 return m_regionOfInterest.get<Settings::RegionOfInterest::Depth::Enabled>();
14344 }
14345
14346 template<
14347 typename T,
14348 typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth::Range>::value, int>::type = 0>
14350 {
14351 return m_regionOfInterest.get<Settings::RegionOfInterest::Depth::Range>();
14352 }
14353
14354 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
14356 {
14357 return m_acquisitions;
14358 }
14359
14360 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
14362 {
14363 return m_diagnostics;
14364 }
14365
14366 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
14368 {
14369 return m_experimental;
14370 }
14371
14372 template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
14374 {
14375 return m_processing;
14376 }
14377
14378 template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
14380 {
14381 return m_regionOfInterest;
14382 }
14383
14385 template<typename F>
14386 void forEach(const F &f) const
14387 {
14388 f(m_acquisitions);
14389 f(m_diagnostics);
14390 f(m_experimental);
14391 f(m_processing);
14392 f(m_regionOfInterest);
14393 }
14394
14396 template<typename F>
14397 void forEach(const F &f)
14398 {
14399 f(m_acquisitions);
14400 f(m_diagnostics);
14401 f(m_experimental);
14402 f(m_processing);
14403 f(m_regionOfInterest);
14404 }
14405
14407 bool operator==(const Settings &other) const;
14408
14410 bool operator!=(const Settings &other) const;
14411
14413 std::string toString() const;
14414
14416 friend std::ostream &operator<<(std::ostream &stream, const Settings &value)
14417 {
14418 return stream << value.toString();
14419 }
14420
14422 void save(const std::string &fileName) const;
14423
14425 void load(const std::string &fileName);
14426
14427 private:
14428 void setFromString(const std::string &value);
14429
14430 void setFromString(const std::string &fullPath, const std::string &value);
14431
14432 std::string getString(const std::string &fullPath) const;
14433
14434 Acquisitions m_acquisitions;
14435 Diagnostics m_diagnostics;
14436 Experimental m_experimental;
14437 Processing m_processing;
14438 RegionOfInterest m_regionOfInterest;
14439
14440 friend struct DataModel::Detail::Befriend<Settings>;
14441 };
14442
14443#ifndef NO_DOC
14445 namespace Detail
14446 {
14447 ZIVID_CORE_EXPORT void save(const Settings &dataModel, std::ostream &ostream);
14448 ZIVID_CORE_EXPORT void load(Settings &dataModel, std::istream &istream);
14449 } // namespace Detail
14450#endif
14451
14452#ifndef NO_DOC
14453 template<>
14454 struct Settings::Version<17>
14455 {
14456 using Type = Settings;
14457 };
14458#endif
14459
14460} // namespace Zivid
14461
14462#ifdef _MSC_VER
14463# pragma warning(pop)
14464#endif
14465
14466#ifndef NO_DOC
14467# if !(defined(_MSC_VER) && (_MSC_VER <= 1900))
14468namespace std // NOLINT
14469{
14470
14471 template<>
14472 struct tuple_size<Zivid::Settings::Diagnostics> : integral_constant<size_t, 1>
14473 {};
14474
14475 template<size_t i>
14476 struct tuple_element<i, Zivid::Settings::Diagnostics>
14477 {
14478 static_assert(i < tuple_size<Zivid::Settings::Diagnostics>::value, "Index must be less than 1");
14479
14480 using type // NOLINT
14481 = decltype(declval<Zivid::Settings::Diagnostics>().get<i>());
14482 };
14483
14484 template<>
14485 struct tuple_size<Zivid::Settings::Experimental> : integral_constant<size_t, 1>
14486 {};
14487
14488 template<size_t i>
14489 struct tuple_element<i, Zivid::Settings::Experimental>
14490 {
14491 static_assert(i < tuple_size<Zivid::Settings::Experimental>::value, "Index must be less than 1");
14492
14493 using type // NOLINT
14494 = decltype(declval<Zivid::Settings::Experimental>().get<i>());
14495 };
14496
14497 template<>
14498 struct tuple_size<Zivid::Settings::Processing> : integral_constant<size_t, 2>
14499 {};
14500
14501 template<size_t i>
14502 struct tuple_element<i, Zivid::Settings::Processing>
14503 {
14504 static_assert(i < tuple_size<Zivid::Settings::Processing>::value, "Index must be less than 2");
14505
14506 using type // NOLINT
14507 = decltype(declval<Zivid::Settings::Processing>().get<i>());
14508 };
14509
14510 template<>
14511 struct tuple_size<Zivid::Settings::Processing::Color> : integral_constant<size_t, 3>
14512 {};
14513
14514 template<size_t i>
14515 struct tuple_element<i, Zivid::Settings::Processing::Color>
14516 {
14517 static_assert(i < tuple_size<Zivid::Settings::Processing::Color>::value, "Index must be less than 3");
14518
14519 using type // NOLINT
14520 = decltype(declval<Zivid::Settings::Processing::Color>().get<i>());
14521 };
14522
14523 template<>
14524 struct tuple_size<Zivid::Settings::Processing::Color::Balance> : integral_constant<size_t, 3>
14525 {};
14526
14527 template<size_t i>
14528 struct tuple_element<i, Zivid::Settings::Processing::Color::Balance>
14529 {
14530 static_assert(i < tuple_size<Zivid::Settings::Processing::Color::Balance>::value, "Index must be less than 3");
14531
14532 using type // NOLINT
14533 = decltype(declval<Zivid::Settings::Processing::Color::Balance>().get<i>());
14534 };
14535
14536 template<>
14537 struct tuple_size<Zivid::Settings::Processing::Color::Experimental> : integral_constant<size_t, 1>
14538 {};
14539
14540 template<size_t i>
14541 struct tuple_element<i, Zivid::Settings::Processing::Color::Experimental>
14542 {
14543 static_assert(
14544 i < tuple_size<Zivid::Settings::Processing::Color::Experimental>::value,
14545 "Index must be less than 1");
14546
14547 using type // NOLINT
14548 = decltype(declval<Zivid::Settings::Processing::Color::Experimental>().get<i>());
14549 };
14550
14551 template<>
14552 struct tuple_size<Zivid::Settings::Processing::Filters> : integral_constant<size_t, 6>
14553 {};
14554
14555 template<size_t i>
14556 struct tuple_element<i, Zivid::Settings::Processing::Filters>
14557 {
14558 static_assert(i < tuple_size<Zivid::Settings::Processing::Filters>::value, "Index must be less than 6");
14559
14560 using type // NOLINT
14561 = decltype(declval<Zivid::Settings::Processing::Filters>().get<i>());
14562 };
14563
14564 template<>
14565 struct tuple_size<Zivid::Settings::Processing::Filters::Cluster> : integral_constant<size_t, 1>
14566 {};
14567
14568 template<size_t i>
14569 struct tuple_element<i, Zivid::Settings::Processing::Filters::Cluster>
14570 {
14571 static_assert(
14572 i < tuple_size<Zivid::Settings::Processing::Filters::Cluster>::value,
14573 "Index must be less than 1");
14574
14575 using type // NOLINT
14576 = decltype(declval<Zivid::Settings::Processing::Filters::Cluster>().get<i>());
14577 };
14578
14579 template<>
14580 struct tuple_size<Zivid::Settings::Processing::Filters::Cluster::Removal> : integral_constant<size_t, 3>
14581 {};
14582
14583 template<size_t i>
14584 struct tuple_element<i, Zivid::Settings::Processing::Filters::Cluster::Removal>
14585 {
14586 static_assert(
14587 i < tuple_size<Zivid::Settings::Processing::Filters::Cluster::Removal>::value,
14588 "Index must be less than 3");
14589
14590 using type // NOLINT
14591 = decltype(declval<Zivid::Settings::Processing::Filters::Cluster::Removal>().get<i>());
14592 };
14593
14594 template<>
14595 struct tuple_size<Zivid::Settings::Processing::Filters::Experimental> : integral_constant<size_t, 2>
14596 {};
14597
14598 template<size_t i>
14599 struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental>
14600 {
14601 static_assert(
14602 i < tuple_size<Zivid::Settings::Processing::Filters::Experimental>::value,
14603 "Index must be less than 2");
14604
14605 using type // NOLINT
14606 = decltype(declval<Zivid::Settings::Processing::Filters::Experimental>().get<i>());
14607 };
14608
14609 template<>
14610 struct tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion>
14611 : integral_constant<size_t, 2>
14612 {};
14613
14614 template<size_t i>
14615 struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion>
14616 {
14617 static_assert(
14618 i < tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
14619 "Index must be less than 2");
14620
14621 using type // NOLINT
14622 = decltype(declval<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion>().get<i>());
14623 };
14624
14625 template<>
14626 struct tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>
14627 : integral_constant<size_t, 2>
14628 {};
14629
14630 template<size_t i>
14631 struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>
14632 {
14633 static_assert(
14634 i < tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::value,
14635 "Index must be less than 2");
14636
14637 using type // NOLINT
14638 = decltype(declval<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>()
14639 .get<i>());
14640 };
14641
14642 template<>
14643 struct tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>
14644 : integral_constant<size_t, 2>
14645 {};
14646
14647 template<size_t i>
14648 struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>
14649 {
14650 static_assert(
14651 i < tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::value,
14652 "Index must be less than 2");
14653
14654 using type // NOLINT
14655 = decltype(declval<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>()
14656 .get<i>());
14657 };
14658
14659 template<>
14660 struct tuple_size<Zivid::Settings::Processing::Filters::Experimental::HoleFilling> : integral_constant<size_t, 3>
14661 {};
14662
14663 template<size_t i>
14664 struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental::HoleFilling>
14665 {
14666 static_assert(
14667 i < tuple_size<Zivid::Settings::Processing::Filters::Experimental::HoleFilling>::value,
14668 "Index must be less than 3");
14669
14670 using type // NOLINT
14671 = decltype(declval<Zivid::Settings::Processing::Filters::Experimental::HoleFilling>().get<i>());
14672 };
14673
14674 template<>
14675 struct tuple_size<Zivid::Settings::Processing::Filters::Noise> : integral_constant<size_t, 1>
14676 {};
14677
14678 template<size_t i>
14679 struct tuple_element<i, Zivid::Settings::Processing::Filters::Noise>
14680 {
14681 static_assert(i < tuple_size<Zivid::Settings::Processing::Filters::Noise>::value, "Index must be less than 1");
14682
14683 using type // NOLINT
14684 = decltype(declval<Zivid::Settings::Processing::Filters::Noise>().get<i>());
14685 };
14686
14687 template<>
14688 struct tuple_size<Zivid::Settings::Processing::Filters::Noise::Removal> : integral_constant<size_t, 2>
14689 {};
14690
14691 template<size_t i>
14692 struct tuple_element<i, Zivid::Settings::Processing::Filters::Noise::Removal>
14693 {
14694 static_assert(
14695 i < tuple_size<Zivid::Settings::Processing::Filters::Noise::Removal>::value,
14696 "Index must be less than 2");
14697
14698 using type // NOLINT
14699 = decltype(declval<Zivid::Settings::Processing::Filters::Noise::Removal>().get<i>());
14700 };
14701
14702 template<>
14703 struct tuple_size<Zivid::Settings::Processing::Filters::Outlier> : integral_constant<size_t, 1>
14704 {};
14705
14706 template<size_t i>
14707 struct tuple_element<i, Zivid::Settings::Processing::Filters::Outlier>
14708 {
14709 static_assert(
14710 i < tuple_size<Zivid::Settings::Processing::Filters::Outlier>::value,
14711 "Index must be less than 1");
14712
14713 using type // NOLINT
14714 = decltype(declval<Zivid::Settings::Processing::Filters::Outlier>().get<i>());
14715 };
14716
14717 template<>
14718 struct tuple_size<Zivid::Settings::Processing::Filters::Outlier::Removal> : integral_constant<size_t, 2>
14719 {};
14720
14721 template<size_t i>
14722 struct tuple_element<i, Zivid::Settings::Processing::Filters::Outlier::Removal>
14723 {
14724 static_assert(
14725 i < tuple_size<Zivid::Settings::Processing::Filters::Outlier::Removal>::value,
14726 "Index must be less than 2");
14727
14728 using type // NOLINT
14729 = decltype(declval<Zivid::Settings::Processing::Filters::Outlier::Removal>().get<i>());
14730 };
14731
14732 template<>
14733 struct tuple_size<Zivid::Settings::Processing::Filters::Reflection> : integral_constant<size_t, 1>
14734 {};
14735
14736 template<size_t i>
14737 struct tuple_element<i, Zivid::Settings::Processing::Filters::Reflection>
14738 {
14739 static_assert(
14740 i < tuple_size<Zivid::Settings::Processing::Filters::Reflection>::value,
14741 "Index must be less than 1");
14742
14743 using type // NOLINT
14744 = decltype(declval<Zivid::Settings::Processing::Filters::Reflection>().get<i>());
14745 };
14746
14747 template<>
14748 struct tuple_size<Zivid::Settings::Processing::Filters::Reflection::Removal> : integral_constant<size_t, 2>
14749 {};
14750
14751 template<size_t i>
14752 struct tuple_element<i, Zivid::Settings::Processing::Filters::Reflection::Removal>
14753 {
14754 static_assert(
14755 i < tuple_size<Zivid::Settings::Processing::Filters::Reflection::Removal>::value,
14756 "Index must be less than 2");
14757
14758 using type // NOLINT
14759 = decltype(declval<Zivid::Settings::Processing::Filters::Reflection::Removal>().get<i>());
14760 };
14761
14762 template<>
14763 struct tuple_size<Zivid::Settings::Processing::Filters::Reflection::Removal::Experimental>
14764 : integral_constant<size_t, 1>
14765 {};
14766
14767 template<size_t i>
14768 struct tuple_element<i, Zivid::Settings::Processing::Filters::Reflection::Removal::Experimental>
14769 {
14770 static_assert(
14771 i < tuple_size<Zivid::Settings::Processing::Filters::Reflection::Removal::Experimental>::value,
14772 "Index must be less than 1");
14773
14774 using type // NOLINT
14775 = decltype(declval<Zivid::Settings::Processing::Filters::Reflection::Removal::Experimental>().get<i>());
14776 };
14777
14778 template<>
14779 struct tuple_size<Zivid::Settings::Processing::Filters::Smoothing> : integral_constant<size_t, 1>
14780 {};
14781
14782 template<size_t i>
14783 struct tuple_element<i, Zivid::Settings::Processing::Filters::Smoothing>
14784 {
14785 static_assert(
14786 i < tuple_size<Zivid::Settings::Processing::Filters::Smoothing>::value,
14787 "Index must be less than 1");
14788
14789 using type // NOLINT
14790 = decltype(declval<Zivid::Settings::Processing::Filters::Smoothing>().get<i>());
14791 };
14792
14793 template<>
14794 struct tuple_size<Zivid::Settings::Processing::Filters::Smoothing::Gaussian> : integral_constant<size_t, 2>
14795 {};
14796
14797 template<size_t i>
14798 struct tuple_element<i, Zivid::Settings::Processing::Filters::Smoothing::Gaussian>
14799 {
14800 static_assert(
14801 i < tuple_size<Zivid::Settings::Processing::Filters::Smoothing::Gaussian>::value,
14802 "Index must be less than 2");
14803
14804 using type // NOLINT
14805 = decltype(declval<Zivid::Settings::Processing::Filters::Smoothing::Gaussian>().get<i>());
14806 };
14807
14808 template<>
14809 struct tuple_size<Zivid::Settings::RegionOfInterest> : integral_constant<size_t, 2>
14810 {};
14811
14812 template<size_t i>
14813 struct tuple_element<i, Zivid::Settings::RegionOfInterest>
14814 {
14815 static_assert(i < tuple_size<Zivid::Settings::RegionOfInterest>::value, "Index must be less than 2");
14816
14817 using type // NOLINT
14818 = decltype(declval<Zivid::Settings::RegionOfInterest>().get<i>());
14819 };
14820
14821 template<>
14822 struct tuple_size<Zivid::Settings::RegionOfInterest::Box> : integral_constant<size_t, 5>
14823 {};
14824
14825 template<size_t i>
14826 struct tuple_element<i, Zivid::Settings::RegionOfInterest::Box>
14827 {
14828 static_assert(i < tuple_size<Zivid::Settings::RegionOfInterest::Box>::value, "Index must be less than 5");
14829
14830 using type // NOLINT
14831 = decltype(declval<Zivid::Settings::RegionOfInterest::Box>().get<i>());
14832 };
14833
14834 template<>
14835 struct tuple_size<Zivid::Settings::RegionOfInterest::Depth> : integral_constant<size_t, 2>
14836 {};
14837
14838 template<size_t i>
14839 struct tuple_element<i, Zivid::Settings::RegionOfInterest::Depth>
14840 {
14841 static_assert(i < tuple_size<Zivid::Settings::RegionOfInterest::Depth>::value, "Index must be less than 2");
14842
14843 using type // NOLINT
14844 = decltype(declval<Zivid::Settings::RegionOfInterest::Depth>().get<i>());
14845 };
14846
14847 template<>
14848 struct tuple_size<Zivid::Settings> : integral_constant<size_t, 5>
14849 {};
14850
14851 template<size_t i>
14852 struct tuple_element<i, Zivid::Settings>
14853 {
14854 static_assert(i < tuple_size<Zivid::Settings>::value, "Index must be less than 5");
14855
14856 using type // NOLINT
14857 = decltype(declval<Zivid::Settings>().get<i>());
14858 };
14859
14860} // namespace std
14861# endif
14862#endif
14863
14864// If we have access to the DataModel library, automatically include internal DataModel
14865// header. This header is necessary for serialization and deserialization.
14866#if defined(__has_include) && !defined(NO_DOC)
14867# if __has_include("Zivid/SettingsInternal.h") && __has_include("Zivid/DataModelNodeMetaData.h")
14868# include "Zivid/SettingsInternal.h"
14869# endif
14870#endif
#define ZIVID_CORE_EXPORT
Definition: CoreExport.h:101
Class describing a range of values for a given type T
Definition: Range.h:118
Aperture setting for the camera. Specified as an f-number (the ratio of lens focal length to the effe...
Definition: Settings.h:178
bool operator<(const Aperture &other) const
Comparison operator
Definition: Settings.h:241
friend std::ostream & operator<<(std::ostream &stream, const Aperture &value)
Operator to serialize the value to a stream
Definition: Settings.h:265
double value() const
Get the value
std::string toString() const
Get the value as string
bool operator<=(const Aperture &other) const
Comparison operator
Definition: Settings.h:253
bool operator>(const Aperture &other) const
Comparison operator
Definition: Settings.h:247
bool operator==(const Aperture &other) const
Comparison operator
Definition: Settings.h:229
bool operator>=(const Aperture &other) const
Comparison operator
Definition: Settings.h:259
bool operator!=(const Aperture &other) const
Comparison operator
Definition: Settings.h:235
Aperture()=default
Default constructor
constexpr Aperture(double value)
Constructor
Definition: Settings.h:209
double ValueType
The type of the underlying value
Definition: Settings.h:197
void reset()
Reset the node to unset state
static constexpr Range< double > validRange()
The range of valid values for Aperture
Definition: Settings.h:200
bool hasValue() const
Check if the value is set
Brightness controls the light output from the projector.
Definition: Settings.h:301
bool operator<=(const Brightness &other) const
Comparison operator
Definition: Settings.h:384
bool operator!=(const Brightness &other) const
Comparison operator
Definition: Settings.h:366
bool operator>=(const Brightness &other) const
Comparison operator
Definition: Settings.h:390
bool operator<(const Brightness &other) const
Comparison operator
Definition: Settings.h:372
bool operator>(const Brightness &other) const
Comparison operator
Definition: Settings.h:378
void reset()
Reset the node to unset state
static constexpr Range< double > validRange()
The range of valid values for Brightness
Definition: Settings.h:331
std::string toString() const
Get the value as string
double value() const
Get the value
friend std::ostream & operator<<(std::ostream &stream, const Brightness &value)
Operator to serialize the value to a stream
Definition: Settings.h:396
constexpr Brightness(double value)
Constructor
Definition: Settings.h:340
bool hasValue() const
Check if the value is set
Brightness()=default
Default constructor
double ValueType
The type of the underlying value
Definition: Settings.h:328
bool operator==(const Brightness &other) const
Comparison operator
Definition: Settings.h:360
Exposure time for each single image in the measurement. Affects frame rate.
Definition: Settings.h:422
bool operator>=(const ExposureTime &other) const
Comparison operator
Definition: Settings.h:501
bool operator<(const ExposureTime &other) const
Comparison operator
Definition: Settings.h:483
ExposureTime()=default
Default constructor
bool hasValue() const
Check if the value is set
void reset()
Reset the node to unset state
std::string toString() const
Get the value as string
bool operator>(const ExposureTime &other) const
Comparison operator
Definition: Settings.h:489
std::chrono::microseconds ValueType
The type of the underlying value
Definition: Settings.h:439
bool operator==(const ExposureTime &other) const
Comparison operator
Definition: Settings.h:471
bool operator!=(const ExposureTime &other) const
Comparison operator
Definition: Settings.h:477
std::chrono::microseconds value() const
Get the value
static constexpr Range< std::chrono::microseconds > validRange()
The range of valid values for ExposureTime
Definition: Settings.h:442
constexpr ExposureTime(std::chrono::microseconds value)
Constructor
Definition: Settings.h:451
friend std::ostream & operator<<(std::ostream &stream, const ExposureTime &value)
Operator to serialize the value to a stream
Definition: Settings.h:507
bool operator<=(const ExposureTime &other) const
Comparison operator
Definition: Settings.h:495
Analog gain in the camera
Definition: Settings.h:534
bool operator==(const Gain &other) const
Comparison operator
Definition: Settings.h:581
friend std::ostream & operator<<(std::ostream &stream, const Gain &value)
Operator to serialize the value to a stream
Definition: Settings.h:617
constexpr Gain(double value)
Constructor
Definition: Settings.h:561
bool operator>=(const Gain &other) const
Comparison operator
Definition: Settings.h:611
void reset()
Reset the node to unset state
bool operator<=(const Gain &other) const
Comparison operator
Definition: Settings.h:605
static constexpr Range< double > validRange()
The range of valid values for Gain
Definition: Settings.h:552
double value() const
Get the value
Gain()=default
Default constructor
bool hasValue() const
Check if the value is set
double ValueType
The type of the underlying value
Definition: Settings.h:549
std::string toString() const
Get the value as string
bool operator!=(const Gain &other) const
Comparison operator
Definition: Settings.h:587
bool operator>(const Gain &other) const
Comparison operator
Definition: Settings.h:599
bool operator<(const Gain &other) const
Comparison operator
Definition: Settings.h:593
Settings for a single acquisition
Definition: Settings.h:158
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:891
Acquisition & set(const Aperture &value)
Set Aperture
Definition: Settings.h:770
const Aperture & aperture() const
Get Aperture
Definition: Settings.h:758
Gain & gain()
Get Gain
Definition: Settings.h:821
const Settings::Acquisition::Aperture & get() const
Definition: Settings.h:836
Brightness & brightness()
Get Brightness
Definition: Settings.h:783
friend std::ostream & operator<<(std::ostream &stream, const Acquisition &value)
Operator to send the value as string to a stream
Definition: Settings.h:919
std::tuple< Settings::Acquisition::Aperture, Settings::Acquisition::Brightness, Settings::Acquisition::ExposureTime, Settings::Acquisition::Gain > Descendants
Definition: Settings.h:643
bool operator==(const Acquisition &other) const
Equality operator
const Settings::Acquisition::ExposureTime & get() const
Definition: Settings.h:852
bool operator!=(const Acquisition &other) const
Inequality operator
const ExposureTime & exposureTime() const
Get ExposureTime
Definition: Settings.h:796
Acquisition & set(const Brightness &value)
Set Brightness
Definition: Settings.h:789
Acquisition & set(const ExposureTime &value)
Set ExposureTime
Definition: Settings.h:808
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:703
const Brightness & brightness() const
Get Brightness
Definition: Settings.h:777
const Settings::Acquisition::Gain & get() const
Definition: Settings.h:860
Acquisition & set(const Gain &value)
Set Gain
Definition: Settings.h:827
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:738
Aperture & aperture()
Get Aperture
Definition: Settings.h:764
const Settings::Acquisition::Brightness & get() const
Definition: Settings.h:844
Acquisition(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:673
ExposureTime & exposureTime()
Get ExposureTime
Definition: Settings.h:802
const Gain & gain() const
Get Gain
Definition: Settings.h:815
Acquisition()
Default constructor
std::string toString() const
Get the value as string
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:901
List of Acquisition objects
Definition: Settings.h:943
bool operator!=(const Acquisitions &other) const
Comparison operator
Definition: Settings.h:1081
std::vector< Settings::Acquisition >::const_iterator ConstIterator
Constant iterator type for Acquisitions
Definition: Settings.h:1060
Iterator begin() noexcept
Returns an iterator to the first element of the list
const std::vector< Settings::Acquisition > & value() const
Get the value
std::string toString() const
Get the value as string
void forEach(const F &f) const
Run the given function on each element in the list
Definition: Settings.h:1042
std::vector< Settings::Acquisition >::iterator Iterator
Iterator type for Acquisitions
Definition: Settings.h:1051
const Settings::Acquisition & at(std::size_t pos) const
Returns a const reference to the element at position pos in the list
Acquisitions()=default
Default constructor
Acquisitions(std::initializer_list< Settings::Acquisition > value)
Constructor
Definition: Settings.h:975
friend std::ostream & operator<<(std::ostream &stream, const Acquisitions &value)
Operator to serialize the value to a stream
Definition: Settings.h:1087
void forEach(const F &f)
Run the given function on each element in the list
Definition: Settings.h:1032
Acquisitions(std::vector< Settings::Acquisition > value)
Constructor
Definition: Settings.h:970
std::vector< Settings::Acquisition > ValueType
The type of the underlying value
Definition: Settings.h:958
static constexpr Range< ValueType::size_type > validSize()
The valid sizes for Acquisitions
Definition: Settings.h:961
const Settings::Acquisition & operator[](std::size_t pos) const
Returns a const reference to the element at position pos in the list
Settings::Acquisition & at(std::size_t pos)
Returns a reference to the element at position pos in the list
std::size_t size() const noexcept
Get the size of the list
Settings::Acquisition & operator[](std::size_t pos)
Returns a reference to the element at position pos in the list
Enable diagnostics
Definition: Settings.h:1136
static const Enabled no
Off/disabled.
Definition: Settings.h:1153
bool hasValue() const
Check if the value is set
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:1156
void reset()
Reset the node to unset state
Enabled()=default
Default constructor
bool ValueType
The type of the underlying value
Definition: Settings.h:1151
static const Enabled yes
On/enabled.
Definition: Settings.h:1152
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:1185
bool value() const
Get the value
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:1197
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:1165
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:1191
std::string toString() const
Get the value as string
When Diagnostics is enabled, extra diagnostic information is recorded during capture....
Definition: Settings.h:1110
friend std::ostream & operator<<(std::ostream &stream, const Diagnostics &value)
Operator to send the value as string to a stream
Definition: Settings.h:1372
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:1350
std::tuple< Settings::Diagnostics::Enabled > Descendants
Definition: Settings.h:1210
std::string toString() const
Get the value as string
Diagnostics copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:1296
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:1357
Diagnostics()
Default constructor
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:1322
bool operator==(const Diagnostics &other) const
Equality operator
Diagnostics(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:1237
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:1264
const Settings::Diagnostics::Enabled & get() const
Definition: Settings.h:1337
bool operator!=(const Diagnostics &other) const
Inequality operator
Diagnostics & set(const Enabled &value)
Set Enabled
Definition: Settings.h:1328
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:1316
Set the Zivid Vision Engine to use.
Definition: Settings.h:1421
ValueType value() const
Get the value
static const Engine phase
phase
Definition: Settings.h:1449
bool hasValue() const
Check if the value is set
ValueType
The type of the underlying value
Definition: Settings.h:1445
friend std::ostream & operator<<(std::ostream &stream, const Engine &value)
Operator to serialize the value to a stream
Definition: Settings.h:1500
static std::set< ValueType > validValues()
All valid values of Engine
Definition: Settings.h:1453
std::string toString() const
Get the value as string
bool operator==(const Engine &other) const
Comparison operator
Definition: Settings.h:1488
Engine()=default
Default constructor
bool operator!=(const Engine &other) const
Comparison operator
Definition: Settings.h:1494
constexpr Engine(ValueType value)
Constructor
Definition: Settings.h:1462
friend std::ostream & operator<<(std::ostream &stream, const Engine::ValueType &value)
Operator to serialize ValueType to a stream
Definition: Settings.h:1482
static const Engine stripe
stripe
Definition: Settings.h:1450
void reset()
Reset the node to unset state
Experimental features. These settings may be changed, renamed, moved or deleted in the future.
Definition: Settings.h:1393
Engine & engine()
Get Engine
Definition: Settings.h:1635
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:1577
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:1609
std::string toString() const
Get the value as string
bool operator!=(const Experimental &other) const
Inequality operator
friend std::ostream & operator<<(std::ostream &stream, const Experimental &value)
Operator to send the value as string to a stream
Definition: Settings.h:1685
const Settings::Experimental::Engine & get() const
Definition: Settings.h:1650
std::tuple< Settings::Experimental::Engine > Descendants
Definition: Settings.h:1523
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:1663
bool operator==(const Experimental &other) const
Equality operator
Experimental(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:1550
Experimental()
Default constructor
Experimental & set(const Engine &value)
Set Engine
Definition: Settings.h:1641
const Engine & engine() const
Get Engine
Definition: Settings.h:1629
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:1670
Digital gain applied to blue channel
Definition: Settings.h:1762
friend std::ostream & operator<<(std::ostream &stream, const Blue &value)
Operator to serialize the value to a stream
Definition: Settings.h:1847
void reset()
Reset the node to unset state
bool operator==(const Blue &other) const
Comparison operator
Definition: Settings.h:1811
bool operator>=(const Blue &other) const
Comparison operator
Definition: Settings.h:1841
std::string toString() const
Get the value as string
bool operator<(const Blue &other) const
Comparison operator
Definition: Settings.h:1823
constexpr Blue(double value)
Constructor
Definition: Settings.h:1791
bool operator<=(const Blue &other) const
Comparison operator
Definition: Settings.h:1835
bool operator!=(const Blue &other) const
Comparison operator
Definition: Settings.h:1817
bool hasValue() const
Check if the value is set
double ValueType
The type of the underlying value
Definition: Settings.h:1779
bool operator>(const Blue &other) const
Comparison operator
Definition: Settings.h:1829
static constexpr Range< double > validRange()
The range of valid values for Blue
Definition: Settings.h:1782
Digital gain applied to green channel
Definition: Settings.h:1874
void reset()
Reset the node to unset state
bool operator>(const Green &other) const
Comparison operator
Definition: Settings.h:1941
bool hasValue() const
Check if the value is set
friend std::ostream & operator<<(std::ostream &stream, const Green &value)
Operator to serialize the value to a stream
Definition: Settings.h:1959
double ValueType
The type of the underlying value
Definition: Settings.h:1891
bool operator>=(const Green &other) const
Comparison operator
Definition: Settings.h:1953
constexpr Green(double value)
Constructor
Definition: Settings.h:1903
bool operator==(const Green &other) const
Comparison operator
Definition: Settings.h:1923
bool operator!=(const Green &other) const
Comparison operator
Definition: Settings.h:1929
std::string toString() const
Get the value as string
bool operator<(const Green &other) const
Comparison operator
Definition: Settings.h:1935
static constexpr Range< double > validRange()
The range of valid values for Green
Definition: Settings.h:1894
bool operator<=(const Green &other) const
Comparison operator
Definition: Settings.h:1947
Digital gain applied to red channel
Definition: Settings.h:1986
bool operator!=(const Red &other) const
Comparison operator
Definition: Settings.h:2041
constexpr Red(double value)
Constructor
Definition: Settings.h:2015
friend std::ostream & operator<<(std::ostream &stream, const Red &value)
Operator to serialize the value to a stream
Definition: Settings.h:2071
bool operator>=(const Red &other) const
Comparison operator
Definition: Settings.h:2065
double ValueType
The type of the underlying value
Definition: Settings.h:2003
static constexpr Range< double > validRange()
The range of valid values for Red
Definition: Settings.h:2006
bool operator==(const Red &other) const
Comparison operator
Definition: Settings.h:2035
bool operator<(const Red &other) const
Comparison operator
Definition: Settings.h:2047
void reset()
Reset the node to unset state
bool operator>(const Red &other) const
Comparison operator
Definition: Settings.h:2053
bool hasValue() const
Check if the value is set
bool operator<=(const Red &other) const
Comparison operator
Definition: Settings.h:2059
std::string toString() const
Get the value as string
Color balance settings
Definition: Settings.h:1744
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:2155
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:2317
bool operator!=(const Balance &other) const
Inequality operator
Balance & set(const Red &value)
Set Red
Definition: Settings.h:2262
Green & green()
Get Green
Definition: Settings.h:2237
std::string toString() const
Get the value as string
Balance(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:2126
Red & red()
Get Red
Definition: Settings.h:2256
bool operator==(const Balance &other) const
Equality operator
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:2191
Balance & set(const Blue &value)
Set Blue
Definition: Settings.h:2224
Blue & blue()
Get Blue
Definition: Settings.h:2218
const Red & red() const
Get Red
Definition: Settings.h:2250
std::tuple< Settings::Processing::Color::Balance::Blue, Settings::Processing::Color::Balance::Green, Settings::Processing::Color::Balance::Red > Descendants
Definition: Settings.h:2097
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:2326
const Settings::Processing::Color::Balance::Green & get() const
Definition: Settings.h:2283
const Settings::Processing::Color::Balance::Red & get() const
Definition: Settings.h:2292
Balance & set(const Green &value)
Set Green
Definition: Settings.h:2243
const Green & green() const
Get Green
Definition: Settings.h:2231
friend std::ostream & operator<<(std::ostream &stream, const Balance &value)
Operator to send the value as string to a stream
Definition: Settings.h:2343
const Settings::Processing::Color::Balance::Blue & get() const
Definition: Settings.h:2273
const Blue & blue() const
Get Blue
Definition: Settings.h:2212
This setting controls how the color image is computed.
Definition: Settings.h:2407
static const Mode toneMapping
toneMapping
Definition: Settings.h:2453
std::string toString() const
Get the value as string
static const Mode automatic
automatic
Definition: Settings.h:2451
friend std::ostream & operator<<(std::ostream &stream, const Mode &value)
Operator to serialize the value to a stream
Definition: Settings.h:2503
void reset()
Reset the node to unset state
static const Mode useFirstAcquisition
useFirstAcquisition
Definition: Settings.h:2452
bool operator!=(const Mode &other) const
Comparison operator
Definition: Settings.h:2497
bool operator==(const Mode &other) const
Comparison operator
Definition: Settings.h:2491
ValueType
The type of the underlying value
Definition: Settings.h:2446
bool hasValue() const
Check if the value is set
constexpr Mode(ValueType value)
Constructor
Definition: Settings.h:2465
static std::set< ValueType > validValues()
All valid values of Mode
Definition: Settings.h:2456
friend std::ostream & operator<<(std::ostream &stream, const Mode::ValueType &value)
Operator to serialize ValueType to a stream
Definition: Settings.h:2485
Experimental color settings. These may be renamed, moved or deleted in the future.
Definition: Settings.h:2366
std::tuple< Settings::Processing::Color::Experimental::Mode > Descendants
Definition: Settings.h:2528
bool operator!=(const Experimental &other) const
Inequality operator
friend std::ostream & operator<<(std::ostream &stream, const Experimental &value)
Operator to send the value as string to a stream
Definition: Settings.h:2695
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:2680
Experimental(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:2555
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:2582
std::string toString() const
Get the value as string
Experimental & set(const Mode &value)
Set Mode
Definition: Settings.h:2649
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:2673
bool operator==(const Experimental &other) const
Equality operator
Mode & mode()
Get Mode
Definition: Settings.h:2643
const Mode & mode() const
Get Mode
Definition: Settings.h:2637
const Settings::Processing::Color::Experimental::Mode & get() const
Definition: Settings.h:2660
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:2616
Gamma applied to the color values. Gamma less than 1 makes the colors brighter, while gamma greater t...
Definition: Settings.h:2718
friend std::ostream & operator<<(std::ostream &stream, const Gamma &value)
Operator to serialize the value to a stream
Definition: Settings.h:2805
double value() const
Get the value
bool operator>(const Gamma &other) const
Comparison operator
Definition: Settings.h:2787
void reset()
Reset the node to unset state
static constexpr Range< double > validRange()
The range of valid values for Gamma
Definition: Settings.h:2740
Gamma()=default
Default constructor
double ValueType
The type of the underlying value
Definition: Settings.h:2737
bool hasValue() const
Check if the value is set
bool operator>=(const Gamma &other) const
Comparison operator
Definition: Settings.h:2799
constexpr Gamma(double value)
Constructor
Definition: Settings.h:2749
bool operator!=(const Gamma &other) const
Comparison operator
Definition: Settings.h:2775
bool operator<(const Gamma &other) const
Comparison operator
Definition: Settings.h:2781
std::string toString() const
Get the value as string
bool operator==(const Gamma &other) const
Comparison operator
Definition: Settings.h:2769
bool operator<=(const Gamma &other) const
Comparison operator
Definition: Settings.h:2793
Color settings
Definition: Settings.h:1726
Color & set(const Gamma &value)
Set Gamma
Definition: Settings.h:3038
const Settings::Processing::Color::Gamma & get() const
Definition: Settings.h:3102
const Settings::Processing::Color::Balance::Red & get() const
Definition: Settings.h:3075
bool operator==(const Color &other) const
Equality operator
Color & set(const Experimental::Mode &value)
Set Experimental::Mode
Definition: Settings.h:3019
const Settings::Processing::Color::Balance::Green & get() const
Definition: Settings.h:3066
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:2900
Color & set(const Experimental &value)
Set Experimental
Definition: Settings.h:3012
Color & set(const Balance &value)
Set Balance
Definition: Settings.h:2972
friend std::ostream & operator<<(std::ostream &stream, const Color &value)
Operator to send the value as string to a stream
Definition: Settings.h:3153
const Balance & balance() const
Get Balance
Definition: Settings.h:2960
const Experimental & experimental() const
Get Experimental
Definition: Settings.h:3000
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:3136
const Settings::Processing::Color::Experimental & get() const
Definition: Settings.h:3084
Color & set(const Balance::Green &value)
Set Balance::Green
Definition: Settings.h:2986
Experimental & experimental()
Get Experimental
Definition: Settings.h:3006
std::string toString() const
Get the value as string
bool operator!=(const Color &other) const
Inequality operator
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::Mode, Settings::Processing::Color::Gamma > Descendants
Definition: Settings.h:2834
Color & set(const Balance::Blue &value)
Set Balance::Blue
Definition: Settings.h:2979
Gamma & gamma()
Get Gamma
Definition: Settings.h:3032
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:2939
const Settings::Processing::Color::Experimental::Mode & get() const
Definition: Settings.h:3094
Color & set(const Balance::Red &value)
Set Balance::Red
Definition: Settings.h:2993
const Gamma & gamma() const
Get Gamma
Definition: Settings.h:3026
Color(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:2867
const Settings::Processing::Color::Balance & get() const
Definition: Settings.h:3048
Balance & balance()
Get Balance
Definition: Settings.h:2966
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:3127
const Settings::Processing::Color::Balance::Blue & get() const
Definition: Settings.h:3057
bool ValueType
The type of the underlying value
Definition: Settings.h:3249
static const Enabled no
Off/disabled.
Definition: Settings.h:3251
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:3263
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:3254
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:3289
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:3295
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:3283
std::string toString() const
Get the value as string
static const Enabled yes
On/enabled.
Definition: Settings.h:3250
Maximum normalized distance between neighboring points that are still classified as belonging to the ...
Definition: Settings.h:3315
constexpr MaxNeighborDistance(double value)
Constructor
Definition: Settings.h:3349
bool operator!=(const MaxNeighborDistance &other) const
Comparison operator
Definition: Settings.h:3375
double ValueType
The type of the underlying value
Definition: Settings.h:3337
bool operator>=(const MaxNeighborDistance &other) const
Comparison operator
Definition: Settings.h:3399
bool operator<(const MaxNeighborDistance &other) const
Comparison operator
Definition: Settings.h:3381
static constexpr Range< double > validRange()
The range of valid values for MaxNeighborDistance
Definition: Settings.h:3340
bool operator<=(const MaxNeighborDistance &other) const
Comparison operator
Definition: Settings.h:3393
friend std::ostream & operator<<(std::ostream &stream, const MaxNeighborDistance &value)
Operator to serialize the value to a stream
Definition: Settings.h:3405
bool operator==(const MaxNeighborDistance &other) const
Comparison operator
Definition: Settings.h:3369
bool operator>(const MaxNeighborDistance &other) const
Comparison operator
Definition: Settings.h:3387
Clusters with area below this threshold are removed by the filter. The area is given in mm^2.
Definition: Settings.h:3434
bool operator>=(const MinArea &other) const
Comparison operator
Definition: Settings.h:3515
double ValueType
The type of the underlying value
Definition: Settings.h:3453
friend std::ostream & operator<<(std::ostream &stream, const MinArea &value)
Operator to serialize the value to a stream
Definition: Settings.h:3521
bool operator<(const MinArea &other) const
Comparison operator
Definition: Settings.h:3497
bool operator!=(const MinArea &other) const
Comparison operator
Definition: Settings.h:3491
bool operator<=(const MinArea &other) const
Comparison operator
Definition: Settings.h:3509
constexpr MinArea(double value)
Constructor
Definition: Settings.h:3465
std::string toString() const
Get the value as string
bool operator>(const MinArea &other) const
Comparison operator
Definition: Settings.h:3503
static constexpr Range< double > validRange()
The range of valid values for MinArea
Definition: Settings.h:3456
bool operator==(const MinArea &other) const
Comparison operator
Definition: Settings.h:3485
Removal(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:3576
friend std::ostream & operator<<(std::ostream &stream, const Removal &value)
Operator to send the value as string to a stream
Definition: Settings.h:3795
const MaxNeighborDistance & maxNeighborDistance() const
Get MaxNeighborDistance
Definition: Settings.h:3681
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:3662
const Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance & get() const
Definition: Settings.h:3734
std::string toString() const
Get the value as string
MinArea & minArea()
Get MinArea
Definition: Settings.h:3706
const MinArea & minArea() const
Get MinArea
Definition: Settings.h:3700
bool operator!=(const Removal &other) const
Inequality operator
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:3641
Removal & set(const MaxNeighborDistance &value)
Set MaxNeighborDistance
Definition: Settings.h:3693
const Settings::Processing::Filters::Cluster::Removal::MinArea & get() const
Definition: Settings.h:3744
Removal & set(const MinArea &value)
Set MinArea
Definition: Settings.h:3712
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:3769
const Settings::Processing::Filters::Cluster::Removal::Enabled & get() const
Definition: Settings.h:3723
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:3668
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:3605
bool operator==(const Removal &other) const
Equality operator
MaxNeighborDistance & maxNeighborDistance()
Get MaxNeighborDistance
Definition: Settings.h:3687
std::tuple< Settings::Processing::Filters::Cluster::Removal::Enabled, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance, Settings::Processing::Filters::Cluster::Removal::MinArea > Descendants
Definition: Settings.h:3547
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:3778
Removal & set(const Enabled &value)
Set Enabled
Definition: Settings.h:3674
Removes floating points and small isolated clusters from the point cloud.
Definition: Settings.h:3195
const Removal & removal() const
Get Removal
Definition: Settings.h:3936
Cluster(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:3848
const Settings::Processing::Filters::Cluster::Removal::MinArea & get() const
Definition: Settings.h:4011
const Settings::Processing::Filters::Cluster::Removal & get() const
Definition: Settings.h:3980
Cluster & set(const Removal::MaxNeighborDistance &value)
Set Removal::MaxNeighborDistance
Definition: Settings.h:3962
bool operator!=(const Cluster &other) const
Inequality operator
const Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance & get() const
Definition: Settings.h:4001
bool operator==(const Cluster &other) const
Equality operator
Cluster copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:3915
Removal & removal()
Get Removal
Definition: Settings.h:3942
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:4031
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:4024
Cluster & set(const Removal::Enabled &value)
Set Removal::Enabled
Definition: Settings.h:3955
Cluster & set(const Removal &value)
Set Removal
Definition: Settings.h:3948
Cluster & set(const Removal::MinArea &value)
Set Removal::MinArea
Definition: Settings.h:3969
const Settings::Processing::Filters::Cluster::Removal::Enabled & get() const
Definition: Settings.h:3990
std::tuple< Settings::Processing::Filters::Cluster::Removal, Settings::Processing::Filters::Cluster::Removal::Enabled, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance, Settings::Processing::Filters::Cluster::Removal::MinArea > Descendants
Definition: Settings.h:3818
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:3878
std::string toString() const
Get the value as string
friend std::ostream & operator<<(std::ostream &stream, const Cluster &value)
Operator to send the value as string to a stream
Definition: Settings.h:4046
bool ValueType
The type of the underlying value
Definition: Settings.h:4152
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:4157
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:4166
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:4198
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:4186
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:4192
Higher values gives more correction.
Definition: Settings.h:4215
double ValueType
The type of the underlying value
Definition: Settings.h:4234
bool operator>(const Strength &other) const
Comparison operator
Definition: Settings.h:4284
bool operator!=(const Strength &other) const
Comparison operator
Definition: Settings.h:4272
constexpr Strength(double value)
Constructor
Definition: Settings.h:4246
static constexpr Range< double > validRange()
The range of valid values for Strength
Definition: Settings.h:4237
bool operator<=(const Strength &other) const
Comparison operator
Definition: Settings.h:4290
bool operator>=(const Strength &other) const
Comparison operator
Definition: Settings.h:4296
friend std::ostream & operator<<(std::ostream &stream, const Strength &value)
Operator to serialize the value to a stream
Definition: Settings.h:4302
bool operator<(const Strength &other) const
Comparison operator
Definition: Settings.h:4278
bool operator==(const Strength &other) const
Comparison operator
Definition: Settings.h:4266
bool operator==(const Correction &other) const
Equality operator
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:4522
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:4439
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength & get() const
Definition: Settings.h:4500
std::tuple< Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength > Descendants
Definition: Settings.h:4327
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:4418
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled & get() const
Definition: Settings.h:4485
bool operator!=(const Correction &other) const
Inequality operator
friend std::ostream & operator<<(std::ostream &stream, const Correction &value)
Operator to send the value as string to a stream
Definition: Settings.h:4546
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:4383
Correction & set(const Enabled &value)
Set Enabled
Definition: Settings.h:4451
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:4530
Correction & set(const Strength &value)
Set Strength
Definition: Settings.h:4470
const Strength & strength() const
Get Strength
Definition: Settings.h:4458
Correction(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:4355
static const Enabled yes
On/enabled.
Definition: Settings.h:4606
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:4619
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:4645
bool ValueType
The type of the underlying value
Definition: Settings.h:4605
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:4610
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:4651
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:4639
static const Enabled no
Off/disabled.
Definition: Settings.h:4607
Higher values remove more points.
Definition: Settings.h:4668
bool operator<=(const Threshold &other) const
Comparison operator
Definition: Settings.h:4743
constexpr Threshold(double value)
Constructor
Definition: Settings.h:4699
bool operator!=(const Threshold &other) const
Comparison operator
Definition: Settings.h:4725
bool operator<(const Threshold &other) const
Comparison operator
Definition: Settings.h:4731
static constexpr Range< double > validRange()
The range of valid values for Threshold
Definition: Settings.h:4690
bool operator==(const Threshold &other) const
Comparison operator
Definition: Settings.h:4719
bool operator>=(const Threshold &other) const
Comparison operator
Definition: Settings.h:4749
bool operator>(const Threshold &other) const
Comparison operator
Definition: Settings.h:4737
friend std::ostream & operator<<(std::ostream &stream, const Threshold &value)
Operator to serialize the value to a stream
Definition: Settings.h:4755
double ValueType
The type of the underlying value
Definition: Settings.h:4687
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:4973
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:4836
friend std::ostream & operator<<(std::ostream &stream, const Removal &value)
Operator to send the value as string to a stream
Definition: Settings.h:4997
const Threshold & threshold() const
Get Threshold
Definition: Settings.h:4911
Removal & set(const Threshold &value)
Set Threshold
Definition: Settings.h:4923
Removal(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:4808
bool operator!=(const Removal &other) const
Inequality operator
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:4871
Threshold & threshold()
Get Threshold
Definition: Settings.h:4917
Removal & set(const Enabled &value)
Set Enabled
Definition: Settings.h:4904
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled & get() const
Definition: Settings.h:4938
std::tuple< Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold > Descendants
Definition: Settings.h:4780
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:4892
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold & get() const
Definition: Settings.h:4952
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:4981
Corrects artifacts that appear when imaging scenes with large texture gradients or high contrast....
Definition: Settings.h:4091
ContrastDistortion & set(const Removal::Enabled &value)
Set Removal::Enabled
Definition: Settings.h:5197
ContrastDistortion & set(const Correction::Enabled &value)
Set Correction::Enabled
Definition: Settings.h:5164
ContrastDistortion & set(const Correction &value)
Set Correction
Definition: Settings.h:5157
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:5308
bool operator!=(const ContrastDistortion &other) const
Inequality operator
friend std::ostream & operator<<(std::ostream &stream, const ContrastDistortion &value)
Operator to send the value as string to a stream
Definition: Settings.h:5332
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:5124
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:5021
ContrastDistortion & set(const Correction::Strength &value)
Set Correction::Strength
Definition: Settings.h:5171
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:5085
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:5316
ContrastDistortion & set(const Removal &value)
Set Removal
Definition: Settings.h:5190
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold & get() const
Definition: Settings.h:5287
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal & get() const
Definition: Settings.h:5259
const Removal & removal() const
Get Removal
Definition: Settings.h:5178
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled & get() const
Definition: Settings.h:5231
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction & get() const
Definition: Settings.h:5217
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength & get() const
Definition: Settings.h:5246
Removal & removal()
Get Removal
Definition: Settings.h:5184
bool operator==(const ContrastDistortion &other) const
Equality operator
ContrastDistortion & set(const Removal::Threshold &value)
Set Removal::Threshold
Definition: Settings.h:5204
const Correction & correction() const
Get Correction
Definition: Settings.h:5145
ContrastDistortion(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:5053
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled & get() const
Definition: Settings.h:5272
Correction & correction()
Get Correction
Definition: Settings.h:5151
static const Enabled no
Off/disabled.
Definition: Settings.h:5393
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:5425
static const Enabled yes
On/enabled.
Definition: Settings.h:5392
bool ValueType
The type of the underlying value
Definition: Settings.h:5391
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:5396
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:5431
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:5437
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:5405
Relative diameter of holes to fill. Increasing this will fill more points, but require more computati...
Definition: Settings.h:5457
bool operator>=(const HoleSize &other) const
Comparison operator
Definition: Settings.h:5539
bool operator<=(const HoleSize &other) const
Comparison operator
Definition: Settings.h:5533
double ValueType
The type of the underlying value
Definition: Settings.h:5477
friend std::ostream & operator<<(std::ostream &stream, const HoleSize &value)
Operator to serialize the value to a stream
Definition: Settings.h:5545
bool operator!=(const HoleSize &other) const
Comparison operator
Definition: Settings.h:5515
bool operator>(const HoleSize &other) const
Comparison operator
Definition: Settings.h:5527
constexpr HoleSize(double value)
Constructor
Definition: Settings.h:5489
static constexpr Range< double > validRange()
The range of valid values for HoleSize
Definition: Settings.h:5480
bool operator==(const HoleSize &other) const
Comparison operator
Definition: Settings.h:5509
bool operator<(const HoleSize &other) const
Comparison operator
Definition: Settings.h:5521
Level of strictness when considering if a point should be filled. A higher level of strictness requir...
Definition: Settings.h:5576
bool operator==(const Strictness &other) const
Comparison operator
Definition: Settings.h:5631
bool operator<(const Strictness &other) const
Comparison operator
Definition: Settings.h:5643
bool operator>(const Strictness &other) const
Comparison operator
Definition: Settings.h:5649
bool operator<=(const Strictness &other) const
Comparison operator
Definition: Settings.h:5655
constexpr Strictness(int32_t value)
Constructor
Definition: Settings.h:5611
bool operator!=(const Strictness &other) const
Comparison operator
Definition: Settings.h:5637
static constexpr Range< int32_t > validRange()
The range of valid values for Strictness
Definition: Settings.h:5602
int32_t ValueType
The type of the underlying value
Definition: Settings.h:5599
friend std::ostream & operator<<(std::ostream &stream, const Strictness &value)
Operator to serialize the value to a stream
Definition: Settings.h:5667
bool operator>=(const Strictness &other) const
Comparison operator
Definition: Settings.h:5661
Fills missing points considering a circular neighborhood.
Definition: Settings.h:5355
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:5917
const Strictness & strictness() const
Get Strictness
Definition: Settings.h:5846
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:5926
Strictness & strictness()
Get Strictness
Definition: Settings.h:5852
HoleFilling copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:5787
HoleSize & holeSize()
Get HoleSize
Definition: Settings.h:5833
bool operator==(const HoleFilling &other) const
Equality operator
std::tuple< Settings::Processing::Filters::Experimental::HoleFilling::Enabled, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize, Settings::Processing::Filters::Experimental::HoleFilling::Strictness > Descendants
Definition: Settings.h:5693
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:5808
HoleFilling & set(const Strictness &value)
Set Strictness
Definition: Settings.h:5858
const Settings::Processing::Filters::Experimental::HoleFilling::Strictness & get() const
Definition: Settings.h:5892
const Settings::Processing::Filters::Experimental::HoleFilling::Enabled & get() const
Definition: Settings.h:5870
const HoleSize & holeSize() const
Get HoleSize
Definition: Settings.h:5827
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:5751
const Settings::Processing::Filters::Experimental::HoleFilling::HoleSize & get() const
Definition: Settings.h:5881
HoleFilling & set(const Enabled &value)
Set Enabled
Definition: Settings.h:5820
bool operator!=(const HoleFilling &other) const
Inequality operator
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:5814
HoleFilling(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:5722
std::string toString() const
Get the value as string
friend std::ostream & operator<<(std::ostream &stream, const HoleFilling &value)
Operator to send the value as string to a stream
Definition: Settings.h:5943
HoleFilling & set(const HoleSize &value)
Set HoleSize
Definition: Settings.h:5839
Experimental filters. These may be renamed, moved or deleted in the future.
Definition: Settings.h:4067
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:6370
ContrastDistortion & contrastDistortion()
Get ContrastDistortion
Definition: Settings.h:6118
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal & get() const
Definition: Settings.h:6271
const HoleFilling & holeFilling() const
Get HoleFilling
Definition: Settings.h:6173
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:6091
Experimental(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:6010
Experimental & set(const ContrastDistortion &value)
Set ContrastDistortion
Definition: Settings.h:6124
Experimental & set(const ContrastDistortion::Removal::Threshold &value)
Set ContrastDistortion::Removal::Threshold
Definition: Settings.h:6166
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:6047
const Settings::Processing::Filters::Experimental::HoleFilling::Enabled & get() const
Definition: Settings.h:6321
Experimental & set(const ContrastDistortion::Correction::Strength &value)
Set ContrastDistortion::Correction::Strength
Definition: Settings.h:6145
Experimental & set(const HoleFilling::HoleSize &value)
Set HoleFilling::HoleSize
Definition: Settings.h:6199
Experimental & set(const HoleFilling::Strictness &value)
Set HoleFilling::Strictness
Definition: Settings.h:6206
friend std::ostream & operator<<(std::ostream &stream, const Experimental &value)
Operator to send the value as string to a stream
Definition: Settings.h:6386
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, Settings::Processing::Filters::Experimental::HoleFilling, Settings::Processing::Filters::Experimental::HoleFilling::Enabled, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize, Settings::Processing::Filters::Experimental::HoleFilling::Strictness > Descendants
Definition: Settings.h:5973
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength & get() const
Definition: Settings.h:6258
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:6362
const Settings::Processing::Filters::Experimental::HoleFilling::Strictness & get() const
Definition: Settings.h:6342
const Settings::Processing::Filters::Experimental::HoleFilling::HoleSize & get() const
Definition: Settings.h:6331
Experimental & set(const ContrastDistortion::Removal &value)
Set ContrastDistortion::Removal
Definition: Settings.h:6152
const Settings::Processing::Filters::Experimental::ContrastDistortion & get() const
Definition: Settings.h:6217
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction & get() const
Definition: Settings.h:6229
bool operator!=(const Experimental &other) const
Inequality operator
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold & get() const
Definition: Settings.h:6299
Experimental & set(const ContrastDistortion::Correction::Enabled &value)
Set ContrastDistortion::Correction::Enabled
Definition: Settings.h:6138
Experimental & set(const HoleFilling::Enabled &value)
Set HoleFilling::Enabled
Definition: Settings.h:6192
const ContrastDistortion & contrastDistortion() const
Get ContrastDistortion
Definition: Settings.h:6112
std::string toString() const
Get the value as string
bool operator==(const Experimental &other) const
Equality operator
Experimental & set(const HoleFilling &value)
Set HoleFilling
Definition: Settings.h:6185
const Settings::Processing::Filters::Experimental::HoleFilling & get() const
Definition: Settings.h:6311
Experimental & set(const ContrastDistortion::Correction &value)
Set ContrastDistortion::Correction
Definition: Settings.h:6131
Experimental & set(const ContrastDistortion::Removal::Enabled &value)
Set ContrastDistortion::Removal::Enabled
Definition: Settings.h:6159
HoleFilling & holeFilling()
Get HoleFilling
Definition: Settings.h:6179
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled & get() const
Definition: Settings.h:6243
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled & get() const
Definition: Settings.h:6285
Enable or disable the SNR filter
Definition: Settings.h:6448
static const Enabled yes
On/enabled.
Definition: Settings.h:6466
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:6505
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:6499
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:6470
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:6479
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:6511
static const Enabled no
Off/disabled.
Definition: Settings.h:6467
bool ValueType
The type of the underlying value
Definition: Settings.h:6465
std::string toString() const
Get the value as string
Discard points with signal-to-noise ratio (SNR) below the given value
Definition: Settings.h:6528
bool operator>=(const Threshold &other) const
Comparison operator
Definition: Settings.h:6607
constexpr Threshold(double value)
Constructor
Definition: Settings.h:6557
bool operator==(const Threshold &other) const
Comparison operator
Definition: Settings.h:6577
bool operator<=(const Threshold &other) const
Comparison operator
Definition: Settings.h:6601
static constexpr Range< double > validRange()
The range of valid values for Threshold
Definition: Settings.h:6548
friend std::ostream & operator<<(std::ostream &stream, const Threshold &value)
Operator to serialize the value to a stream
Definition: Settings.h:6613
bool operator>(const Threshold &other) const
Comparison operator
Definition: Settings.h:6595
bool operator<(const Threshold &other) const
Comparison operator
Definition: Settings.h:6589
std::string toString() const
Get the value as string
double ValueType
The type of the underlying value
Definition: Settings.h:6545
bool operator!=(const Threshold &other) const
Comparison operator
Definition: Settings.h:6583
Discard points with signal-to-noise ratio (SNR) values below a threshold
Definition: Settings.h:6428
Removal(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:6666
friend std::ostream & operator<<(std::ostream &stream, const Removal &value)
Operator to send the value as string to a stream
Definition: Settings.h:6845
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:6750
const Threshold & threshold() const
Get Threshold
Definition: Settings.h:6769
std::tuple< Settings::Processing::Filters::Noise::Removal::Enabled, Settings::Processing::Filters::Noise::Removal::Threshold > Descendants
Definition: Settings.h:6638
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:6829
Removal & set(const Enabled &value)
Set Enabled
Definition: Settings.h:6762
Removal & set(const Threshold &value)
Set Threshold
Definition: Settings.h:6781
bool operator==(const Removal &other) const
Equality operator
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:6694
bool operator!=(const Removal &other) const
Inequality operator
const Settings::Processing::Filters::Noise::Removal::Threshold & get() const
Definition: Settings.h:6802
Threshold & threshold()
Get Threshold
Definition: Settings.h:6775
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
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:6729
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:6756
std::string toString() const
Get the value as string
const Settings::Processing::Filters::Noise::Removal::Enabled & get() const
Definition: Settings.h:6792
Contains a filter that removes points with low signal-to-noise ratio (SNR)
Definition: Settings.h:6408
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:7051
std::string toString() const
Get the value as string
Removal & removal()
Get Removal
Definition: Settings.h:6987
Noise(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:6895
Noise & set(const Removal::Threshold &value)
Set Removal::Threshold
Definition: Settings.h:7007
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:6960
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:7058
const Settings::Processing::Filters::Noise::Removal::Threshold & get() const
Definition: Settings.h:7038
std::tuple< Settings::Processing::Filters::Noise::Removal, Settings::Processing::Filters::Noise::Removal::Enabled, Settings::Processing::Filters::Noise::Removal::Threshold > Descendants
Definition: Settings.h:6866
Noise & set(const Removal::Enabled &value)
Set Removal::Enabled
Definition: Settings.h:7000
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:6924
bool operator!=(const Noise &other) const
Inequality operator
friend std::ostream & operator<<(std::ostream &stream, const Noise &value)
Operator to send the value as string to a stream
Definition: Settings.h:7073
const Removal & removal() const
Get Removal
Definition: Settings.h:6981
const Settings::Processing::Filters::Noise::Removal::Enabled & get() const
Definition: Settings.h:7028
bool operator==(const Noise &other) const
Equality operator
const Settings::Processing::Filters::Noise::Removal & get() const
Definition: Settings.h:7018
Noise & set(const Removal &value)
Set Removal
Definition: Settings.h:6993
Enable or disable the outlier filter
Definition: Settings.h:7134
bool ValueType
The type of the underlying value
Definition: Settings.h:7151
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:7191
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:7165
static const Enabled no
Off/disabled.
Definition: Settings.h:7153
std::string toString() const
Get the value as string
static const Enabled yes
On/enabled.
Definition: Settings.h:7152
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:7197
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:7156
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:7185
Discard point if Euclidean distance to neighboring points is above the given value
Definition: Settings.h:7214
static constexpr Range< double > validRange()
The range of valid values for Threshold
Definition: Settings.h:7234
constexpr Threshold(double value)
Constructor
Definition: Settings.h:7243
bool operator<(const Threshold &other) const
Comparison operator
Definition: Settings.h:7275
bool operator==(const Threshold &other) const
Comparison operator
Definition: Settings.h:7263
bool operator>=(const Threshold &other) const
Comparison operator
Definition: Settings.h:7293
bool operator!=(const Threshold &other) const
Comparison operator
Definition: Settings.h:7269
friend std::ostream & operator<<(std::ostream &stream, const Threshold &value)
Operator to serialize the value to a stream
Definition: Settings.h:7299
bool operator<=(const Threshold &other) const
Comparison operator
Definition: Settings.h:7287
bool operator>(const Threshold &other) const
Comparison operator
Definition: Settings.h:7281
std::string toString() const
Get the value as string
double ValueType
The type of the underlying value
Definition: Settings.h:7231
Discard point if Euclidean distance to neighboring points is above a threshold
Definition: Settings.h:7114
bool operator!=(const Removal &other) const
Inequality operator
friend std::ostream & operator<<(std::ostream &stream, const Removal &value)
Operator to send the value as string to a stream
Definition: Settings.h:7531
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:7436
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:7415
Removal & set(const Enabled &value)
Set Enabled
Definition: Settings.h:7448
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:7442
Removal & set(const Threshold &value)
Set Threshold
Definition: Settings.h:7467
const Settings::Processing::Filters::Outlier::Removal::Enabled & get() const
Definition: Settings.h:7478
Removal(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:7352
const Settings::Processing::Filters::Outlier::Removal::Threshold & get() const
Definition: Settings.h:7488
std::tuple< Settings::Processing::Filters::Outlier::Removal::Enabled, Settings::Processing::Filters::Outlier::Removal::Threshold > Descendants
Definition: Settings.h:7324
const Threshold & threshold() const
Get Threshold
Definition: Settings.h:7455
Threshold & threshold()
Get Threshold
Definition: Settings.h:7461
std::string toString() const
Get the value as string
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:7507
bool operator==(const Removal &other) const
Equality operator
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:7380
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:7515
Contains a filter that removes points with large Euclidean distance to neighboring points
Definition: Settings.h:7094
const Removal & removal() const
Get Removal
Definition: Settings.h:7667
Outlier(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:7581
Outlier & set(const Removal &value)
Set Removal
Definition: Settings.h:7679
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:7744
std::string toString() const
Get the value as string
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:7737
bool operator!=(const Outlier &other) const
Inequality operator
Outlier & set(const Removal::Threshold &value)
Set Removal::Threshold
Definition: Settings.h:7693
Outlier & set(const Removal::Enabled &value)
Set Removal::Enabled
Definition: Settings.h:7686
Removal & removal()
Get Removal
Definition: Settings.h:7673
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:7646
friend std::ostream & operator<<(std::ostream &stream, const Outlier &value)
Operator to send the value as string to a stream
Definition: Settings.h:7759
bool operator==(const Outlier &other) const
Equality operator
const Settings::Processing::Filters::Outlier::Removal::Threshold & get() const
Definition: Settings.h:7724
const Settings::Processing::Filters::Outlier::Removal & get() const
Definition: Settings.h:7704
const Settings::Processing::Filters::Outlier::Removal::Enabled & get() const
Definition: Settings.h:7714
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:7610
std::tuple< Settings::Processing::Filters::Outlier::Removal, Settings::Processing::Filters::Outlier::Removal::Enabled, Settings::Processing::Filters::Outlier::Removal::Threshold > Descendants
Definition: Settings.h:7552
Enable or disable the reflection filter. Note that this filter is computationally intensive and may a...
Definition: Settings.h:7820
bool ValueType
The type of the underlying value
Definition: Settings.h:7837
static const Enabled yes
On/enabled.
Definition: Settings.h:7838
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:7877
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:7851
std::string toString() const
Get the value as string
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:7883
static const Enabled no
Off/disabled.
Definition: Settings.h:7839
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:7871
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:7842
The reflection filter has two modes: Local and Global. Local mode preserves more 3D data on thinner o...
Definition: Settings.h:7927
friend std::ostream & operator<<(std::ostream &stream, const Mode &value)
Operator to serialize the value to a stream
Definition: Settings.h:8009
static const Mode global
global
Definition: Settings.h:7958
constexpr Mode(ValueType value)
Constructor
Definition: Settings.h:7971
bool operator==(const Mode &other) const
Comparison operator
Definition: Settings.h:7997
bool operator!=(const Mode &other) const
Comparison operator
Definition: Settings.h:8003
ValueType
The type of the underlying value
Definition: Settings.h:7954
static std::set< ValueType > validValues()
All valid values of Mode
Definition: Settings.h:7962
friend std::ostream & operator<<(std::ostream &stream, const Mode::ValueType &value)
Operator to serialize ValueType to a stream
Definition: Settings.h:7991
Experimental reflection filter related settings
Definition: Settings.h:7900
Experimental(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:8062
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:8189
bool operator!=(const Experimental &other) const
Inequality operator
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:8182
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:8123
std::tuple< Settings::Processing::Filters::Reflection::Removal::Experimental::Mode > Descendants
Definition: Settings.h:8035
friend std::ostream & operator<<(std::ostream &stream, const Experimental &value)
Operator to send the value as string to a stream
Definition: Settings.h:8204
const Settings::Processing::Filters::Reflection::Removal::Experimental::Mode & get() const
Definition: Settings.h:8169
bool operator==(const Experimental &other) const
Equality operator
const Mode & mode() const
Get Mode
Definition: Settings.h:8144
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:8089
Experimental & set(const Mode &value)
Set Mode
Definition: Settings.h:8156
Discard points likely introduced by reflections (useful for shiny materials)
Definition: Settings.h:7800
const Experimental & experimental() const
Get Experimental
Definition: Settings.h:8358
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:8345
friend std::ostream & operator<<(std::ostream &stream, const Removal &value)
Operator to send the value as string to a stream
Definition: Settings.h:8455
std::string toString() const
Get the value as string
bool operator==(const Removal &other) const
Equality operator
const Settings::Processing::Filters::Reflection::Removal::Enabled & get() const
Definition: Settings.h:8388
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:8282
std::tuple< Settings::Processing::Filters::Reflection::Removal::Enabled, Settings::Processing::Filters::Reflection::Removal::Experimental, Settings::Processing::Filters::Reflection::Removal::Experimental::Mode > Descendants
Definition: Settings.h:8224
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:8431
const Settings::Processing::Filters::Reflection::Removal::Experimental::Mode & get() const
Definition: Settings.h:8411
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:8318
Removal(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:8253
Removal & set(const Enabled &value)
Set Enabled
Definition: Settings.h:8351
Removal & set(const Experimental &value)
Set Experimental
Definition: Settings.h:8370
Experimental & experimental()
Get Experimental
Definition: Settings.h:8364
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:8439
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:8339
const Settings::Processing::Filters::Reflection::Removal::Experimental & get() const
Definition: Settings.h:8399
bool operator!=(const Removal &other) const
Inequality operator
Removal & set(const Experimental::Mode &value)
Set Experimental::Mode
Definition: Settings.h:8377
Contains a filter that removes points likely introduced by reflections (useful for shiny materials)
Definition: Settings.h:7780
const Settings::Processing::Filters::Reflection::Removal::Experimental::Mode & get() const
Definition: Settings.h:8670
Reflection & set(const Removal::Experimental &value)
Set Removal::Experimental
Definition: Settings.h:8621
bool operator!=(const Reflection &other) const
Inequality operator
bool operator==(const Reflection &other) const
Equality operator
std::tuple< Settings::Processing::Filters::Reflection::Removal, Settings::Processing::Filters::Reflection::Removal::Enabled, Settings::Processing::Filters::Reflection::Removal::Experimental, Settings::Processing::Filters::Reflection::Removal::Experimental::Mode > Descendants
Definition: Settings.h:8477
const Settings::Processing::Filters::Reflection::Removal::Experimental & get() const
Definition: Settings.h:8659
Removal & removal()
Get Removal
Definition: Settings.h:8601
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:8537
friend std::ostream & operator<<(std::ostream &stream, const Reflection &value)
Operator to send the value as string to a stream
Definition: Settings.h:8705
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:8690
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:8683
Reflection & set(const Removal::Enabled &value)
Set Removal::Enabled
Definition: Settings.h:8614
const Settings::Processing::Filters::Reflection::Removal::Enabled & get() const
Definition: Settings.h:8649
Reflection(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:8507
std::string toString() const
Get the value as string
Reflection & set(const Removal::Experimental::Mode &value)
Set Removal::Experimental::Mode
Definition: Settings.h:8628
const Removal & removal() const
Get Removal
Definition: Settings.h:8595
const Settings::Processing::Filters::Reflection::Removal & get() const
Definition: Settings.h:8639
Reflection & set(const Removal &value)
Set Removal
Definition: Settings.h:8607
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:8574
Enable or disable the smoothing filter
Definition: Settings.h:8764
bool ValueType
The type of the underlying value
Definition: Settings.h:8781
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:8786
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:8821
static const Enabled yes
On/enabled.
Definition: Settings.h:8782
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:8815
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:8827
static const Enabled no
Off/disabled.
Definition: Settings.h:8783
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:8795
std::string toString() const
Get the value as string
Higher values result in smoother point clouds (Standard deviation of the filter coefficients)
Definition: Settings.h:8844
double ValueType
The type of the underlying value
Definition: Settings.h:8861
bool operator!=(const Sigma &other) const
Comparison operator
Definition: Settings.h:8899
bool operator>(const Sigma &other) const
Comparison operator
Definition: Settings.h:8911
constexpr Sigma(double value)
Constructor
Definition: Settings.h:8873
static constexpr Range< double > validRange()
The range of valid values for Sigma
Definition: Settings.h:8864
friend std::ostream & operator<<(std::ostream &stream, const Sigma &value)
Operator to serialize the value to a stream
Definition: Settings.h:8929
bool operator>=(const Sigma &other) const
Comparison operator
Definition: Settings.h:8923
bool operator==(const Sigma &other) const
Comparison operator
Definition: Settings.h:8893
bool operator<=(const Sigma &other) const
Comparison operator
Definition: Settings.h:8917
std::string toString() const
Get the value as string
bool operator<(const Sigma &other) const
Comparison operator
Definition: Settings.h:8905
Gaussian smoothing of the point cloud
Definition: Settings.h:8744
Gaussian(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:8982
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:9072
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:9137
const Settings::Processing::Filters::Smoothing::Gaussian::Sigma & get() const
Definition: Settings.h:9118
Gaussian & set(const Enabled &value)
Set Enabled
Definition: Settings.h:9078
friend std::ostream & operator<<(std::ostream &stream, const Gaussian &value)
Operator to send the value as string to a stream
Definition: Settings.h:9161
const Sigma & sigma() const
Get Sigma
Definition: Settings.h:9085
std::tuple< Settings::Processing::Filters::Smoothing::Gaussian::Enabled, Settings::Processing::Filters::Smoothing::Gaussian::Sigma > Descendants
Definition: Settings.h:8954
bool operator==(const Gaussian &other) const
Equality operator
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:9066
bool operator!=(const Gaussian &other) const
Inequality operator
std::string toString() const
Get the value as string
const Settings::Processing::Filters::Smoothing::Gaussian::Enabled & get() const
Definition: Settings.h:9108
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:9045
Gaussian & set(const Sigma &value)
Set Sigma
Definition: Settings.h:9097
Sigma & sigma()
Get Sigma
Definition: Settings.h:9091
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:9010
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:9145
Smoothing filters
Definition: Settings.h:8726
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:9276
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:9240
Smoothing & set(const Gaussian &value)
Set Gaussian
Definition: Settings.h:9309
std::tuple< Settings::Processing::Filters::Smoothing::Gaussian, Settings::Processing::Filters::Smoothing::Gaussian::Enabled, Settings::Processing::Filters::Smoothing::Gaussian::Sigma > Descendants
Definition: Settings.h:9182
const Settings::Processing::Filters::Smoothing::Gaussian::Enabled & get() const
Definition: Settings.h:9344
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:9374
Smoothing & set(const Gaussian::Sigma &value)
Set Gaussian::Sigma
Definition: Settings.h:9323
Smoothing & set(const Gaussian::Enabled &value)
Set Gaussian::Enabled
Definition: Settings.h:9316
bool operator!=(const Smoothing &other) const
Inequality operator
const Gaussian & gaussian() const
Get Gaussian
Definition: Settings.h:9297
Smoothing(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:9211
std::string toString() const
Get the value as string
bool operator==(const Smoothing &other) const
Equality operator
const Settings::Processing::Filters::Smoothing::Gaussian & get() const
Definition: Settings.h:9334
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:9367
const Settings::Processing::Filters::Smoothing::Gaussian::Sigma & get() const
Definition: Settings.h:9354
friend std::ostream & operator<<(std::ostream &stream, const Smoothing &value)
Operator to send the value as string to a stream
Definition: Settings.h:9389
Gaussian & gaussian()
Get Gaussian
Definition: Settings.h:9303
Filters
Definition: Settings.h:3176
bool operator!=(const Filters &other) const
Inequality operator
const Settings::Processing::Filters::Outlier::Removal & get() const
Definition: Settings.h:10194
Filters & set(const Reflection::Removal::Enabled &value)
Set Reflection::Removal::Enabled
Definition: Settings.h:9896
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:10357
Filters & set(const Cluster &value)
Set Cluster
Definition: Settings.h:9659
const Settings::Processing::Filters::Outlier::Removal::Enabled & get() const
Definition: Settings.h:10204
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:9626
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold & get() const
Definition: Settings.h:10096
std::string toString() const
Get the value as string
Filters & set(const Reflection::Removal::Experimental &value)
Set Reflection::Removal::Experimental
Definition: Settings.h:9903
Filters & set(const Cluster::Removal::MaxNeighborDistance &value)
Set Cluster::Removal::MaxNeighborDistance
Definition: Settings.h:9680
const Settings::Processing::Filters::Noise::Removal::Enabled & get() const
Definition: Settings.h:10165
const Settings::Processing::Filters::Reflection::Removal::Experimental & get() const
Definition: Settings.h:10253
const Settings::Processing::Filters::Smoothing & get() const
Definition: Settings.h:10272
const Settings::Processing::Filters::Cluster::Removal & get() const
Definition: Settings.h:9970
Cluster & cluster()
Get Cluster
Definition: Settings.h:9653
Filters & set(const Reflection::Removal::Experimental::Mode &value)
Set Reflection::Removal::Experimental::Mode
Definition: Settings.h:9910
const Settings::Processing::Filters::Reflection::Removal & get() const
Definition: Settings.h:10233
const Settings::Processing::Filters::Reflection & get() const
Definition: Settings.h:10223
Filters & set(const Outlier::Removal::Threshold &value)
Set Outlier::Removal::Threshold
Definition: Settings.h:9863
Filters & set(const Experimental::ContrastDistortion::Correction::Strength &value)
Set Experimental::ContrastDistortion::Correction::Strength
Definition: Settings.h:9734
Filters & set(const Experimental &value)
Set Experimental
Definition: Settings.h:9706
Outlier & outlier()
Get Outlier
Definition: Settings.h:9836
Filters & set(const Outlier::Removal &value)
Set Outlier::Removal
Definition: Settings.h:9849
const Cluster & cluster() const
Get Cluster
Definition: Settings.h:9647
const Experimental & experimental() const
Get Experimental
Definition: Settings.h:9694
Filters & set(const Experimental::ContrastDistortion &value)
Set Experimental::ContrastDistortion
Definition: Settings.h:9713
friend std::ostream & operator<<(std::ostream &stream, const Filters &value)
Operator to send the value as string to a stream
Definition: Settings.h:10377
Filters & set(const Cluster::Removal::Enabled &value)
Set Cluster::Removal::Enabled
Definition: Settings.h:9673
const Settings::Processing::Filters::Reflection::Removal::Enabled & get() const
Definition: Settings.h:10243
const Settings::Processing::Filters::Experimental::HoleFilling & get() const
Definition: Settings.h:10107
const Settings::Processing::Filters::Outlier & get() const
Definition: Settings.h:10184
const Settings::Processing::Filters::Experimental::ContrastDistortion & get() const
Definition: Settings.h:10019
const Settings::Processing::Filters::Smoothing::Gaussian::Sigma & get() const
Definition: Settings.h:10302
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:9560
const Reflection & reflection() const
Get Reflection
Definition: Settings.h:9870
const Settings::Processing::Filters::Experimental & get() const
Definition: Settings.h:10009
Filters & set(const Experimental::HoleFilling::Enabled &value)
Set Experimental::HoleFilling::Enabled
Definition: Settings.h:9769
Filters & set(const Noise::Removal::Threshold &value)
Set Noise::Removal::Threshold
Definition: Settings.h:9823
Filters & set(const Experimental::HoleFilling &value)
Set Experimental::HoleFilling
Definition: Settings.h:9762
const Settings::Processing::Filters::Smoothing::Gaussian::Enabled & get() const
Definition: Settings.h:10292
Filters & set(const Reflection &value)
Set Reflection
Definition: Settings.h:9882
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength & get() const
Definition: Settings.h:10058
Filters & set(const Experimental::ContrastDistortion::Removal &value)
Set Experimental::ContrastDistortion::Removal
Definition: Settings.h:9741
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:10345
const Settings::Processing::Filters::Cluster::Removal::Enabled & get() const
Definition: Settings.h:9980
Filters & set(const Outlier &value)
Set Outlier
Definition: Settings.h:9842
const Noise & noise() const
Get Noise
Definition: Settings.h:9790
Filters & set(const Experimental::ContrastDistortion::Correction &value)
Set Experimental::ContrastDistortion::Correction
Definition: Settings.h:9720
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled & get() const
Definition: Settings.h:10044
Filters & set(const Reflection::Removal &value)
Set Reflection::Removal
Definition: Settings.h:9889
const Settings::Processing::Filters::Noise::Removal & get() const
Definition: Settings.h:10155
Filters & set(const Noise::Removal::Enabled &value)
Set Noise::Removal::Enabled
Definition: Settings.h:9816
std::tuple< Settings::Processing::Filters::Cluster, Settings::Processing::Filters::Cluster::Removal, Settings::Processing::Filters::Cluster::Removal::Enabled, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance, Settings::Processing::Filters::Cluster::Removal::MinArea, 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::Experimental::HoleFilling, Settings::Processing::Filters::Experimental::HoleFilling::Enabled, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize, Settings::Processing::Filters::Experimental::HoleFilling::Strictness, 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::Reflection::Removal::Experimental, Settings::Processing::Filters::Reflection::Removal::Experimental::Mode, 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:9440
const Settings::Processing::Filters::Experimental::HoleFilling::Strictness & get() const
Definition: Settings.h:10137
Filters & set(const Smoothing::Gaussian::Enabled &value)
Set Smoothing::Gaussian::Enabled
Definition: Settings.h:9943
const Settings::Processing::Filters::Noise & get() const
Definition: Settings.h:10146
Filters & set(const Experimental::ContrastDistortion::Removal::Threshold &value)
Set Experimental::ContrastDistortion::Removal::Threshold
Definition: Settings.h:9755
Filters & set(const Smoothing::Gaussian &value)
Set Smoothing::Gaussian
Definition: Settings.h:9936
bool operator==(const Filters &other) const
Equality operator
Filters & set(const Outlier::Removal::Enabled &value)
Set Outlier::Removal::Enabled
Definition: Settings.h:9856
Filters & set(const Experimental::HoleFilling::HoleSize &value)
Set Experimental::HoleFilling::HoleSize
Definition: Settings.h:9776
Filters & set(const Cluster::Removal &value)
Set Cluster::Removal
Definition: Settings.h:9666
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled & get() const
Definition: Settings.h:10083
const Settings::Processing::Filters::Reflection::Removal::Experimental::Mode & get() const
Definition: Settings.h:10263
const Settings::Processing::Filters::Experimental::HoleFilling::HoleSize & get() const
Definition: Settings.h:10127
Filters & set(const Cluster::Removal::MinArea &value)
Set Cluster::Removal::MinArea
Definition: Settings.h:9687
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal & get() const
Definition: Settings.h:10070
Filters(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:9500
Noise & noise()
Get Noise
Definition: Settings.h:9796
Filters & set(const Smoothing &value)
Set Smoothing
Definition: Settings.h:9929
Filters & set(const Experimental::ContrastDistortion::Correction::Enabled &value)
Set Experimental::ContrastDistortion::Correction::Enabled
Definition: Settings.h:9727
const Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance & get() const
Definition: Settings.h:9990
Filters & set(const Noise::Removal &value)
Set Noise::Removal
Definition: Settings.h:9809
const Settings::Processing::Filters::Cluster & get() const
Definition: Settings.h:9960
const Settings::Processing::Filters::Outlier::Removal::Threshold & get() const
Definition: Settings.h:10214
const Settings::Processing::Filters::Noise::Removal::Threshold & get() const
Definition: Settings.h:10175
Smoothing & smoothing()
Get Smoothing
Definition: Settings.h:9923
const Settings::Processing::Filters::Cluster::Removal::MinArea & get() const
Definition: Settings.h:10000
const Settings::Processing::Filters::Smoothing::Gaussian & get() const
Definition: Settings.h:10282
Filters & set(const Experimental::ContrastDistortion::Removal::Enabled &value)
Set Experimental::ContrastDistortion::Removal::Enabled
Definition: Settings.h:9748
Filters & set(const Experimental::HoleFilling::Strictness &value)
Set Experimental::HoleFilling::Strictness
Definition: Settings.h:9783
const Outlier & outlier() const
Get Outlier
Definition: Settings.h:9830
const Settings::Processing::Filters::Experimental::HoleFilling::Enabled & get() const
Definition: Settings.h:10117
Reflection & reflection()
Get Reflection
Definition: Settings.h:9876
Filters & set(const Noise &value)
Set Noise
Definition: Settings.h:9802
Filters & set(const Smoothing::Gaussian::Sigma &value)
Set Smoothing::Gaussian::Sigma
Definition: Settings.h:9950
const Smoothing & smoothing() const
Get Smoothing
Definition: Settings.h:9917
Experimental & experimental()
Get Experimental
Definition: Settings.h:9700
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction & get() const
Definition: Settings.h:10030
Settings related to processing of a capture, including filters and color balance
Definition: Settings.h:1706
const Settings::Processing::Filters::Experimental::HoleFilling::Strictness & get() const
Definition: Settings.h:11247
const Settings::Processing::Color::Experimental::Mode & get() const
Definition: Settings.h:11054
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal & get() const
Definition: Settings.h:11182
const Settings::Processing::Filters::Smoothing::Gaussian & get() const
Definition: Settings.h:11389
const Settings::Processing::Filters::Reflection::Removal::Enabled & get() const
Definition: Settings.h:11350
Processing & set(const Color::Experimental &value)
Set Color::Experimental
Definition: Settings.h:10721
Processing & set(const Color &value)
Set Color
Definition: Settings.h:10686
Processing & set(const Filters::Cluster::Removal::MaxNeighborDistance &value)
Set Filters::Cluster::Removal::MaxNeighborDistance
Definition: Settings.h:10782
const Settings::Processing::Color::Balance::Red & get() const
Definition: Settings.h:11036
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::Mode, Settings::Processing::Color::Gamma, Settings::Processing::Filters, Settings::Processing::Filters::Cluster, Settings::Processing::Filters::Cluster::Removal, Settings::Processing::Filters::Cluster::Removal::Enabled, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance, Settings::Processing::Filters::Cluster::Removal::MinArea, 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::Experimental::HoleFilling, Settings::Processing::Filters::Experimental::HoleFilling::Enabled, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize, Settings::Processing::Filters::Experimental::HoleFilling::Strictness, 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::Reflection::Removal::Experimental, Settings::Processing::Filters::Reflection::Removal::Experimental::Mode, 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:10442
Processing & set(const Color::Balance &value)
Set Color::Balance
Definition: Settings.h:10693
Processing & set(const Filters::Smoothing::Gaussian &value)
Set Filters::Smoothing::Gaussian
Definition: Settings.h:10978
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:10654
Filters & filters()
Get Filters
Definition: Settings.h:10748
Processing & set(const Filters::Smoothing::Gaussian::Enabled &value)
Set Filters::Smoothing::Gaussian::Enabled
Definition: Settings.h:10985
const Settings::Processing::Color::Gamma & get() const
Definition: Settings.h:11062
Processing & set(const Filters::Experimental::ContrastDistortion::Removal &value)
Set Filters::Experimental::ContrastDistortion::Removal
Definition: Settings.h:10831
Processing & set(const Filters::Experimental::HoleFilling::HoleSize &value)
Set Filters::Experimental::HoleFilling::HoleSize
Definition: Settings.h:10866
Processing()
Default constructor
const Settings::Processing::Filters::Smoothing & get() const
Definition: Settings.h:11379
Processing & set(const Filters::Experimental::ContrastDistortion::Removal::Threshold &value)
Set Filters::Experimental::ContrastDistortion::Removal::Threshold
Definition: Settings.h:10845
const Settings::Processing::Color::Balance::Green & get() const
Definition: Settings.h:11027
Processing & set(const Filters::Outlier::Removal &value)
Set Filters::Outlier::Removal
Definition: Settings.h:10915
Processing & set(const Filters::Experimental::ContrastDistortion::Removal::Enabled &value)
Set Filters::Experimental::ContrastDistortion::Removal::Enabled
Definition: Settings.h:10838
Processing & set(const Filters::Cluster::Removal::Enabled &value)
Set Filters::Cluster::Removal::Enabled
Definition: Settings.h:10775
friend std::ostream & operator<<(std::ostream &stream, const Processing &value)
Operator to send the value as string to a stream
Definition: Settings.h:11452
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled & get() const
Definition: Settings.h:11193
const Settings::Processing::Filters::Reflection::Removal & get() const
Definition: Settings.h:11340
std::string toString() const
Get the value as string
const Settings::Processing::Filters::Noise::Removal::Threshold & get() const
Definition: Settings.h:11284
const Settings::Processing::Filters::Smoothing::Gaussian::Sigma & get() const
Definition: Settings.h:11409
const Settings::Processing::Filters::Noise::Removal::Enabled & get() const
Definition: Settings.h:11274
Processing & set(const Color::Balance::Blue &value)
Set Color::Balance::Blue
Definition: Settings.h:10700
Color & color()
Get Color
Definition: Settings.h:10680
Processing & set(const Filters::Experimental::HoleFilling::Strictness &value)
Set Filters::Experimental::HoleFilling::Strictness
Definition: Settings.h:10873
const Settings::Processing::Filters::Reflection::Removal::Experimental & get() const
Definition: Settings.h:11360
const Settings::Processing::Filters::Smoothing::Gaussian::Enabled & get() const
Definition: Settings.h:11399
Processing & set(const Filters::Reflection &value)
Set Filters::Reflection
Definition: Settings.h:10936
Processing & set(const Filters::Noise &value)
Set Filters::Noise
Definition: Settings.h:10880
Processing & set(const Filters::Cluster &value)
Set Filters::Cluster
Definition: Settings.h:10761
const Settings::Processing::Filters::Outlier & get() const
Definition: Settings.h:11292
const Settings::Processing::Filters & get() const
Definition: Settings.h:11070
Processing & set(const Filters::Experimental::ContrastDistortion::Correction::Strength &value)
Set Filters::Experimental::ContrastDistortion::Correction::Strength
Definition: Settings.h:10824
Processing & set(const Filters::Noise::Removal::Enabled &value)
Set Filters::Noise::Removal::Enabled
Definition: Settings.h:10894
Processing & set(const Filters::Smoothing &value)
Set Filters::Smoothing
Definition: Settings.h:10971
const Settings::Processing::Color::Balance & get() const
Definition: Settings.h:11009
const Filters & filters() const
Get Filters
Definition: Settings.h:10742
Processing & set(const Filters::Cluster::Removal &value)
Set Filters::Cluster::Removal
Definition: Settings.h:10768
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:11436
const Settings::Processing::Filters::Cluster::Removal::MinArea & get() const
Definition: Settings.h:11117
Processing & set(const Filters::Smoothing::Gaussian::Sigma &value)
Set Filters::Smoothing::Gaussian::Sigma
Definition: Settings.h:10992
Processing & set(const Filters::Noise::Removal &value)
Set Filters::Noise::Removal
Definition: Settings.h:10887
const Settings::Processing::Filters::Experimental::HoleFilling::Enabled & get() const
Definition: Settings.h:11227
Processing & set(const Filters::Reflection::Removal::Experimental &value)
Set Filters::Reflection::Removal::Experimental
Definition: Settings.h:10957
Processing & set(const Filters::Outlier::Removal::Enabled &value)
Set Filters::Outlier::Removal::Enabled
Definition: Settings.h:10922
Processing & set(const Filters::Noise::Removal::Threshold &value)
Set Filters::Noise::Removal::Threshold
Definition: Settings.h:10901
const Settings::Processing::Color::Balance::Blue & get() const
Definition: Settings.h:11018
Processing & set(const Filters::Cluster::Removal::MinArea &value)
Set Filters::Cluster::Removal::MinArea
Definition: Settings.h:10789
Processing & set(const Filters::Experimental &value)
Set Filters::Experimental
Definition: Settings.h:10796
const Settings::Processing::Filters::Noise::Removal & get() const
Definition: Settings.h:11264
Processing & set(const Filters::Outlier::Removal::Threshold &value)
Set Filters::Outlier::Removal::Threshold
Definition: Settings.h:10929
Processing & set(const Filters::Experimental::HoleFilling &value)
Set Filters::Experimental::HoleFilling
Definition: Settings.h:10852
Processing & set(const Color::Balance::Green &value)
Set Color::Balance::Green
Definition: Settings.h:10707
Processing & set(const Filters::Experimental::HoleFilling::Enabled &value)
Set Filters::Experimental::HoleFilling::Enabled
Definition: Settings.h:10859
const Settings::Processing::Color::Experimental & get() const
Definition: Settings.h:11045
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength & get() const
Definition: Settings.h:11171
Processing & set(const Filters::Outlier &value)
Set Filters::Outlier
Definition: Settings.h:10908
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled & get() const
Definition: Settings.h:11158
Processing & set(const Color::Experimental::Mode &value)
Set Color::Experimental::Mode
Definition: Settings.h:10728
Processing & set(const Filters::Reflection::Removal::Enabled &value)
Set Filters::Reflection::Removal::Enabled
Definition: Settings.h:10950
Processing & set(const Filters::Experimental::ContrastDistortion::Correction::Enabled &value)
Set Filters::Experimental::ContrastDistortion::Correction::Enabled
Definition: Settings.h:10817
const Settings::Processing::Filters::Cluster::Removal::Enabled & get() const
Definition: Settings.h:11097
const Settings::Processing::Filters::Outlier::Removal::Threshold & get() const
Definition: Settings.h:11321
Processing & set(const Filters::Reflection::Removal::Experimental::Mode &value)
Set Filters::Reflection::Removal::Experimental::Mode
Definition: Settings.h:10964
Processing & set(const Filters::Reflection::Removal &value)
Set Filters::Reflection::Removal
Definition: Settings.h:10943
const Settings::Processing::Filters::Reflection::Removal::Experimental::Mode & get() const
Definition: Settings.h:11370
const Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance & get() const
Definition: Settings.h:11107
Processing(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:10511
Processing & set(const Filters::Experimental::ContrastDistortion::Correction &value)
Set Filters::Experimental::ContrastDistortion::Correction
Definition: Settings.h:10810
const Settings::Processing::Color & get() const
Definition: Settings.h:11001
bool operator==(const Processing &other) const
Equality operator
const Color & color() const
Get Color
Definition: Settings.h:10674
Processing & set(const Filters::Experimental::ContrastDistortion &value)
Set Filters::Experimental::ContrastDistortion
Definition: Settings.h:10803
const Settings::Processing::Filters::Cluster::Removal & get() const
Definition: Settings.h:11087
const Settings::Processing::Filters::Reflection & get() const
Definition: Settings.h:11330
const Settings::Processing::Filters::Outlier::Removal::Enabled & get() const
Definition: Settings.h:11311
Processing & set(const Filters &value)
Set Filters
Definition: Settings.h:10754
const Settings::Processing::Filters::Experimental::HoleFilling::HoleSize & get() const
Definition: Settings.h:11237
Processing & set(const Color::Balance::Red &value)
Set Color::Balance::Red
Definition: Settings.h:10714
const Settings::Processing::Filters::Noise & get() const
Definition: Settings.h:11255
bool operator!=(const Processing &other) const
Inequality operator
const Settings::Processing::Filters::Experimental & get() const
Definition: Settings.h:11126
Processing & set(const Color::Gamma &value)
Set Color::Gamma
Definition: Settings.h:10735
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:10580
const Settings::Processing::Filters::Experimental::HoleFilling & get() const
Definition: Settings.h:11217
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold & get() const
Definition: Settings.h:11206
const Settings::Processing::Filters::Cluster & get() const
Definition: Settings.h:11078
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction & get() const
Definition: Settings.h:11146
const Settings::Processing::Filters::Experimental::ContrastDistortion & get() const
Definition: Settings.h:11136
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:11428
const Settings::Processing::Filters::Outlier::Removal & get() const
Definition: Settings.h:11301
Enabled
Definition: Settings.h:11532
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:11561
bool ValueType
The type of the underlying value
Definition: Settings.h:11547
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:11581
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:11552
static const Enabled yes
On/enabled.
Definition: Settings.h:11548
static const Enabled no
Off/disabled.
Definition: Settings.h:11549
bool hasValue() const
Check if the value is set
void reset()
Reset the node to unset state
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:11593
std::string toString() const
Get the value as string
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:11587
Two points on the normal describing the direction and distance from the plane from which the normal i...
Definition: Settings.h:11610
std::string toString() const
Get the value as string
bool operator==(const Extents &other) const
Comparison operator
Definition: Settings.h:11658
void reset()
Reset the node to unset state
constexpr Extents(Zivid::Range< double > value)
Constructor
Definition: Settings.h:11633
constexpr Extents(double minValue, double maxValue)
Constructor
Definition: Settings.h:11653
bool hasValue() const
Check if the value is set
friend std::ostream & operator<<(std::ostream &stream, const Extents &value)
Operator to serialize the value to a stream
Definition: Settings.h:11670
const Zivid::Range< double > & value() const
Get the value
bool operator!=(const Extents &other) const
Comparison operator
Definition: Settings.h:11664
A point such that the vector from PointO to PointA describes the first edge of the parallelogram
Definition: Settings.h:11687
void reset()
Reset the node to unset state
constexpr PointA(float x, float y, float z)
Constructor
Definition: Settings.h:11730
bool operator!=(const PointA &other) const
Comparison operator
Definition: Settings.h:11741
bool operator==(const PointA &other) const
Comparison operator
Definition: Settings.h:11735
bool hasValue() const
Check if the value is set
friend std::ostream & operator<<(std::ostream &stream, const PointA &value)
Operator to serialize the value to a stream
Definition: Settings.h:11747
constexpr PointA(Zivid::PointXYZ value)
Constructor
Definition: Settings.h:11710
Zivid::PointXYZ value() const
Get the value
std::string toString() const
Get the value as string
A point such that the vector from PointO to PointB describes the second edge of the parallelogram
Definition: Settings.h:11764
bool operator==(const PointB &other) const
Comparison operator
Definition: Settings.h:11812
bool hasValue() const
Check if the value is set
friend std::ostream & operator<<(std::ostream &stream, const PointB &value)
Operator to serialize the value to a stream
Definition: Settings.h:11824
void reset()
Reset the node to unset state
std::string toString() const
Get the value as string
constexpr PointB(float x, float y, float z)
Constructor
Definition: Settings.h:11807
constexpr PointB(Zivid::PointXYZ value)
Constructor
Definition: Settings.h:11787
Zivid::PointXYZ value() const
Get the value
bool operator!=(const PointB &other) const
Comparison operator
Definition: Settings.h:11818
The point at the intersection of two adjacent edges defining a parallelogram
Definition: Settings.h:11841
constexpr PointO(float x, float y, float z)
Constructor
Definition: Settings.h:11884
void reset()
Reset the node to unset state
bool operator!=(const PointO &other) const
Comparison operator
Definition: Settings.h:11895
constexpr PointO(Zivid::PointXYZ value)
Constructor
Definition: Settings.h:11864
bool operator==(const PointO &other) const
Comparison operator
Definition: Settings.h:11889
bool hasValue() const
Check if the value is set
Zivid::PointXYZ value() const
Get the value
std::string toString() const
Get the value as string
friend std::ostream & operator<<(std::ostream &stream, const PointO &value)
Operator to serialize the value to a stream
Definition: Settings.h:11901
Removes the points outside the box.
Definition: Settings.h:11504
std::tuple< Settings::RegionOfInterest::Box::Enabled, Settings::RegionOfInterest::Box::Extents, Settings::RegionOfInterest::Box::PointA, Settings::RegionOfInterest::Box::PointB, Settings::RegionOfInterest::Box::PointO > Descendants
Definition: Settings.h:11919
std::string toString() const
Get the value as string
Box & set(const PointA &value)
Set PointA
Definition: Settings.h:12089
Box copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:12018
const PointO & pointO() const
Get PointO
Definition: Settings.h:12115
Box & set(const PointO &value)
Set PointO
Definition: Settings.h:12127
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:12045
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:12039
Box & set(const Extents &value)
Set Extents
Definition: Settings.h:12070
const Settings::RegionOfInterest::Box::Enabled & get() const
Definition: Settings.h:12137
PointA & pointA()
Get PointA
Definition: Settings.h:12083
PointB & pointB()
Get PointB
Definition: Settings.h:12102
Box & set(const PointB &value)
Set PointB
Definition: Settings.h:12108
const Settings::RegionOfInterest::Box::PointO & get() const
Definition: Settings.h:12173
const Settings::RegionOfInterest::Box::PointA & get() const
Definition: Settings.h:12155
const Extents & extents() const
Get Extents
Definition: Settings.h:12058
Box(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:11950
const PointA & pointA() const
Get PointA
Definition: Settings.h:12077
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:11981
PointO & pointO()
Get PointO
Definition: Settings.h:12121
Extents & extents()
Get Extents
Definition: Settings.h:12064
const PointB & pointB() const
Get PointB
Definition: Settings.h:12096
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:12210
friend std::ostream & operator<<(std::ostream &stream, const Box &value)
Operator to send the value as string to a stream
Definition: Settings.h:12240
bool operator!=(const Box &other) const
Inequality operator
bool operator==(const Box &other) const
Equality operator
const Settings::RegionOfInterest::Box::PointB & get() const
Definition: Settings.h:12164
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:12221
const Settings::RegionOfInterest::Box::Extents & get() const
Definition: Settings.h:12146
Box & set(const Enabled &value)
Set Enabled
Definition: Settings.h:12051
Enabled
Definition: Settings.h:12289
static const Enabled yes
On/enabled.
Definition: Settings.h:12305
bool hasValue() const
Check if the value is set
void reset()
Reset the node to unset state
bool operator==(const Enabled &other) const
Comparison operator
Definition: Settings.h:12338
bool operator!=(const Enabled &other) const
Comparison operator
Definition: Settings.h:12344
bool ValueType
The type of the underlying value
Definition: Settings.h:12304
friend std::ostream & operator<<(std::ostream &stream, const Enabled &value)
Operator to serialize the value to a stream
Definition: Settings.h:12350
static std::set< bool > validValues()
All valid values of Enabled
Definition: Settings.h:12309
std::string toString() const
Get the value as string
static const Enabled no
Off/disabled.
Definition: Settings.h:12306
constexpr Enabled(bool value)
Constructor
Definition: Settings.h:12318
Specify the minimum and maximum Z value that will be included.
Definition: Settings.h:12367
constexpr Range(double minValue, double maxValue)
Constructor
Definition: Settings.h:12410
constexpr Range(Zivid::Range< double > value)
Constructor
Definition: Settings.h:12390
const Zivid::Range< double > & value() const
Get the value
std::string toString() const
Get the value as string
friend std::ostream & operator<<(std::ostream &stream, const Range &value)
Operator to serialize the value to a stream
Definition: Settings.h:12427
bool operator==(const Range &other) const
Comparison operator
Definition: Settings.h:12415
bool operator!=(const Range &other) const
Comparison operator
Definition: Settings.h:12421
void reset()
Reset the node to unset state
bool hasValue() const
Check if the value is set
Removes points that reside outside of a depth range, meaning that their Z coordinate falls above a gi...
Definition: Settings.h:12267
Depth & set(const Enabled &value)
Set Enabled
Definition: Settings.h:12564
std::string toString() const
Get the value as string
const Range & range() const
Get Range
Definition: Settings.h:12571
Depth & set(const Range &value)
Set Range
Definition: Settings.h:12583
std::tuple< Settings::RegionOfInterest::Depth::Enabled, Settings::RegionOfInterest::Depth::Range > Descendants
Definition: Settings.h:12441
const Enabled & isEnabled() const
Get Enabled
Definition: Settings.h:12552
bool operator==(const Depth &other) const
Equality operator
Depth(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:12469
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:12629
bool operator!=(const Depth &other) const
Inequality operator
const Settings::RegionOfInterest::Depth::Enabled & get() const
Definition: Settings.h:12593
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:12621
Range & range()
Get Range
Definition: Settings.h:12577
friend std::ostream & operator<<(std::ostream &stream, const Depth &value)
Operator to send the value as string to a stream
Definition: Settings.h:12645
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:12497
Enabled & isEnabled()
Get Enabled
Definition: Settings.h:12558
const Settings::RegionOfInterest::Depth::Range & get() const
Definition: Settings.h:12602
Depth copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:12531
Removes points outside the region of interest.
Definition: Settings.h:11475
const Settings::RegionOfInterest::Depth::Enabled & get() const
Definition: Settings.h:12950
std::tuple< Settings::RegionOfInterest::Box, Settings::RegionOfInterest::Box::Enabled, Settings::RegionOfInterest::Box::Extents, Settings::RegionOfInterest::Box::PointA, Settings::RegionOfInterest::Box::PointB, Settings::RegionOfInterest::Box::PointO, Settings::RegionOfInterest::Depth, Settings::RegionOfInterest::Depth::Enabled, Settings::RegionOfInterest::Depth::Range > Descendants
Definition: Settings.h:12672
Depth & depth()
Get Depth
Definition: Settings.h:12862
RegionOfInterest & set(const Depth::Enabled &value)
Set Depth::Enabled
Definition: Settings.h:12875
const Box & box() const
Get Box
Definition: Settings.h:12802
RegionOfInterest & set(const Box &value)
Set Box
Definition: Settings.h:12814
friend std::ostream & operator<<(std::ostream &stream, const RegionOfInterest &value)
Operator to send the value as string to a stream
Definition: Settings.h:13002
RegionOfInterest & set(const Box::PointO &value)
Set Box::PointO
Definition: Settings.h:12849
const Settings::RegionOfInterest::Box::PointO & get() const
Definition: Settings.h:12933
std::string toString() const
Get the value as string
const Settings::RegionOfInterest::Box::PointA & get() const
Definition: Settings.h:12917
const Settings::RegionOfInterest::Depth & get() const
Definition: Settings.h:12941
const Settings::RegionOfInterest::Box::Extents & get() const
Definition: Settings.h:12909
const Settings::RegionOfInterest::Depth::Range & get() const
Definition: Settings.h:12959
const Settings::RegionOfInterest::Box::PointB & get() const
Definition: Settings.h:12925
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:12742
RegionOfInterest copyWith(Args &&...args) const
Returns a copy of this object with the given argument(s) set to the new value(s)
Definition: Settings.h:12782
Box & box()
Get Box
Definition: Settings.h:12808
const Settings::RegionOfInterest::Box & get() const
Definition: Settings.h:12891
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:12978
RegionOfInterest & set(const Box::PointA &value)
Set Box::PointA
Definition: Settings.h:12835
const Depth & depth() const
Get Depth
Definition: Settings.h:12856
RegionOfInterest & set(const Box::Extents &value)
Set Box::Extents
Definition: Settings.h:12828
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:12986
RegionOfInterest & set(const Box::Enabled &value)
Set Box::Enabled
Definition: Settings.h:12821
RegionOfInterest & set(const Depth::Range &value)
Set Depth::Range
Definition: Settings.h:12882
bool operator!=(const RegionOfInterest &other) const
Inequality operator
RegionOfInterest & set(const Depth &value)
Set Depth
Definition: Settings.h:12868
RegionOfInterest & set(const Box::PointB &value)
Set Box::PointB
Definition: Settings.h:12842
bool operator==(const RegionOfInterest &other) const
Equality operator
RegionOfInterest(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:12707
const Settings::RegionOfInterest::Box::Enabled & get() const
Definition: Settings.h:12900
RegionOfInterest()
Default constructor
Settings used when capturing with a Zivid camera
Definition: Settings.h:124
const Settings::RegionOfInterest::Depth & get() const
Definition: Settings.h:14333
const Settings::Processing::Filters::Outlier::Removal::Enabled & get() const
Definition: Settings.h:14177
Settings(Args &&...args)
Constructor taking variadic number of arguments
Definition: Settings.h:13166
Settings & set(const Processing::Filters::Cluster::Removal::MinArea &value)
Set Processing::Filters::Cluster::Removal::MinArea
Definition: Settings.h:13541
const Settings::Processing::Filters::Outlier & get() const
Definition: Settings.h:14158
Settings & set(const RegionOfInterest::Box::PointB &value)
Set RegionOfInterest::Box::PointB
Definition: Settings.h:13798
const Settings::Processing::Color::Balance & get() const
Definition: Settings.h:13883
Settings & set(const Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &value)
Set Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled
Definition: Settings.h:13590
const Experimental & experimental() const
Get Experimental
Definition: Settings.h:13405
const Settings::Processing::Color::Balance::Red & get() const
Definition: Settings.h:13907
Settings & set(const Processing::Color::Experimental::Mode &value)
Set Processing::Color::Experimental::Mode
Definition: Settings.h:13492
Settings & set(const Processing::Filters::Smoothing &value)
Set Processing::Filters::Smoothing
Definition: Settings.h:13723
const Settings::Processing::Filters::Experimental::HoleFilling::Enabled & get() const
Definition: Settings.h:14093
const Settings::RegionOfInterest & get() const
Definition: Settings.h:14277
const Settings::Processing::Filters::Noise::Removal & get() const
Definition: Settings.h:14130
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:13341
const Processing & processing() const
Get Processing
Definition: Settings.h:13431
const Settings::Processing::Filters::Experimental::HoleFilling::HoleSize & get() const
Definition: Settings.h:14103
const Settings::Experimental & get() const
Definition: Settings.h:13853
const Settings::Processing::Color::Gamma & get() const
Definition: Settings.h:13932
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal & get() const
Definition: Settings.h:14049
Settings & set(const Processing &value)
Set Processing
Definition: Settings.h:13443
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold & get() const
Definition: Settings.h:14072
Settings & set(const Processing::Filters::Outlier::Removal::Enabled &value)
Set Processing::Filters::Outlier::Removal::Enabled
Definition: Settings.h:13674
const Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance & get() const
Definition: Settings.h:13977
Settings & set(const Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &value)
Set Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold
Definition: Settings.h:13597
Settings & set(const Experimental::Engine &value)
Set Experimental::Engine
Definition: Settings.h:13424
Settings & set(const Processing::Filters::Smoothing::Gaussian &value)
Set Processing::Filters::Smoothing::Gaussian
Definition: Settings.h:13730
Settings & set(const Diagnostics &value)
Set Diagnostics
Definition: Settings.h:13391
const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled & get() const
Definition: Settings.h:14060
Settings & set(const RegionOfInterest::Depth::Enabled &value)
Set RegionOfInterest::Depth::Enabled
Definition: Settings.h:13819
Settings & set(const Processing::Filters::Noise &value)
Set Processing::Filters::Noise
Definition: Settings.h:13632
void load(const std::string &fileName)
Load from the given file
const Settings::Processing::Filters::Cluster::Removal::MinArea & get() const
Definition: Settings.h:13987
const Settings::Acquisitions & get() const
Definition: Settings.h:13833
const Settings::Processing::Filters::Experimental::HoleFilling & get() const
Definition: Settings.h:14083
const Settings::Processing::Filters::Experimental & get() const
Definition: Settings.h:13995
const Settings::Processing::Filters::Outlier::Removal & get() const
Definition: Settings.h:14167
Settings & set(const Processing::Filters::Cluster &value)
Set Processing::Filters::Cluster
Definition: Settings.h:13513
const Settings::Processing::Filters::Smoothing::Gaussian::Sigma & get() const
Definition: Settings.h:14271
Settings & set(const Processing::Filters::Reflection::Removal::Experimental &value)
Set Processing::Filters::Reflection::Removal::Experimental
Definition: Settings.h:13709
const Settings::Diagnostics & get() const
Definition: Settings.h:13839
RegionOfInterest & regionOfInterest()
Get RegionOfInterest
Definition: Settings.h:13757
const Settings::Processing::Filters::Smoothing::Gaussian::Enabled & get() const
Definition: Settings.h:14261
const Settings::RegionOfInterest::Box & get() const
Definition: Settings.h:14285
Settings & set(const Processing::Color::Balance &value)
Set Processing::Color::Balance
Definition: Settings.h:13457
const Settings::RegionOfInterest::Box::PointO & get() const
Definition: Settings.h:14325
Settings & set(const RegionOfInterest::Depth &value)
Set RegionOfInterest::Depth
Definition: Settings.h:13812
const Settings::Processing::Filters::Noise::Removal::Enabled & get() const
Definition: Settings.h:14140
const Settings::RegionOfInterest::Depth::Enabled & get() const
Definition: Settings.h:14341
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction & get() const
Definition: Settings.h:14015
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:14386
const Settings::Processing::Color::Balance::Green & get() const
Definition: Settings.h:13899
const Settings::RegionOfInterest::Box::Extents & get() const
Definition: Settings.h:14301
Settings & set(const Processing::Filters::Smoothing::Gaussian::Enabled &value)
Set Processing::Filters::Smoothing::Gaussian::Enabled
Definition: Settings.h:13737
const Settings::Processing & get() const
Definition: Settings.h:13867
Settings & set(const Processing::Filters::Reflection &value)
Set Processing::Filters::Reflection
Definition: Settings.h:13688
std::tuple< Settings::Acquisitions, Settings::Diagnostics, Settings::Diagnostics::Enabled, 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::Mode, Settings::Processing::Color::Gamma, Settings::Processing::Filters, Settings::Processing::Filters::Cluster, Settings::Processing::Filters::Cluster::Removal, Settings::Processing::Filters::Cluster::Removal::Enabled, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance, Settings::Processing::Filters::Cluster::Removal::MinArea, 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::Experimental::HoleFilling, Settings::Processing::Filters::Experimental::HoleFilling::Enabled, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize, Settings::Processing::Filters::Experimental::HoleFilling::Strictness, 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::Reflection::Removal::Experimental, Settings::Processing::Filters::Reflection::Removal::Experimental::Mode, Settings::Processing::Filters::Smoothing, Settings::Processing::Filters::Smoothing::Gaussian, Settings::Processing::Filters::Smoothing::Gaussian::Enabled, Settings::Processing::Filters::Smoothing::Gaussian::Sigma, Settings::RegionOfInterest, Settings::RegionOfInterest::Box, Settings::RegionOfInterest::Box::Enabled, Settings::RegionOfInterest::Box::Extents, Settings::RegionOfInterest::Box::PointA, Settings::RegionOfInterest::Box::PointB, Settings::RegionOfInterest::Box::PointO, Settings::RegionOfInterest::Depth, Settings::RegionOfInterest::Depth::Enabled, Settings::RegionOfInterest::Depth::Range > Descendants
Definition: Settings.h:13079
const Settings::Experimental::Engine & get() const
Definition: Settings.h:13861
void forEach(const F &f)
Run the given function on each direct member with the value of the member as parameter
Definition: Settings.h:14397
Settings()
Default constructor
const Settings::Processing::Filters::Experimental::ContrastDistortion & get() const
Definition: Settings.h:14005
Settings & set(const Processing::Filters::Outlier::Removal::Threshold &value)
Set Processing::Filters::Outlier::Removal::Threshold
Definition: Settings.h:13681
const Settings::RegionOfInterest::Box::Enabled & get() const
Definition: Settings.h:14293
const Settings::Processing::Color::Experimental::Mode & get() const
Definition: Settings.h:13924
Settings & set(const Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &value)
Set Processing::Filters::Experimental::ContrastDistortion::Correction::Strength
Definition: Settings.h:13576
Settings & set(const RegionOfInterest::Box::Enabled &value)
Set RegionOfInterest::Box::Enabled
Definition: Settings.h:13777
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength & get() const
Definition: Settings.h:14038
Settings & set(const RegionOfInterest::Box::Extents &value)
Set RegionOfInterest::Box::Extents
Definition: Settings.h:13784
const Settings::Processing::Color::Balance::Blue & get() const
Definition: Settings.h:13891
const Acquisitions & acquisitions() const
Get Acquisitions
Definition: Settings.h:13360
void set(Args &&...args)
Set multiple arguments
Definition: Settings.h:13251
const Settings::Processing::Filters::Reflection & get() const
Definition: Settings.h:14195
Settings & set(const Processing::Filters::Experimental &value)
Set Processing::Filters::Experimental
Definition: Settings.h:13548
const Settings::Processing::Filters::Smoothing & get() const
Definition: Settings.h:14242
const Settings::Processing::Filters & get() const
Definition: Settings.h:13940
Settings & set(const Processing::Color::Experimental &value)
Set Processing::Color::Experimental
Definition: Settings.h:13485
void save(const std::string &fileName) const
Save to the given file
Settings & set(const RegionOfInterest::Depth::Range &value)
Set RegionOfInterest::Depth::Range
Definition: Settings.h:13826
const Settings::Processing::Filters::Experimental::HoleFilling::Strictness & get() const
Definition: Settings.h:14113
const Settings::Processing::Color::Experimental & get() const
Definition: Settings.h:13915
Settings & set(const Processing::Filters::Experimental::ContrastDistortion::Removal &value)
Set Processing::Filters::Experimental::ContrastDistortion::Removal
Definition: Settings.h:13583
const Settings::RegionOfInterest::Box::PointA & get() const
Definition: Settings.h:14309
Settings & set(const Processing::Color &value)
Set Processing::Color
Definition: Settings.h:13450
Experimental & experimental()
Get Experimental
Definition: Settings.h:13411
Settings & set(const Processing::Filters::Outlier &value)
Set Processing::Filters::Outlier
Definition: Settings.h:13660
bool operator==(const Settings &other) const
Equality operator
Acquisitions & acquisitions()
Get Acquisitions
Definition: Settings.h:13366
Settings & set(const Processing::Filters::Reflection::Removal &value)
Set Processing::Filters::Reflection::Removal
Definition: Settings.h:13695
const Settings::Processing::Filters::Cluster & get() const
Definition: Settings.h:13948
Settings(const std::string &fileName)
Construct Settings by loading from file
Settings & set(const Processing::Color::Balance::Red &value)
Set Processing::Color::Balance::Red
Definition: Settings.h:13478
Settings & set(const RegionOfInterest::Box::PointO &value)
Set RegionOfInterest::Box::PointO
Definition: Settings.h:13805
Settings & set(const Processing::Filters::Cluster::Removal &value)
Set Processing::Filters::Cluster::Removal
Definition: Settings.h:13520
Settings & set(const RegionOfInterest::Box &value)
Set RegionOfInterest::Box
Definition: Settings.h:13770
Diagnostics & diagnostics()
Get Diagnostics
Definition: Settings.h:13385
const Settings::Processing::Filters::Noise::Removal::Threshold & get() const
Definition: Settings.h:14150
const Settings::Processing::Filters::Cluster::Removal::Enabled & get() const
Definition: Settings.h:13967
const Settings::Processing::Filters::Reflection::Removal::Experimental & get() const
Definition: Settings.h:14224
Settings & set(const Processing::Filters::Reflection::Removal::Enabled &value)
Set Processing::Filters::Reflection::Removal::Enabled
Definition: Settings.h:13702
Processing & processing()
Get Processing
Definition: Settings.h:13437
Settings & set(const RegionOfInterest::Box::PointA &value)
Set RegionOfInterest::Box::PointA
Definition: Settings.h:13791
Settings & set(const Processing::Filters::Experimental::HoleFilling::Enabled &value)
Set Processing::Filters::Experimental::HoleFilling::Enabled
Definition: Settings.h:13611
Settings & set(const Processing::Filters::Experimental::HoleFilling &value)
Set Processing::Filters::Experimental::HoleFilling
Definition: Settings.h:13604
Settings & set(const Diagnostics::Enabled &value)
Set Diagnostics::Enabled
Definition: Settings.h:13398
const Settings::Processing::Filters::Noise & get() const
Definition: Settings.h:14121
const Settings::Diagnostics::Enabled & get() const
Definition: Settings.h:13847
const Settings::Processing::Filters::Cluster::Removal & get() const
Definition: Settings.h:13957
Settings & set(const Processing::Filters::Experimental::HoleFilling::Strictness &value)
Set Processing::Filters::Experimental::HoleFilling::Strictness
Definition: Settings.h:13625
std::string toString() const
Get the value as string
const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled & get() const
Definition: Settings.h:14026
const Settings::RegionOfInterest::Box::PointB & get() const
Definition: Settings.h:14317
Settings & set(const Processing::Filters::Experimental::ContrastDistortion &value)
Set Processing::Filters::Experimental::ContrastDistortion
Definition: Settings.h:13555
Settings & set(const Processing::Color::Gamma &value)
Set Processing::Color::Gamma
Definition: Settings.h:13499
Settings & set(const Processing::Filters::Cluster::Removal::Enabled &value)
Set Processing::Filters::Cluster::Removal::Enabled
Definition: Settings.h:13527
const Settings::RegionOfInterest::Depth::Range & get() const
Definition: Settings.h:14349
Settings & set(const Processing::Filters::Noise::Removal::Threshold &value)
Set Processing::Filters::Noise::Removal::Threshold
Definition: Settings.h:13653
Settings & set(const Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &value)
Set Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled
Definition: Settings.h:13569
Settings & set(const Processing::Filters::Reflection::Removal::Experimental::Mode &value)
Set Processing::Filters::Reflection::Removal::Experimental::Mode
Definition: Settings.h:13716
Settings & set(const Processing::Filters::Experimental::HoleFilling::HoleSize &value)
Set Processing::Filters::Experimental::HoleFilling::HoleSize
Definition: Settings.h:13618
Settings & set(const Acquisitions &value)
Set Acquisitions
Definition: Settings.h:13372
Settings & set(const Processing::Filters::Smoothing::Gaussian::Sigma &value)
Set Processing::Filters::Smoothing::Gaussian::Sigma
Definition: Settings.h:13744
const Diagnostics & diagnostics() const
Get Diagnostics
Definition: Settings.h:13379
bool operator!=(const Settings &other) const
Inequality operator
Settings & set(const Processing::Filters::Noise::Removal &value)
Set Processing::Filters::Noise::Removal
Definition: Settings.h:13639
Settings & set(const Processing::Filters::Cluster::Removal::MaxNeighborDistance &value)
Set Processing::Filters::Cluster::Removal::MaxNeighborDistance
Definition: Settings.h:13534
Settings & set(const Processing::Filters::Outlier::Removal &value)
Set Processing::Filters::Outlier::Removal
Definition: Settings.h:13667
Settings & set(const RegionOfInterest &value)
Set RegionOfInterest
Definition: Settings.h:13763
Settings & set(const Processing::Filters::Noise::Removal::Enabled &value)
Set Processing::Filters::Noise::Removal::Enabled
Definition: Settings.h:13646
Settings & set(const Processing::Filters::Experimental::ContrastDistortion::Correction &value)
Set Processing::Filters::Experimental::ContrastDistortion::Correction
Definition: Settings.h:13562
const Settings::Processing::Color & get() const
Definition: Settings.h:13875
const Settings::Processing::Filters::Reflection::Removal::Enabled & get() const
Definition: Settings.h:14214
const Settings::Processing::Filters::Reflection::Removal & get() const
Definition: Settings.h:14204
Settings & set(const Processing::Color::Balance::Green &value)
Set Processing::Color::Balance::Green
Definition: Settings.h:13471
Settings & set(const Processing::Filters &value)
Set Processing::Filters
Definition: Settings.h:13506
const RegionOfInterest & regionOfInterest() const
Get RegionOfInterest
Definition: Settings.h:13751
Settings & set(const Experimental &value)
Set Experimental
Definition: Settings.h:13417
const Settings::Processing::Filters::Outlier::Removal::Threshold & get() const
Definition: Settings.h:14187
Settings & set(const Processing::Color::Balance::Blue &value)
Set Processing::Color::Balance::Blue
Definition: Settings.h:13464
const Settings::Processing::Filters::Smoothing::Gaussian & get() const
Definition: Settings.h:14251
friend std::ostream & operator<<(std::ostream &stream, const Settings &value)
Operator to send the value as string to a stream
Definition: Settings.h:14416
const Settings::Processing::Filters::Reflection::Removal::Experimental::Mode & get() const
Definition: Settings.h:14234
NodeType
Definition: NodeType.h:100
Ret validRange(const CameraInfo &cameraInfo)
Definition: SettingsInfo.h:225
The main Zivid namespace. All Zivid code is found here
Definition: Application.h:99
Point with three coordinates as float
Definition: Point.h:105