Settings2D.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of the Zivid API
 *
 * Copyright 2015-2025 (C) Zivid AS
 * All rights reserved.
 *
 * Zivid Software License, v1.0
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * 3. Neither the name of Zivid AS nor the names of its contributors may be used
 * to endorse or promote products derived from this software without specific
 * prior written permission.
 *
 * 4. This software, with or without modification, must not be used with any
 * other 3D camera than from Zivid AS.
 *
 * 5. Any software provided in binary form under this license must not be
 * reverse engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY ZIVID AS "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ZIVID AS OR CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Contact: Zivid Customer Success Team <customersuccess@zivid.com>
 * Info:    http://www.zivid.com
 ******************************************************************************/
 
#pragma once
 
#include <array>
#include <chrono>
#include <cmath>
#include <ctime>
#include <iomanip>
#include <memory>
#include <optional>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include "Zivid/DataModel/Detail/Detail.h"
#include "Zivid/DataModel/NodeType.h"
#include "Zivid/DataModel/Traits.h"
#include "Zivid/Detail/CoreExport.h"
#include "Zivid/Detail/TypeTraits.h"
#include "Zivid/Range.h"
 
#ifdef _MSC_VER
#    pragma warning(push)
#    pragma warning(disable : 4251) // "X needs to have dll-interface to be used by clients of class Y."
#endif
 
namespace Zivid
{

 
    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
    class ZIVID_CORE_EXPORT Settings2D
    {
    public:
        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

        static constexpr const char *path{ "" };

        static constexpr const char *name{ "Settings2D" };

        static constexpr const char *description{
            R"description(Settings used when capturing 2D images with a Zivid camera.)description"
        };
 
        static constexpr size_t version{ 8 };
 
#ifndef NO_DOC
        template<size_t>
        struct Version;
 
        using LatestVersion = Zivid::Settings2D;
 
        // Short identifier. This value is not guaranteed to be universally unique
        // Todo(ZIVID-2808): Move this to internal DataModelExt header
        static constexpr std::array<uint8_t, 3> binaryId{ 's', 't', '2' };
 
#endif

 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Acquisition
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

            static constexpr const char *path{ "Acquisition" };

            static constexpr const char *name{ "Acquisition" };

            static constexpr const char *description{ R"description(Settings for one 2D acquisition.
 
When capturing 2D HDR, all 2D acquisitions must have the same Aperture setting. Use Exposure Time
or Gain to control the exposure instead.
)description" };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Aperture
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "Acquisition/Aperture" };

                static constexpr const char *name{ "Aperture" };

                static constexpr const char *description{
                    R"description(Aperture setting for the camera. Specified as an f-number (the ratio of lens focal length to
the effective aperture diameter).
 
When capturing 2D HDR, all 2D acquisitions must have the same Aperture setting. Use Exposure Time
or Gain to control the exposure instead.
)description"
                };

                using ValueType = double;

                static constexpr Range<double> validRange()
                {
                    return { 1.4, 32.0 };
                }

                Aperture() = default;

                explicit constexpr Aperture(double value)
                    : m_opt{ verifyValue(value) }
                {}

                double value() const;

                bool hasValue() const;

                void reset();

                std::string toString() const;

                bool operator==(const Aperture &other) const
                {
                    return m_opt == other.m_opt;
                }

                bool operator!=(const Aperture &other) const
                {
                    return m_opt != other.m_opt;
                }

                bool operator<(const Aperture &other) const
                {
                    return m_opt < other.m_opt;
                }

                bool operator>(const Aperture &other) const
                {
                    return m_opt > other.m_opt;
                }

                bool operator<=(const Aperture &other) const
                {
                    return m_opt <= other.m_opt;
                }

                bool operator>=(const Aperture &other) const
                {
                    return m_opt >= other.m_opt;
                }

                friend std::ostream &operator<<(std::ostream &stream, const Aperture &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return validRange().isInRange(value)
                               ? value
                               : throw std::out_of_range{ "Aperture{ " + std::to_string(value) + " } is not in range ["
                                                          + std::to_string(validRange().min()) + ", "
                                                          + std::to_string(validRange().max()) + "]" };
                }
 
                std::optional<double> m_opt;
 
                friend struct DataModel::Detail::Befriend<Aperture>;
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Brightness
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "Acquisition/Brightness" };

                static constexpr const char *name{ "Brightness" };

                static constexpr const char *description{
                    R"description(Brightness controls the light output from the projector.
 
Brightness above 1.0 may be needed when the distance between the camera and the scene is large,
or in case of high levels of ambient lighting.
 
When brightness is above 1.0 the duty cycle of the camera (the percentage of time the camera
can capture) will be reduced. The duty cycle in boost mode is 50%. The duty cycle is calculated
over a 10 second period. This limitation is enforced automatically by the camera. Calling capture
when the duty cycle limit has been reached will cause the camera to first wait (sleep) for a
duration of time to cool down, before capture will start.
)description"
                };

                using ValueType = double;

                static constexpr Range<double> validRange()
                {
                    return { 0, 3.0 };
                }

                Brightness() = default;

                explicit constexpr Brightness(double value)
                    : m_opt{ verifyValue(value) }
                {}

                double value() const;

                bool hasValue() const;

                void reset();

                std::string toString() const;

                bool operator==(const Brightness &other) const
                {
                    return m_opt == other.m_opt;
                }

                bool operator!=(const Brightness &other) const
                {
                    return m_opt != other.m_opt;
                }

                bool operator<(const Brightness &other) const
                {
                    return m_opt < other.m_opt;
                }

                bool operator>(const Brightness &other) const
                {
                    return m_opt > other.m_opt;
                }

                bool operator<=(const Brightness &other) const
                {
                    return m_opt <= other.m_opt;
                }

                bool operator>=(const Brightness &other) const
                {
                    return m_opt >= other.m_opt;
                }

                friend std::ostream &operator<<(std::ostream &stream, const Brightness &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return validRange().isInRange(value)
                               ? value
                               : throw std::out_of_range{ "Brightness{ " + std::to_string(value)
                                                          + " } is not in range [" + std::to_string(validRange().min())
                                                          + ", " + std::to_string(validRange().max()) + "]" };
                }
 
                std::optional<double> m_opt;
 
                friend struct DataModel::Detail::Befriend<Brightness>;
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT ExposureTime
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "Acquisition/ExposureTime" };

                static constexpr const char *name{ "ExposureTime" };

                static constexpr const char *description{ R"description(Exposure time for the image.)description" };

                using ValueType = std::chrono::microseconds;

                static constexpr Range<std::chrono::microseconds> validRange()
                {
                    return { std::chrono::microseconds{ 200 }, std::chrono::microseconds{ 100000 } };
                }

                ExposureTime() = default;

                explicit constexpr ExposureTime(std::chrono::microseconds value)
                    : m_opt{ verifyValue(value) }
                {}

                std::chrono::microseconds value() const;

                bool hasValue() const;

                void reset();

                std::string toString() const;

                bool operator==(const ExposureTime &other) const
                {
                    return m_opt == other.m_opt;
                }

                bool operator!=(const ExposureTime &other) const
                {
                    return m_opt != other.m_opt;
                }

                bool operator<(const ExposureTime &other) const
                {
                    return m_opt < other.m_opt;
                }

                bool operator>(const ExposureTime &other) const
                {
                    return m_opt > other.m_opt;
                }

                bool operator<=(const ExposureTime &other) const
                {
                    return m_opt <= other.m_opt;
                }

                bool operator>=(const ExposureTime &other) const
                {
                    return m_opt >= other.m_opt;
                }

                friend std::ostream &operator<<(std::ostream &stream, const ExposureTime &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return validRange().isInRange(value)
                               ? value
                               : throw std::out_of_range{ "ExposureTime{ " + std::to_string(value.count())
                                                          + " } is not in range ["
                                                          + std::to_string(validRange().min().count()) + ", "
                                                          + std::to_string(validRange().max().count()) + "]" };
                }
 
                std::optional<std::chrono::microseconds> m_opt;
 
                friend struct DataModel::Detail::Befriend<ExposureTime>;
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Gain
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "Acquisition/Gain" };

                static constexpr const char *name{ "Gain" };

                static constexpr const char *description{ R"description(Analog gain in the camera.)description" };

                using ValueType = double;

                static constexpr Range<double> validRange()
                {
                    return { 1, 16 };
                }

                Gain() = default;

                explicit constexpr Gain(double value)
                    : m_opt{ verifyValue(value) }
                {}

                double value() const;

                bool hasValue() const;

                void reset();

                std::string toString() const;

                bool operator==(const Gain &other) const
                {
                    return m_opt == other.m_opt;
                }

                bool operator!=(const Gain &other) const
                {
                    return m_opt != other.m_opt;
                }

                bool operator<(const Gain &other) const
                {
                    return m_opt < other.m_opt;
                }

                bool operator>(const Gain &other) const
                {
                    return m_opt > other.m_opt;
                }

                bool operator<=(const Gain &other) const
                {
                    return m_opt <= other.m_opt;
                }

                bool operator>=(const Gain &other) const
                {
                    return m_opt >= other.m_opt;
                }

                friend std::ostream &operator<<(std::ostream &stream, const Gain &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return validRange().isInRange(value)
                               ? value
                               : throw std::out_of_range{ "Gain{ " + std::to_string(value) + " } is not in range ["
                                                          + std::to_string(validRange().min()) + ", "
                                                          + std::to_string(validRange().max()) + "]" };
                }
 
                std::optional<double> m_opt;
 
                friend struct DataModel::Detail::Befriend<Gain>;
            };
 
            using Descendants = std::tuple<
                Settings2D::Acquisition::Aperture,
                Settings2D::Acquisition::Brightness,
                Settings2D::Acquisition::ExposureTime,
                Settings2D::Acquisition::Gain>;

            Acquisition();

