Settings2D.h

Go to the documentation of this file.

 
 
/*******************************************************************************
 
 * This file is part of the Zivid 3D Camera API
 
 *
 
 * Copyright 2015-2023 (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 <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{ 3 };
 
#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 a single acquisition)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).
)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()) + "]" };
                }
 
                Zivid::DataModel::Detail::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, 2.5 };
                }
 
                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()) + "]" };
                }
 
                Zivid::DataModel::Detail::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{ 1677 }, 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()) + "]" };
                }
 
                Zivid::DataModel::Detail::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()) + "]" };
                }
 
                Zivid::DataModel::Detail::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. Note that the Zivid SDK only supports a single acquisition per capture in 2D mode.)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(Processing related 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()) + "]" };
                        }
 
                        Zivid::DataModel::Detail::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()) + "]" };
                        }
 
                        Zivid::DataModel::Detail::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()) + "]" };
                        }
 
                        Zivid::DataModel::Detail::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 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()) + "]" };
                    }
 
                    Zivid::DataModel::Detail::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::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 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::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::Gamma &get() const
                {
                    return m_gamma;
                }
 
                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_balance);
                    f(m_gamma);
                }
 
                template<typename F>
                void forEach(const F &f)
                {
                    f(m_balance);
                    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;
                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::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::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::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>;
        };
 
        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::Gamma>;
 
        Settings2D();
 
        explicit Settings2D(const std::string &fileName);
 
#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::Gamma &value)
        {
            m_processing.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::Gamma>::value, int>::type = 0>
        const Settings2D::Processing::Color::Gamma &get() const
        {
            return m_processing.get<Settings2D::Processing::Color::Gamma>();
        }
 
        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<typename F>
        void forEach(const F &f) const
        {
            f(m_acquisitions);
            f(m_processing);
        }
 
        template<typename F>
        void forEach(const F &f)
        {
            f(m_acquisitions);
            f(m_processing);
        }
 
        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;
 
        friend struct DataModel::Detail::Befriend<Settings2D>;
    };
 
#ifndef NO_DOC
    namespace Detail
    {
        ZIVID_CORE_EXPORT void save(const Settings2D &dataModel, std::ostream &ostream);
        ZIVID_CORE_EXPORT void load(Settings2D &dataModel, std::istream &istream);
    } // namespace Detail
#endif
 
#ifndef NO_DOC
    template<>
    struct Settings2D::Version<3>
    {
        using Type = Settings2D;
    };
#endif
 
} // namespace Zivid
 
#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, 2>
    {};
 
    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 2");
 
        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> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings2D>
    {
        static_assert(i < tuple_size<Zivid::Settings2D>::value, "Index must be less than 2");
 
        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