#ifndef NO_DOC
            template<
                typename... Args,
                typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                typename std::enable_if<
                    Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                        value,
                    int>::type = 0>
#else
            template<typename... Args>
#endif
            explicit Acquisition(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Acquisition(...). "
                    "Types should be listed at most once.");
 
                set(std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
            template<typename... Args>
#endif
            void set(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to set(...). "
                    "Types should be listed at most once.");
 
                Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
            template<typename... Args>
#endif
            Acquisition copyWith(Args &&...args) const
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value,
                    "All arguments passed to copyWith(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to copyWith(...). "
                    "Types should be listed at most once.");
 
                auto copy{ *this };
                copy.set(std::forward<Args>(args)...);
                return copy;
            }

            const Aperture &aperture() const
            {
                return m_aperture;
            }

            Aperture &aperture()
            {
                return m_aperture;
            }

            Acquisition &set(const Aperture &value)
            {
                m_aperture = value;
                return *this;
            }

            const Brightness &brightness() const
            {
                return m_brightness;
            }

            Brightness &brightness()
            {
                return m_brightness;
            }

            Acquisition &set(const Brightness &value)
            {
                m_brightness = value;
                return *this;
            }

            const ExposureTime &exposureTime() const
            {
                return m_exposureTime;
            }

            ExposureTime &exposureTime()
            {
                return m_exposureTime;
            }

            Acquisition &set(const ExposureTime &value)
            {
                m_exposureTime = value;
                return *this;
            }

            const Gain &gain() const
            {
                return m_gain;
            }

            Gain &gain()
            {
                return m_gain;
            }

            Acquisition &set(const Gain &value)
            {
                m_gain = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Acquisition::Aperture>::value, int>::type = 0>
            const Settings2D::Acquisition::Aperture &get() const
            {
                return m_aperture;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Acquisition::Brightness>::value, int>::type = 0>
            const Settings2D::Acquisition::Brightness &get() const
            {
                return m_brightness;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Acquisition::ExposureTime>::value, int>::type = 0>
            const Settings2D::Acquisition::ExposureTime &get() const
            {
                return m_exposureTime;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Acquisition::Gain>::value, int>::type = 0>
            const Settings2D::Acquisition::Gain &get() const
            {
                return m_gain;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const Settings2D::Acquisition::Aperture &get() const
            {
                return m_aperture;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const Settings2D::Acquisition::Brightness &get() const
            {
                return m_brightness;
            }
 
            template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
            const Settings2D::Acquisition::ExposureTime &get() const
            {
                return m_exposureTime;
            }
 
            template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
            const Settings2D::Acquisition::Gain &get() const
            {
                return m_gain;
            }

            template<typename F>
            void forEach(const F &f) const
            {
                f(m_aperture);
                f(m_brightness);
                f(m_exposureTime);
                f(m_gain);
            }

            template<typename F>
            void forEach(const F &f)
            {
                f(m_aperture);
                f(m_brightness);
                f(m_exposureTime);
                f(m_gain);
            }

            bool operator==(const Acquisition &other) const;

            bool operator!=(const Acquisition &other) const;

            std::string toString() const;

            friend std::ostream &operator<<(std::ostream &stream, const Acquisition &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            void setFromString(const std::string &fullPath, const std::string &value);
 
            std::string getString(const std::string &fullPath) const;
 
            Aperture m_aperture;
            Brightness m_brightness;
            ExposureTime m_exposureTime;
            Gain m_gain;
 
            friend struct DataModel::Detail::Befriend<Acquisition>;
        };

 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Acquisitions
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafDataModelList;

            static constexpr const char *path{ "Acquisitions" };

            static constexpr const char *name{ "Acquisitions" };

            static constexpr const char *description{
                R"description(List of acquisitions used for 2D capture.)description"
            };

            using ValueType = std::vector<Settings2D::Acquisition>;

            static constexpr Range<ValueType::size_type> validSize()
            {
                return { 0, std::numeric_limits<ValueType::size_type>::max() };
            }

            Acquisitions() = default;

            explicit Acquisitions(std::vector<Settings2D::Acquisition> value)
                : m_value{ std::move(value) }
            {}

            explicit Acquisitions(std::initializer_list<Settings2D::Acquisition> value)
                : Acquisitions{ ValueType{ value } }
            {}

            const std::vector<Settings2D::Acquisition> &value() const;

            std::string toString() const;

            std::size_t size() const noexcept;

            bool isEmpty() const noexcept;

            template<typename... Args>
            void emplaceBack(Args &&...args)
            {
                m_value.emplace_back(std::forward<Args>(args)...);
            }

            Settings2D::Acquisition &at(std::size_t pos);

            const Settings2D::Acquisition &at(std::size_t pos) const;

            Settings2D::Acquisition &operator[](std::size_t pos);

            const Settings2D::Acquisition &operator[](std::size_t pos) const;

            template<typename F>
            void forEach(const F &f)
            {
                for(auto &child : m_value)
                {
                    f(child);
                }
            }

            template<typename F>
            void forEach(const F &f) const
            {
                for(const auto &child : m_value)
                {
                    f(child);
                }
            }

            using Iterator = std::vector<Settings2D::Acquisition>::iterator;

            Iterator begin() noexcept;

            Iterator end() noexcept;

            using ConstIterator = std::vector<Settings2D::Acquisition>::const_iterator;

            ConstIterator begin() const noexcept;

            ConstIterator end() const noexcept;

            ConstIterator cbegin() const noexcept;

            ConstIterator cend() const noexcept;

            bool operator==(const Acquisitions &other) const
            {
                return m_value == other.m_value;
            }

            bool operator!=(const Acquisitions &other) const
            {
                return m_value != other.m_value;
            }

            friend std::ostream &operator<<(std::ostream &stream, const Acquisitions &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            std::vector<Settings2D::Acquisition> m_value{};
 
            friend struct DataModel::Detail::Befriend<Acquisitions>;
        };

 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Processing
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

            static constexpr const char *path{ "Processing" };

            static constexpr const char *name{ "Processing" };

            static constexpr const char *description{ R"description(2D processing settings.)description" };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Color
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

                static constexpr const char *path{ "Processing/Color" };

                static constexpr const char *name{ "Color" };

                static constexpr const char *description{ R"description(Color settings.)description" };

 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Balance
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

                    static constexpr const char *path{ "Processing/Color/Balance" };

                    static constexpr const char *name{ "Balance" };

                    static constexpr const char *description{ R"description(Color balance settings.)description" };

 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Blue
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                        static constexpr const char *path{ "Processing/Color/Balance/Blue" };

                        static constexpr const char *name{ "Blue" };

                        static constexpr const char *description{
                            R"description(Digital gain applied to blue channel.)description"
                        };

                        using ValueType = double;

                        static constexpr Range<double> validRange()
                        {
                            return { 1.0, 8.0 };
                        }

                        Blue() = default;

                        explicit constexpr Blue(double value)
                            : m_opt{ verifyValue(value) }
                        {}

                        double value() const;

                        bool hasValue() const;

                        void reset();

                        std::string toString() const;

                        bool operator==(const Blue &other) const
                        {
                            return m_opt == other.m_opt;
                        }

                        bool operator!=(const Blue &other) const
                        {
                            return m_opt != other.m_opt;
                        }

                        bool operator<(const Blue &other) const
                        {
                            return m_opt < other.m_opt;
                        }

                        bool operator>(const Blue &other) const
                        {
                            return m_opt > other.m_opt;
                        }

                        bool operator<=(const Blue &other) const
                        {
                            return m_opt <= other.m_opt;
                        }

                        bool operator>=(const Blue &other) const
                        {
                            return m_opt >= other.m_opt;
                        }

                        friend std::ostream &operator<<(std::ostream &stream, const Blue &value)
                        {
                            return stream << value.toString();
                        }
 
                    private:
                        void setFromString(const std::string &value);
 
                        constexpr ValueType static verifyValue(const ValueType &value)
                        {
                            return validRange().isInRange(value)
                                       ? value
                                       : throw std::out_of_range{ "Blue{ " + std::to_string(value)
                                                                  + " } is not in range ["
                                                                  + std::to_string(validRange().min()) + ", "
                                                                  + std::to_string(validRange().max()) + "]" };
                        }
 
                        std::optional<double> m_opt;
 
                        friend struct DataModel::Detail::Befriend<Blue>;
                    };

 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Green
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                        static constexpr const char *path{ "Processing/Color/Balance/Green" };

                        static constexpr const char *name{ "Green" };

                        static constexpr const char *description{
                            R"description(Digital gain applied to green channel.)description"
                        };

                        using ValueType = double;

                        static constexpr Range<double> validRange()
                        {
                            return { 1.0, 8.0 };
                        }

                        Green() = default;

                        explicit constexpr Green(double value)
                            : m_opt{ verifyValue(value) }
                        {}

                        double value() const;

                        bool hasValue() const;

                        void reset();

                        std::string toString() const;

                        bool operator==(const Green &other) const
                        {
                            return m_opt == other.m_opt;
                        }

                        bool operator!=(const Green &other) const
                        {
                            return m_opt != other.m_opt;
                        }

                        bool operator<(const Green &other) const
                        {
                            return m_opt < other.m_opt;
                        }

                        bool operator>(const Green &other) const
                        {
                            return m_opt > other.m_opt;
                        }

                        bool operator<=(const Green &other) const
                        {
                            return m_opt <= other.m_opt;
                        }

                        bool operator>=(const Green &other) const
                        {
                            return m_opt >= other.m_opt;
                        }

                        friend std::ostream &operator<<(std::ostream &stream, const Green &value)
                        {
                            return stream << value.toString();
                        }
 
                    private:
                        void setFromString(const std::string &value);
 
                        constexpr ValueType static verifyValue(const ValueType &value)
                        {
                            return validRange().isInRange(value)
                                       ? value
                                       : throw std::out_of_range{ "Green{ " + std::to_string(value)
                                                                  + " } is not in range ["
                                                                  + std::to_string(validRange().min()) + ", "
                                                                  + std::to_string(validRange().max()) + "]" };
                        }
 
                        std::optional<double> m_opt;
 
                        friend struct DataModel::Detail::Befriend<Green>;
                    };

 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Red
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                        static constexpr const char *path{ "Processing/Color/Balance/Red" };

                        static constexpr const char *name{ "Red" };

                        static constexpr const char *description{
                            R"description(Digital gain applied to red channel.)description"
                        };

                        using ValueType = double;

                        static constexpr Range<double> validRange()
                        {
                            return { 1.0, 8.0 };
                        }

                        Red() = default;

                        explicit constexpr Red(double value)
                            : m_opt{ verifyValue(value) }
                        {}

                        double value() const;

                        bool hasValue() const;

                        void reset();

                        std::string toString() const;

                        bool operator==(const Red &other) const
                        {
                            return m_opt == other.m_opt;
                        }

                        bool operator!=(const Red &other) const
                        {
                            return m_opt != other.m_opt;
                        }

                        bool operator<(const Red &other) const
                        {
                            return m_opt < other.m_opt;
                        }

                        bool operator>(const Red &other) const
                        {
                            return m_opt > other.m_opt;
                        }

                        bool operator<=(const Red &other) const
                        {
                            return m_opt <= other.m_opt;
                        }

                        bool operator>=(const Red &other) const
                        {
                            return m_opt >= other.m_opt;
                        }

                        friend std::ostream &operator<<(std::ostream &stream, const Red &value)
                        {
                            return stream << value.toString();
                        }
 
                    private:
                        void setFromString(const std::string &value);
 
                        constexpr ValueType static verifyValue(const ValueType &value)
                        {
                            return validRange().isInRange(value)
                                       ? value
                                       : throw std::out_of_range{ "Red{ " + std::to_string(value)
                                                                  + " } is not in range ["
                                                                  + std::to_string(validRange().min()) + ", "
                                                                  + std::to_string(validRange().max()) + "]" };
                        }
 
                        std::optional<double> m_opt;
 
                        friend struct DataModel::Detail::Befriend<Red>;
                    };
 
                    using Descendants = std::tuple<
                        Settings2D::Processing::Color::Balance::Blue,
                        Settings2D::Processing::Color::Balance::Green,
                        Settings2D::Processing::Color::Balance::Red>;

                    Balance();

#ifndef NO_DOC
                    template<
                        typename... Args,
                        typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                        typename std::enable_if<
                            Zivid::Detail::TypeTraits::
                                AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
                            int>::type = 0>
#else
                    template<typename... Args>
#endif
                    explicit Balance(Args &&...args)
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to Balance(...). "
                            "Types should be listed at most once.");
 
                        set(std::forward<Args>(args)...);
                    }

#ifndef NO_DOC
                    template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
                    template<typename... Args>
#endif
                    void set(Args &&...args)
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        using AllArgsAreDescendantNodes =
                            AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                        static_assert(
                            AllArgsAreDescendantNodes::value,
                            "All arguments passed to set(...) must be descendant nodes.");
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to set(...). "
                            "Types should be listed at most once.");
 
                        Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
                    }

#ifndef NO_DOC
                    template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
                    template<typename... Args>
#endif
                    Balance copyWith(Args &&...args) const
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        using AllArgsAreDescendantNodes =
                            AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                        static_assert(
                            AllArgsAreDescendantNodes::value,
                            "All arguments passed to copyWith(...) must be descendant nodes.");
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to copyWith(...). "
                            "Types should be listed at most once.");
 
                        auto copy{ *this };
                        copy.set(std::forward<Args>(args)...);
                        return copy;
                    }

                    const Blue &blue() const
                    {
                        return m_blue;
                    }

                    Blue &blue()
                    {
                        return m_blue;
                    }

                    Balance &set(const Blue &value)
                    {
                        m_blue = value;
                        return *this;
                    }

                    const Green &green() const
                    {
                        return m_green;
                    }

                    Green &green()
                    {
                        return m_green;
                    }

                    Balance &set(const Green &value)
                    {
                        m_green = value;
                        return *this;
                    }

                    const Red &red() const
                    {
                        return m_red;
                    }

                    Red &red()
                    {
                        return m_red;
                    }

                    Balance &set(const Red &value)
                    {
                        m_red = value;
                        return *this;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings2D::Processing::Color::Balance::Blue>::value,
                            int>::type = 0>
                    const Settings2D::Processing::Color::Balance::Blue &get() const
                    {
                        return m_blue;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings2D::Processing::Color::Balance::Green>::value,
                            int>::type = 0>
                    const Settings2D::Processing::Color::Balance::Green &get() const
                    {
                        return m_green;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings2D::Processing::Color::Balance::Red>::value,
                            int>::type = 0>
                    const Settings2D::Processing::Color::Balance::Red &get() const
                    {
                        return m_red;
                    }
 
                    template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                    const Settings2D::Processing::Color::Balance::Blue &get() const
                    {
                        return m_blue;
                    }
 
                    template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                    const Settings2D::Processing::Color::Balance::Green &get() const
                    {
                        return m_green;
                    }
 
                    template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
                    const Settings2D::Processing::Color::Balance::Red &get() const
                    {
                        return m_red;
                    }

                    template<typename F>
                    void forEach(const F &f) const
                    {
                        f(m_blue);
                        f(m_green);
                        f(m_red);
                    }

                    template<typename F>
                    void forEach(const F &f)
                    {
                        f(m_blue);
                        f(m_green);
                        f(m_red);
                    }

                    bool operator==(const Balance &other) const;

                    bool operator!=(const Balance &other) const;

                    std::string toString() const;

                    friend std::ostream &operator<<(std::ostream &stream, const Balance &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    void setFromString(const std::string &fullPath, const std::string &value);
 
                    std::string getString(const std::string &fullPath) const;
 
                    Blue m_blue;
                    Green m_green;
                    Red m_red;
 
                    friend struct DataModel::Detail::Befriend<Balance>;
                };

 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Experimental
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

                    static constexpr const char *path{ "Processing/Color/Experimental" };

                    static constexpr const char *name{ "Experimental" };

                    static constexpr const char *description{
                        R"description(Experimental color settings. These may be renamed, moved or deleted in the future.)description"
                    };

 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Mode
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                        static constexpr const char *path{ "Processing/Color/Experimental/Mode" };

                        static constexpr const char *name{ "Mode" };

                        static constexpr const char *description{
                            R"description(This setting controls how the color image is computed.
 
`automatic` is the default option. It performs tone mapping for HDR captures, but not for
single-acquisition captures. Use this mode with a single acquisition if you want to have
the most control over the colors in the image.
 
`toneMapping` uses all the acquisitions to create one merged and normalized color image. For
HDR captures the dynamic range of the captured images is usually higher than the 8-bit color
image range. `toneMapping` will map the HDR color data to the 8-bit color output range by
applying a scaling factor. `toneMapping` can also be used for single-acquisition captures to
normalize the captured color image to the full 8-bit output. Note that when using `toneMapping`
mode the color values can be inconsistent over repeated captures if you move, add or remove
objects in the scene. For the most control over the colors in the single-acquisition case,
select the `automatic` mode.
)description"
                        };

                        enum class ValueType
                        {
                            automatic,
                            toneMapping
                        };
                        static const Mode automatic;   
                        static const Mode toneMapping; 

                        static std::set<ValueType> validValues()
                        {
                            return { ValueType::automatic, ValueType::toneMapping };
                        }

                        Mode() = default;

                        explicit constexpr Mode(ValueType value)
                            : m_opt{ verifyValue(value) }
                        {}

                        ValueType value() const;

                        bool hasValue() const;

                        void reset();

                        std::string toString() const;

                        friend std::ostream &operator<<(std::ostream &stream, const Mode::ValueType &value)
                        {
                            return stream << Mode{ value }.toString();
                        }

                        bool operator==(const Mode &other) const
                        {
                            return m_opt == other.m_opt;
                        }

                        bool operator!=(const Mode &other) const
                        {
                            return m_opt != other.m_opt;
                        }

                        friend std::ostream &operator<<(std::ostream &stream, const Mode &value)
                        {
                            return stream << value.toString();
                        }
 
                    private:
                        void setFromString(const std::string &value);
 
                        constexpr ValueType static verifyValue(const ValueType &value)
                        {
                            return value == ValueType::automatic || value == ValueType::toneMapping
                                       ? value
                                       : throw std::invalid_argument{
                                             "Invalid value: Mode{ "
                                             + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value))
                                             + " }"
                                         };
                        }
 
                        std::optional<ValueType> m_opt;
 
                        friend struct DataModel::Detail::Befriend<Mode>;
                    };
 
                    using Descendants = std::tuple<Settings2D::Processing::Color::Experimental::Mode>;

                    Experimental();

#ifndef NO_DOC
                    template<
                        typename... Args,
                        typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                        typename std::enable_if<
                            Zivid::Detail::TypeTraits::
                                AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
                            int>::type = 0>
#else
                    template<typename... Args>
#endif
                    explicit Experimental(Args &&...args)
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to Experimental(...). "
                            "Types should be listed at most once.");
 
                        set(std::forward<Args>(args)...);
                    }

#ifndef NO_DOC
                    template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
                    template<typename... Args>
#endif
                    void set(Args &&...args)
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        using AllArgsAreDescendantNodes =
                            AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                        static_assert(
                            AllArgsAreDescendantNodes::value,
                            "All arguments passed to set(...) must be descendant nodes.");
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to set(...). "
                            "Types should be listed at most once.");
 
                        Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
                    }

#ifndef NO_DOC
                    template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
                    template<typename... Args>
#endif
                    Experimental copyWith(Args &&...args) const
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        using AllArgsAreDescendantNodes =
                            AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                        static_assert(
                            AllArgsAreDescendantNodes::value,
                            "All arguments passed to copyWith(...) must be descendant nodes.");
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to copyWith(...). "
                            "Types should be listed at most once.");
 
                        auto copy{ *this };
                        copy.set(std::forward<Args>(args)...);
                        return copy;
                    }

                    const Mode &mode() const
                    {
                        return m_mode;
                    }

                    Mode &mode()
                    {
                        return m_mode;
                    }

                    Experimental &set(const Mode &value)
                    {
                        m_mode = value;
                        return *this;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings2D::Processing::Color::Experimental::Mode>::value,
                            int>::type = 0>
                    const Settings2D::Processing::Color::Experimental::Mode &get() const
                    {
                        return m_mode;
                    }
 
                    template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                    const Settings2D::Processing::Color::Experimental::Mode &get() const
                    {
                        return m_mode;
                    }

                    template<typename F>
                    void forEach(const F &f) const
                    {
                        f(m_mode);
                    }

                    template<typename F>
                    void forEach(const F &f)
                    {
                        f(m_mode);
                    }

                    bool operator==(const Experimental &other) const;

                    bool operator!=(const Experimental &other) const;

                    std::string toString() const;

                    friend std::ostream &operator<<(std::ostream &stream, const Experimental &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    void setFromString(const std::string &fullPath, const std::string &value);
 
                    std::string getString(const std::string &fullPath) const;
 
                    Mode m_mode;
 
                    friend struct DataModel::Detail::Befriend<Experimental>;
                };

 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Gamma
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                    static constexpr const char *path{ "Processing/Color/Gamma" };

                    static constexpr const char *name{ "Gamma" };

                    static constexpr const char *description{
                        R"description(Gamma applied to the color values. Gamma less than 1 makes the colors brighter, while gamma
greater than 1 makes the colors darker.
)description"
                    };

                    using ValueType = double;

                    static constexpr Range<double> validRange()
                    {
                        return { 0.25, 1.5 };
                    }

                    Gamma() = default;

                    explicit constexpr Gamma(double value)
                        : m_opt{ verifyValue(value) }
                    {}

                    double value() const;

                    bool hasValue() const;

                    void reset();

                    std::string toString() const;

                    bool operator==(const Gamma &other) const
                    {
                        return m_opt == other.m_opt;
                    }

                    bool operator!=(const Gamma &other) const
                    {
                        return m_opt != other.m_opt;
                    }

                    bool operator<(const Gamma &other) const
                    {
                        return m_opt < other.m_opt;
                    }

                    bool operator>(const Gamma &other) const
                    {
                        return m_opt > other.m_opt;
                    }

                    bool operator<=(const Gamma &other) const
                    {
                        return m_opt <= other.m_opt;
                    }

                    bool operator>=(const Gamma &other) const
                    {
                        return m_opt >= other.m_opt;
                    }

                    friend std::ostream &operator<<(std::ostream &stream, const Gamma &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    constexpr ValueType static verifyValue(const ValueType &value)
                    {
                        return validRange().isInRange(value)
                                   ? value
                                   : throw std::out_of_range{ "Gamma{ " + std::to_string(value) + " } is not in range ["
                                                              + std::to_string(validRange().min()) + ", "
                                                              + std::to_string(validRange().max()) + "]" };
                    }
 
                    std::optional<double> m_opt;
 
                    friend struct DataModel::Detail::Befriend<Gamma>;
                };
 
                using Descendants = std::tuple<
                    Settings2D::Processing::Color::Balance,
                    Settings2D::Processing::Color::Balance::Blue,
                    Settings2D::Processing::Color::Balance::Green,
                    Settings2D::Processing::Color::Balance::Red,
                    Settings2D::Processing::Color::Experimental,
                    Settings2D::Processing::Color::Experimental::Mode,
                    Settings2D::Processing::Color::Gamma>;

                Color();

#ifndef NO_DOC
                template<
                    typename... Args,
                    typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                    typename std::enable_if<
                        Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                            value,
                        int>::type = 0>
#else
                template<typename... Args>
#endif
                explicit Color(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to Color(...). "
                        "Types should be listed at most once.");
 
                    set(std::forward<Args>(args)...);
                }

#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
                template<typename... Args>
#endif
                void set(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to set(...). "
                        "Types should be listed at most once.");
 
                    Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
                }

#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
                template<typename... Args>
#endif
                Color copyWith(Args &&...args) const
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value,
                        "All arguments passed to copyWith(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to copyWith(...). "
                        "Types should be listed at most once.");
 
                    auto copy{ *this };
                    copy.set(std::forward<Args>(args)...);
                    return copy;
                }

                const Balance &balance() const
                {
                    return m_balance;
                }

                Balance &balance()
                {
                    return m_balance;
                }

                Color &set(const Balance &value)
                {
                    m_balance = value;
                    return *this;
                }

                Color &set(const Balance::Blue &value)
                {
                    m_balance.set(value);
                    return *this;
                }

                Color &set(const Balance::Green &value)
                {
                    m_balance.set(value);
                    return *this;
                }

                Color &set(const Balance::Red &value)
                {
                    m_balance.set(value);
                    return *this;
                }

                const Experimental &experimental() const
                {
                    return m_experimental;
                }

                Experimental &experimental()
                {
                    return m_experimental;
                }

                Color &set(const Experimental &value)
                {
                    m_experimental = value;
                    return *this;
                }

                Color &set(const Experimental::Mode &value)
                {
                    m_experimental.set(value);
                    return *this;
                }

                const Gamma &gamma() const
                {
                    return m_gamma;
                }

                Gamma &gamma()
                {
                    return m_gamma;
                }

                Color &set(const Gamma &value)
                {
                    m_gamma = value;
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Balance>::value, int>::type =
                        0>
                const Settings2D::Processing::Color::Balance &get() const
                {
                    return m_balance;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Balance::Blue>::value, int>::
                        type = 0>
                const Settings2D::Processing::Color::Balance::Blue &get() const
                {
                    return m_balance.get<Settings2D::Processing::Color::Balance::Blue>();
                }
 
                template<
                    typename T,
                    typename std::
                        enable_if<std::is_same<T, Settings2D::Processing::Color::Balance::Green>::value, int>::type = 0>
                const Settings2D::Processing::Color::Balance::Green &get() const
                {
                    return m_balance.get<Settings2D::Processing::Color::Balance::Green>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Balance::Red>::value, int>::
                        type = 0>
                const Settings2D::Processing::Color::Balance::Red &get() const
                {
                    return m_balance.get<Settings2D::Processing::Color::Balance::Red>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Experimental>::value, int>::
                        type = 0>
                const Settings2D::Processing::Color::Experimental &get() const
                {
                    return m_experimental;
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings2D::Processing::Color::Experimental::Mode>::value,
                        int>::type = 0>
                const Settings2D::Processing::Color::Experimental::Mode &get() const
                {
                    return m_experimental.get<Settings2D::Processing::Color::Experimental::Mode>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Gamma>::value, int>::type =
                        0>
                const Settings2D::Processing::Color::Gamma &get() const
                {
                    return m_gamma;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const Settings2D::Processing::Color::Balance &get() const
                {
                    return m_balance;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const Settings2D::Processing::Color::Experimental &get() const
                {
                    return m_experimental;
                }
 
                template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
                const Settings2D::Processing::Color::Gamma &get() const
                {
                    return m_gamma;
                }

                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_balance);
                    f(m_experimental);
                    f(m_gamma);
                }

                template<typename F>
                void forEach(const F &f)
                {
                    f(m_balance);
                    f(m_experimental);
                    f(m_gamma);
                }

                bool operator==(const Color &other) const;

                bool operator!=(const Color &other) const;

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const Color &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                void setFromString(const std::string &fullPath, const std::string &value);
 
                std::string getString(const std::string &fullPath) const;
 
                Balance m_balance;
                Experimental m_experimental;
                Gamma m_gamma;
 
                friend struct DataModel::Detail::Befriend<Color>;
            };
 
            using Descendants = std::tuple<
                Settings2D::Processing::Color,
                Settings2D::Processing::Color::Balance,
                Settings2D::Processing::Color::Balance::Blue,
                Settings2D::Processing::Color::Balance::Green,
                Settings2D::Processing::Color::Balance::Red,
                Settings2D::Processing::Color::Experimental,
                Settings2D::Processing::Color::Experimental::Mode,
                Settings2D::Processing::Color::Gamma>;

            Processing();

#ifndef NO_DOC
            template<
                typename... Args,
                typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                typename std::enable_if<
                    Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                        value,
                    int>::type = 0>
#else
            template<typename... Args>
#endif
            explicit Processing(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Processing(...). "
                    "Types should be listed at most once.");
 
                set(std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
            template<typename... Args>
#endif
            void set(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to set(...). "
                    "Types should be listed at most once.");
 
                Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
            template<typename... Args>
#endif
            Processing copyWith(Args &&...args) const
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value,
                    "All arguments passed to copyWith(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to copyWith(...). "
                    "Types should be listed at most once.");
 
                auto copy{ *this };
                copy.set(std::forward<Args>(args)...);
                return copy;
            }

            const Color &color() const
            {
                return m_color;
            }

            Color &color()
            {
                return m_color;
            }

            Processing &set(const Color &value)
            {
                m_color = value;
                return *this;
            }

            Processing &set(const Color::Balance &value)
            {
                m_color.set(value);
                return *this;
            }

            Processing &set(const Color::Balance::Blue &value)
            {
                m_color.set(value);
                return *this;
            }

            Processing &set(const Color::Balance::Green &value)
            {
                m_color.set(value);
                return *this;
            }

            Processing &set(const Color::Balance::Red &value)
            {
                m_color.set(value);
                return *this;
            }

            Processing &set(const Color::Experimental &value)
            {
                m_color.set(value);
                return *this;
            }

            Processing &set(const Color::Experimental::Mode &value)
            {
                m_color.set(value);
                return *this;
            }

            Processing &set(const Color::Gamma &value)
            {
                m_color.set(value);
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Processing::Color>::value, int>::type = 0>
            const Settings2D::Processing::Color &get() const
            {
                return m_color;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Balance>::value, int>::type = 0>
            const Settings2D::Processing::Color::Balance &get() const
            {
                return m_color.get<Settings2D::Processing::Color::Balance>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Balance::Blue>::value, int>::
                    type = 0>
            const Settings2D::Processing::Color::Balance::Blue &get() const
            {
                return m_color.get<Settings2D::Processing::Color::Balance::Blue>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Balance::Green>::value, int>::
                    type = 0>
            const Settings2D::Processing::Color::Balance::Green &get() const
            {
                return m_color.get<Settings2D::Processing::Color::Balance::Green>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Balance::Red>::value, int>::
                    type = 0>
            const Settings2D::Processing::Color::Balance::Red &get() const
            {
                return m_color.get<Settings2D::Processing::Color::Balance::Red>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Experimental>::value, int>::
                    type = 0>
            const Settings2D::Processing::Color::Experimental &get() const
            {
                return m_color.get<Settings2D::Processing::Color::Experimental>();
            }
 
            template<
                typename T,
                typename std::
                    enable_if<std::is_same<T, Settings2D::Processing::Color::Experimental::Mode>::value, int>::type = 0>
            const Settings2D::Processing::Color::Experimental::Mode &get() const
            {
                return m_color.get<Settings2D::Processing::Color::Experimental::Mode>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Gamma>::value, int>::type = 0>
            const Settings2D::Processing::Color::Gamma &get() const
            {
                return m_color.get<Settings2D::Processing::Color::Gamma>();
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const Settings2D::Processing::Color &get() const
            {
                return m_color;
            }

            template<typename F>
            void forEach(const F &f) const
            {
                f(m_color);
            }

            template<typename F>
            void forEach(const F &f)
            {
                f(m_color);
            }

            bool operator==(const Processing &other) const;

            bool operator!=(const Processing &other) const;

            std::string toString() const;

            friend std::ostream &operator<<(std::ostream &stream, const Processing &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            void setFromString(const std::string &fullPath, const std::string &value);
 
            std::string getString(const std::string &fullPath) const;
 
            Color m_color;
 
            friend struct DataModel::Detail::Befriend<Processing>;
        };

 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Sampling
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

            static constexpr const char *path{ "Sampling" };

            static constexpr const char *name{ "Sampling" };

            static constexpr const char *description{ R"description(Sampling settings.
)description" };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Color
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "Sampling/Color" };

                static constexpr const char *name{ "Color" };

                static constexpr const char *description{ R"description(Choose how to sample colors for the 2D image.
 
- `rgb` option gives an image with full colors.
- `grayscale` option gives a grayscale (r=g=b) image, which
  can be acquired faster than full colors.
- `rgbStrongAmbientLight` option gives an image with full colors and reduced
  color noise. This option should be chosen only for applications which
  suffer from high color noise and with high amounts of ambient light in the
  scene.
- `rgbAmbientSuppression` option gives an image with full colors while
  suppressing the ambient light. The Zivid 2+R and Zivid 3 cameras suppress ambient
  light by default, and therefore do not need the additional option
  `rgbAmbientSuppression`.
 
 
The `grayscale`, `rgbStrongAmbientLight` and `rgbAmbientSuppression` options are not available on all camera models.
)description" };

                enum class ValueType
                {
                    rgb,
                    grayscale,
                    rgbStrongAmbientLight,
                    rgbAmbientSuppression
                };
                static const Color rgb;                   
                static const Color grayscale;             
                static const Color rgbStrongAmbientLight; 
                static const Color rgbAmbientSuppression; 

                static std::set<ValueType> validValues()
                {
                    return { ValueType::rgb,
                             ValueType::grayscale,
                             ValueType::rgbStrongAmbientLight,
                             ValueType::rgbAmbientSuppression };
                }

                Color() = default;

                explicit constexpr Color(ValueType value)
                    : m_opt{ verifyValue(value) }
                {}

                ValueType value() const;

                bool hasValue() const;

                void reset();

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const Color::ValueType &value)
                {
                    return stream << Color{ value }.toString();
                }

                bool operator==(const Color &other) const
                {
                    return m_opt == other.m_opt;
                }

                bool operator!=(const Color &other) const
                {
                    return m_opt != other.m_opt;
                }

                friend std::ostream &operator<<(std::ostream &stream, const Color &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return value == ValueType::rgb || value == ValueType::grayscale
                                   || value == ValueType::rgbStrongAmbientLight
                                   || value == ValueType::rgbAmbientSuppression
                               ? value
                               : throw std::invalid_argument{
                                     "Invalid value: Color{ "
                                     + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                                 };
                }
 
                std::optional<ValueType> m_opt;
 
                friend struct DataModel::Detail::Befriend<Color>;
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Interval
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

                static constexpr const char *path{ "Sampling/Interval" };

                static constexpr const char *name{ "Interval" };

                static constexpr const char *description{
                    R"description(Sampling interval controls the interval between successive sensor operations (e.g.,
structured light pattern projection and image exposure), aligned to external
frequencies (e.g., 50 Hz, 60 Hz grid) or to other devices (e.g., barcode scanners
at 100 Hz). The requested interval is a target: the sensor operations will happen
at this rate if the it can fit the chosen exposure time plus some processing overhead.
Otherwise, the sampling interval is rounded up to the nearest suitable integer multiple
(e.g., n * 10 ms for 100 Hz and n * 8.33 ms for 120 Hz).
)description"
                };

 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Duration
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                    static constexpr const char *path{ "Sampling/Interval/Duration" };

                    static constexpr const char *name{ "Duration" };

                    static constexpr const char *description{
                        R"description(Duration between successive sensor operations, in microseconds. The effective interval
might be rounded up to the nearest suitable integer multiple and will never be shorter
than exposure time plus some processing overhead.
)description"
                    };

                    using ValueType = std::chrono::microseconds;

                    static constexpr Range<std::chrono::microseconds> validRange()
                    {
                        return { std::chrono::microseconds{ 1000 }, std::chrono::microseconds{ 10000 } };
                    }

                    Duration() = default;

                    explicit constexpr Duration(std::chrono::microseconds value)
                        : m_opt{ verifyValue(value) }
                    {}

                    std::chrono::microseconds value() const;

                    bool hasValue() const;

                    void reset();

                    std::string toString() const;

                    bool operator==(const Duration &other) const
                    {
                        return m_opt == other.m_opt;
                    }

                    bool operator!=(const Duration &other) const
                    {
                        return m_opt != other.m_opt;
                    }

                    bool operator<(const Duration &other) const
                    {
                        return m_opt < other.m_opt;
                    }

                    bool operator>(const Duration &other) const
                    {
                        return m_opt > other.m_opt;
                    }

                    bool operator<=(const Duration &other) const
                    {
                        return m_opt <= other.m_opt;
                    }

                    bool operator>=(const Duration &other) const
                    {
                        return m_opt >= other.m_opt;
                    }

                    friend std::ostream &operator<<(std::ostream &stream, const Duration &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    constexpr ValueType static verifyValue(const ValueType &value)
                    {
                        return validRange().isInRange(value)
                                   ? value
                                   : throw std::out_of_range{ "Duration{ " + std::to_string(value.count())
                                                              + " } is not in range ["
                                                              + std::to_string(validRange().min().count()) + ", "
                                                              + std::to_string(validRange().max().count()) + "]" };
                    }
 
                    std::optional<std::chrono::microseconds> m_opt;
 
                    friend struct DataModel::Detail::Befriend<Duration>;
                };

 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Enabled
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                    static constexpr const char *path{ "Sampling/Interval/Enabled" };

                    static constexpr const char *name{ "Enabled" };

                    static constexpr const char *description{
                        R"description(Enable or disable sampling interval.)description"
                    };

                    using ValueType = bool;
                    static const Enabled yes; 
                    static const Enabled no;  

                    static std::set<bool> validValues()
                    {
                        return { false, true };
                    }

                    Enabled() = default;

                    explicit constexpr Enabled(bool value)
                        : m_opt{ value }
                    {}

                    bool value() const;

                    bool hasValue() const;

                    void reset();

                    std::string toString() const;

                    bool operator==(const Enabled &other) const
                    {
                        return m_opt == other.m_opt;
                    }

                    bool operator!=(const Enabled &other) const
                    {
                        return m_opt != other.m_opt;
                    }

                    friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    std::optional<bool> m_opt;
 
                    friend struct DataModel::Detail::Befriend<Enabled>;
                };
 
                using Descendants =
                    std::tuple<Settings2D::Sampling::Interval::Duration, Settings2D::Sampling::Interval::Enabled>;

                Interval();

#ifndef NO_DOC
                template<
                    typename... Args,
                    typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                    typename std::enable_if<
                        Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                            value,
                        int>::type = 0>
#else
                template<typename... Args>
#endif
                explicit Interval(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to Interval(...). "
                        "Types should be listed at most once.");
 
                    set(std::forward<Args>(args)...);
                }

#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
                template<typename... Args>
#endif
                void set(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to set(...). "
                        "Types should be listed at most once.");
 
                    Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
                }

#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
                template<typename... Args>
#endif
                Interval copyWith(Args &&...args) const
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value,
                        "All arguments passed to copyWith(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to copyWith(...). "
                        "Types should be listed at most once.");
 
                    auto copy{ *this };
                    copy.set(std::forward<Args>(args)...);
                    return copy;
                }

                const Duration &duration() const
                {
                    return m_duration;
                }

                Duration &duration()
                {
                    return m_duration;
                }

                Interval &set(const Duration &value)
                {
                    m_duration = value;
                    return *this;
                }

                const Enabled &isEnabled() const
                {
                    return m_enabled;
                }

                Enabled &isEnabled()
                {
                    return m_enabled;
                }

                Interval &set(const Enabled &value)
                {
                    m_enabled = value;
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings2D::Sampling::Interval::Duration>::value, int>::
                        type = 0>
                const Settings2D::Sampling::Interval::Duration &get() const
                {
                    return m_duration;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings2D::Sampling::Interval::Enabled>::value, int>::
                        type = 0>
                const Settings2D::Sampling::Interval::Enabled &get() const
                {
                    return m_enabled;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const Settings2D::Sampling::Interval::Duration &get() const
                {
                    return m_duration;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const Settings2D::Sampling::Interval::Enabled &get() const
                {
                    return m_enabled;
                }

                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_duration);
                    f(m_enabled);
                }

                template<typename F>
                void forEach(const F &f)
                {
                    f(m_duration);
                    f(m_enabled);
                }

                bool operator==(const Interval &other) const;

                bool operator!=(const Interval &other) const;

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const Interval &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                void setFromString(const std::string &fullPath, const std::string &value);
 
                std::string getString(const std::string &fullPath) const;
 
                Duration m_duration;
                Enabled m_enabled;
 
                friend struct DataModel::Detail::Befriend<Interval>;
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Pixel
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "Sampling/Pixel" };

                static constexpr const char *name{ "Pixel" };

                static constexpr const char *description{
                    R"description(Set the pixel sampling to use for the 2D capture. This setting defines how the camera sensor is sampled.
When doing 2D+3D capture, picking the same value that is used for 3D is generally recommended.
)description"
                };

                enum class ValueType
                {
                    all,
                    blueSubsample2x2,
                    redSubsample2x2,
                    blueSubsample4x4,
                    redSubsample4x4,
                    by2x2,
                    by4x4
                };
                static const Pixel all;              
                static const Pixel blueSubsample2x2; 
                static const Pixel redSubsample2x2;  
                static const Pixel blueSubsample4x4; 
                static const Pixel redSubsample4x4;  
                static const Pixel by2x2;            
                static const Pixel by4x4;            

                static std::set<ValueType> validValues()
                {
                    return { ValueType::all,
                             ValueType::blueSubsample2x2,
                             ValueType::redSubsample2x2,
                             ValueType::blueSubsample4x4,
                             ValueType::redSubsample4x4,
                             ValueType::by2x2,
                             ValueType::by4x4 };
                }

                Pixel() = default;

                explicit constexpr Pixel(ValueType value)
                    : m_opt{ verifyValue(value) }
                {}

                ValueType value() const;

                bool hasValue() const;

                void reset();

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const Pixel::ValueType &value)
                {
                    return stream << Pixel{ value }.toString();
                }

                bool operator==(const Pixel &other) const
                {
                    return m_opt == other.m_opt;
                }

                bool operator!=(const Pixel &other) const
                {
                    return m_opt != other.m_opt;
                }

                friend std::ostream &operator<<(std::ostream &stream, const Pixel &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return value == ValueType::all || value == ValueType::blueSubsample2x2
                                   || value == ValueType::redSubsample2x2 || value == ValueType::blueSubsample4x4
                                   || value == ValueType::redSubsample4x4 || value == ValueType::by2x2
                                   || value == ValueType::by4x4
                               ? value
                               : throw std::invalid_argument{
                                     "Invalid value: Pixel{ "
                                     + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                                 };
                }
 
                std::optional<ValueType> m_opt;
 
                friend struct DataModel::Detail::Befriend<Pixel>;
            };
 
            using Descendants = std::tuple<
                Settings2D::Sampling::Color,
                Settings2D::Sampling::Interval,
                Settings2D::Sampling::Interval::Duration,
                Settings2D::Sampling::Interval::Enabled,
                Settings2D::Sampling::Pixel>;

            Sampling();

#ifndef NO_DOC
            template<
                typename... Args,
                typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                typename std::enable_if<
                    Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                        value,
                    int>::type = 0>
#else
            template<typename... Args>
#endif
            explicit Sampling(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Sampling(...). "
                    "Types should be listed at most once.");
 
                set(std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
            template<typename... Args>
#endif
            void set(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to set(...). "
                    "Types should be listed at most once.");
 
                Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
            template<typename... Args>
#endif
            Sampling copyWith(Args &&...args) const
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value,
                    "All arguments passed to copyWith(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to copyWith(...). "
                    "Types should be listed at most once.");
 
                auto copy{ *this };
                copy.set(std::forward<Args>(args)...);
                return copy;
            }

            const Color &color() const
            {
                return m_color;
            }

            Color &color()
            {
                return m_color;
            }

            Sampling &set(const Color &value)
            {
                m_color = value;
                return *this;
            }

            const Interval &interval() const
            {
                return m_interval;
            }

            Interval &interval()
            {
                return m_interval;
            }

            Sampling &set(const Interval &value)
            {
                m_interval = value;
                return *this;
            }

            Sampling &set(const Interval::Duration &value)
            {
                m_interval.set(value);
                return *this;
            }

            Sampling &set(const Interval::Enabled &value)
            {
                m_interval.set(value);
                return *this;
            }

            const Pixel &pixel() const
            {
                return m_pixel;
            }

            Pixel &pixel()
            {
                return m_pixel;
            }

            Sampling &set(const Pixel &value)
            {
                m_pixel = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Sampling::Color>::value, int>::type = 0>
            const Settings2D::Sampling::Color &get() const
            {
                return m_color;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Sampling::Interval>::value, int>::type = 0>
            const Settings2D::Sampling::Interval &get() const
            {
                return m_interval;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Sampling::Interval::Duration>::value, int>::type =
                    0>
            const Settings2D::Sampling::Interval::Duration &get() const
            {
                return m_interval.get<Settings2D::Sampling::Interval::Duration>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Sampling::Interval::Enabled>::value, int>::type = 0>
            const Settings2D::Sampling::Interval::Enabled &get() const
            {
                return m_interval.get<Settings2D::Sampling::Interval::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings2D::Sampling::Pixel>::value, int>::type = 0>
            const Settings2D::Sampling::Pixel &get() const
            {
                return m_pixel;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const Settings2D::Sampling::Color &get() const
            {
                return m_color;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const Settings2D::Sampling::Interval &get() const
            {
                return m_interval;
            }
 
            template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
            const Settings2D::Sampling::Pixel &get() const
            {
                return m_pixel;
            }

            template<typename F>
            void forEach(const F &f) const
            {
                f(m_color);
                f(m_interval);
                f(m_pixel);
            }

            template<typename F>
            void forEach(const F &f)
            {
                f(m_color);
                f(m_interval);
                f(m_pixel);
            }

            bool operator==(const Sampling &other) const;

            bool operator!=(const Sampling &other) const;

            std::string toString() const;

            friend std::ostream &operator<<(std::ostream &stream, const Sampling &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            void setFromString(const std::string &fullPath, const std::string &value);
 
            std::string getString(const std::string &fullPath) const;
 
            Color m_color;
            Interval m_interval;
            Pixel m_pixel;
 
            friend struct DataModel::Detail::Befriend<Sampling>;
        };
 
        using Descendants = std::tuple<
            Settings2D::Acquisitions,
            Settings2D::Processing,
            Settings2D::Processing::Color,
            Settings2D::Processing::Color::Balance,
            Settings2D::Processing::Color::Balance::Blue,
            Settings2D::Processing::Color::Balance::Green,
            Settings2D::Processing::Color::Balance::Red,
            Settings2D::Processing::Color::Experimental,
            Settings2D::Processing::Color::Experimental::Mode,
            Settings2D::Processing::Color::Gamma,
            Settings2D::Sampling,
            Settings2D::Sampling::Color,
            Settings2D::Sampling::Interval,
            Settings2D::Sampling::Interval::Duration,
            Settings2D::Sampling::Interval::Enabled,
            Settings2D::Sampling::Pixel>;

        Settings2D();

        explicit Settings2D(const std::string &fileName);

        [[nodiscard]] static Settings2D fromSerialized(const std::string &value);

        std::string serialize() const;

#ifndef NO_DOC
        template<
            typename... Args,
            typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
            typename std::enable_if<
                Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
                int>::type = 0>
#else
        template<typename... Args>
#endif
        explicit Settings2D(Args &&...args)
        {
            using namespace Zivid::Detail::TypeTraits;
 
            static_assert(
                AllArgsDecayedAreUnique<Args...>::value,
                "Found duplicate types among the arguments passed to Settings2D(...). "
                "Types should be listed at most once.");
 
            set(std::forward<Args>(args)...);
        }

#ifndef NO_DOC
        template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
        template<typename... Args>
#endif
        void set(Args &&...args)
        {
            using namespace Zivid::Detail::TypeTraits;
 
            using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
            static_assert(
                AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
            static_assert(
                AllArgsDecayedAreUnique<Args...>::value,
                "Found duplicate types among the arguments passed to set(...). "
                "Types should be listed at most once.");
 
            Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
        }

#ifndef NO_DOC
        template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
        template<typename... Args>
#endif
        Settings2D copyWith(Args &&...args) const
        {
            using namespace Zivid::Detail::TypeTraits;
 
            using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
            static_assert(
                AllArgsAreDescendantNodes::value, "All arguments passed to copyWith(...) must be descendant nodes.");
 
            static_assert(
                AllArgsDecayedAreUnique<Args...>::value,
                "Found duplicate types among the arguments passed to copyWith(...). "
                "Types should be listed at most once.");
 
            auto copy{ *this };
            copy.set(std::forward<Args>(args)...);
            return copy;
        }

        const Acquisitions &acquisitions() const
        {
            return m_acquisitions;
        }

        Acquisitions &acquisitions()
        {
            return m_acquisitions;
        }

        Settings2D &set(const Acquisitions &value)
        {
            m_acquisitions = value;
            return *this;
        }

        const Processing &processing() const
        {
            return m_processing;
        }

        Processing &processing()
        {
            return m_processing;
        }

        Settings2D &set(const Processing &value)
        {
            m_processing = value;
            return *this;
        }

        Settings2D &set(const Processing::Color &value)
        {
            m_processing.set(value);
            return *this;
        }

        Settings2D &set(const Processing::Color::Balance &value)
        {
            m_processing.set(value);
            return *this;
        }

        Settings2D &set(const Processing::Color::Balance::Blue &value)
        {
            m_processing.set(value);
            return *this;
        }

        Settings2D &set(const Processing::Color::Balance::Green &value)
        {
            m_processing.set(value);
            return *this;
        }

        Settings2D &set(const Processing::Color::Balance::Red &value)
        {
            m_processing.set(value);
            return *this;
        }

        Settings2D &set(const Processing::Color::Experimental &value)
        {
            m_processing.set(value);
            return *this;
        }

        Settings2D &set(const Processing::Color::Experimental::Mode &value)
        {
            m_processing.set(value);
            return *this;
        }

        Settings2D &set(const Processing::Color::Gamma &value)
        {
            m_processing.set(value);
            return *this;
        }

        const Sampling &sampling() const
        {
            return m_sampling;
        }

        Sampling &sampling()
        {
            return m_sampling;
        }

        Settings2D &set(const Sampling &value)
        {
            m_sampling = value;
            return *this;
        }

        Settings2D &set(const Sampling::Color &value)
        {
            m_sampling.set(value);
            return *this;
        }

        Settings2D &set(const Sampling::Interval &value)
        {
            m_sampling.set(value);
            return *this;
        }

        Settings2D &set(const Sampling::Interval::Duration &value)
        {
            m_sampling.set(value);
            return *this;
        }

        Settings2D &set(const Sampling::Interval::Enabled &value)
        {
            m_sampling.set(value);
            return *this;
        }

        Settings2D &set(const Sampling::Pixel &value)
        {
            m_sampling.set(value);
            return *this;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings2D::Acquisitions>::value, int>::type = 0>
        const Settings2D::Acquisitions &get() const
        {
            return m_acquisitions;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings2D::Processing>::value, int>::type = 0>
        const Settings2D::Processing &get() const
        {
            return m_processing;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings2D::Processing::Color>::value, int>::type = 0>
        const Settings2D::Processing::Color &get() const
        {
            return m_processing.get<Settings2D::Processing::Color>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Balance>::value, int>::type = 0>
        const Settings2D::Processing::Color::Balance &get() const
        {
            return m_processing.get<Settings2D::Processing::Color::Balance>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Balance::Blue>::value, int>::type =
                0>
        const Settings2D::Processing::Color::Balance::Blue &get() const
        {
            return m_processing.get<Settings2D::Processing::Color::Balance::Blue>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Balance::Green>::value, int>::type =
                0>
        const Settings2D::Processing::Color::Balance::Green &get() const
        {
            return m_processing.get<Settings2D::Processing::Color::Balance::Green>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Balance::Red>::value, int>::type = 0>
        const Settings2D::Processing::Color::Balance::Red &get() const
        {
            return m_processing.get<Settings2D::Processing::Color::Balance::Red>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Experimental>::value, int>::type = 0>
        const Settings2D::Processing::Color::Experimental &get() const
        {
            return m_processing.get<Settings2D::Processing::Color::Experimental>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Experimental::Mode>::value, int>::
                type = 0>
        const Settings2D::Processing::Color::Experimental::Mode &get() const
        {
            return m_processing.get<Settings2D::Processing::Color::Experimental::Mode>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings2D::Processing::Color::Gamma>::value, int>::type = 0>
        const Settings2D::Processing::Color::Gamma &get() const
        {
            return m_processing.get<Settings2D::Processing::Color::Gamma>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings2D::Sampling>::value, int>::type = 0>
        const Settings2D::Sampling &get() const
        {
            return m_sampling;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings2D::Sampling::Color>::value, int>::type = 0>
        const Settings2D::Sampling::Color &get() const
        {
            return m_sampling.get<Settings2D::Sampling::Color>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings2D::Sampling::Interval>::value, int>::type = 0>
        const Settings2D::Sampling::Interval &get() const
        {
            return m_sampling.get<Settings2D::Sampling::Interval>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings2D::Sampling::Interval::Duration>::value, int>::type = 0>
        const Settings2D::Sampling::Interval::Duration &get() const
        {
            return m_sampling.get<Settings2D::Sampling::Interval::Duration>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings2D::Sampling::Interval::Enabled>::value, int>::type = 0>
        const Settings2D::Sampling::Interval::Enabled &get() const
        {
            return m_sampling.get<Settings2D::Sampling::Interval::Enabled>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings2D::Sampling::Pixel>::value, int>::type = 0>
        const Settings2D::Sampling::Pixel &get() const
        {
            return m_sampling.get<Settings2D::Sampling::Pixel>();
        }
 
        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
        const Settings2D::Acquisitions &get() const
        {
            return m_acquisitions;
        }
 
        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
        const Settings2D::Processing &get() const
        {
            return m_processing;
        }
 
        template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
        const Settings2D::Sampling &get() const
        {
            return m_sampling;
        }

        template<typename F>
        void forEach(const F &f) const
        {
            f(m_acquisitions);
            f(m_processing);
            f(m_sampling);
        }

        template<typename F>
        void forEach(const F &f)
        {
            f(m_acquisitions);
            f(m_processing);
            f(m_sampling);
        }

        bool operator==(const Settings2D &other) const;

        bool operator!=(const Settings2D &other) const;

        std::string toString() const;

        friend std::ostream &operator<<(std::ostream &stream, const Settings2D &value)
        {
            return stream << value.toString();
        }

        void save(const std::string &fileName) const;

        void load(const std::string &fileName);
 
    private:
        void setFromString(const std::string &value);
 
        void setFromString(const std::string &fullPath, const std::string &value);
 
        std::string getString(const std::string &fullPath) const;
 
        Acquisitions m_acquisitions;
        Processing m_processing;
        Sampling m_sampling;
 
        friend struct DataModel::Detail::Befriend<Settings2D>;
    };
 
#ifndef NO_DOC
    template<>
    struct Settings2D::Version<8>
    {
        using Type = Settings2D;
    };
#endif
 
} // namespace Zivid
 
#ifndef NO_DOC
namespace Zivid::Detail
{
 
    ZIVID_CORE_EXPORT void save(const Zivid::Settings2D &dataModel, std::ostream &ostream);
    ZIVID_CORE_EXPORT void load(Zivid::Settings2D &dataModel, std::istream &istream);
 
    ZIVID_CORE_EXPORT std::vector<uint8_t> serializeToBinaryVector(const Zivid::Settings2D &source);
    ZIVID_CORE_EXPORT void deserializeFromBinaryVector(Zivid::Settings2D &dest, const std::vector<uint8_t> &data);
 
} // namespace Zivid::Detail
#endif
 
#ifdef _MSC_VER
#    pragma warning(pop)
#endif
 
#ifndef NO_DOC
#    if !(defined(_MSC_VER) && (_MSC_VER <= 1900))
namespace std // NOLINT
{
 
    template<>
    struct tuple_size<Zivid::Settings2D::Processing> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings2D::Processing>
    {
        static_assert(i < tuple_size<Zivid::Settings2D::Processing>::value, "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings2D::Processing>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings2D::Processing::Color> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings2D::Processing::Color>
    {
        static_assert(i < tuple_size<Zivid::Settings2D::Processing::Color>::value, "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings2D::Processing::Color>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings2D::Processing::Color::Balance> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings2D::Processing::Color::Balance>
    {
        static_assert(
            i < tuple_size<Zivid::Settings2D::Processing::Color::Balance>::value,
            "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings2D::Processing::Color::Balance>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings2D::Processing::Color::Experimental> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings2D::Processing::Color::Experimental>
    {
        static_assert(
            i < tuple_size<Zivid::Settings2D::Processing::Color::Experimental>::value,
            "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings2D::Processing::Color::Experimental>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings2D::Sampling> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings2D::Sampling>
    {
        static_assert(i < tuple_size<Zivid::Settings2D::Sampling>::value, "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings2D::Sampling>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings2D::Sampling::Interval> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings2D::Sampling::Interval>
    {
        static_assert(i < tuple_size<Zivid::Settings2D::Sampling::Interval>::value, "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings2D::Sampling::Interval>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings2D> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings2D>
    {
        static_assert(i < tuple_size<Zivid::Settings2D>::value, "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings2D>().get<i>());
    };
 
} // namespace std
#    endif
#endif
 
// If we have access to the DataModel library, automatically include internal DataModel
// header. This header is necessary for serialization and deserialization.
#if defined(__has_include) && !defined(NO_DOC)
#    if __has_include("Zivid/Settings2DInternal.h") && __has_include("Zivid/DataModelNodeMetaData.h")
#        include "Zivid/Settings2DInternal.h"
#    endif
#endif