Settings.h

Go to the documentation of this file.

 
/*******************************************************************************
 * This file is part of the Zivid 3D Camera API
 *
 * Copyright 2015-2020 (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 Support <support@zivid.com>
 * Info:    http://www.zivid.com
 ******************************************************************************/
 
#pragma once
 
#include <chrono>
#include <ctime>
#include <iomanip>
#include <memory>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include "Zivid/APIExport.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
{
    class ZIVID_API_EXPORT Settings
    {
    public:
        static constexpr size_t version{ 3 };
 
#ifndef NO_DOC
        template<size_t>
        struct Version;
 
        using LatestVersion = Zivid::Settings;
#endif
 
        ~Settings();
 
        Settings(const Settings &other);
 
        Settings &operator=(const Settings &other);
 
        Settings(Settings &&other) noexcept;
 
        Settings &operator=(Settings &&other) noexcept;
 
        Settings() = default;
 
        static constexpr bool isContainer{ true };
 
        static constexpr const char *path{ "" };
 
        static constexpr const char *name{ "Settings" };
 
        static constexpr const char *description{ R"description(Settings for a Zivid camera)description" };
 
        void set(const std::string &fullPath, const std::string &value);
 
        std::string getString(const std::string &fullPath) const;
 
        class ZIVID_API_EXPORT Bidirectional
        {
        public:
            using ValueType = bool;
            static const Bidirectional yes; 
            static const Bidirectional no;  
 
            static constexpr bool isContainer{ false };
 
            static constexpr const char *path{ "Bidirectional" };
 
            static constexpr const char *name{ "Bidirectional" };
 
            static constexpr const char *description{
                R"description(Enable or disable the use of bi-directional patterns (requires twice as many patterns as well as increased exposure time))description"
            };
 
            Bidirectional() = default;
 
            explicit constexpr Bidirectional(ValueType value) noexcept(
                std::is_nothrow_copy_constructible<ValueType>::value)
                : m_value{ value }
            {}
 
            const ValueType &value() const
            {
                return m_value;
            }
 
            void setFromString(const std::string &value)
            {
                if(value == "yes")
                {
                    m_value = true;
                }
                else if(value == "no")
                {
                    m_value = false;
                }
                else
                {
                    throw std::invalid_argument("Bidirectional{ " + value + " } is not in range [yes, no]");
                }
            }
 
            std::string toString() const
            {
                return m_value ? "yes" : "no";
            }
 
            explicit operator bool() const
            {
                return m_value;
            }
 
            bool operator==(const Bidirectional &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const Bidirectional &other) const
            {
                return m_value != other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const Bidirectional &value)
            {
                return stream << value.toString();
            }
 
            friend std::istream &operator>>(std::istream &stream, Bidirectional &value)
            {
                value.setFromString(
                    std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                return stream;
            }
 
        private:
            ValueType m_value{ false };
        };
 
        class ZIVID_API_EXPORT BlueBalance
        {
        public:
            using ValueType = double;
 
            static constexpr bool isContainer{ false };
 
            static constexpr const char *path{ "BlueBalance" };
 
            static constexpr const char *name{ "BlueBalance" };
 
            static constexpr const char *description{
                R"description(White balance of blue channel in the camera)description"
            };
 
            BlueBalance() = default;
 
            explicit constexpr BlueBalance(ValueType value) noexcept(
                std::is_nothrow_copy_constructible<ValueType>::value)
                : m_value{ value }
            {}
 
            const ValueType &value() const
            {
                return m_value;
            }
 
            Range<ValueType> range() const
            {
                return { 1.0, 8.0 };
            }
 
            void setFromString(const std::string &value)
            {
                m_value = std::stod(value);
            }
 
            std::string toString() const
            {
                return std::to_string(m_value);
            }
 
            bool operator==(const BlueBalance &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const BlueBalance &other) const
            {
                return m_value != other.m_value;
            }
 
            bool operator<(const BlueBalance &other) const
            {
                return m_value < other.m_value;
            }
 
            bool operator>(const BlueBalance &other) const
            {
                return m_value > other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const BlueBalance &value)
            {
                return stream << value.toString();
            }
 
            friend std::istream &operator>>(std::istream &stream, BlueBalance &value)
            {
                value.setFromString(
                    std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                return stream;
            }
 
        private:
            ValueType m_value{ 1.081 };
        };
 
        class ZIVID_API_EXPORT Brightness
        {
        public:
            using ValueType = double;
 
            static constexpr bool isContainer{ false };
 
            static constexpr const char *path{ "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. Brightness above 1.0
is only supported on Zivid One Plus.
 
When brightness is above 1.0 some limitations apply:
 
1) Live mode is not supported.
 
2) The duty cycle of the camera (the percentage of time the camera can capture frames) will be reduced.
The lights in the projector can be lit for at most 50% of the time during 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"
            };
 
            Brightness() = default;
 
            explicit constexpr Brightness(ValueType value) noexcept(
                std::is_nothrow_copy_constructible<ValueType>::value)
                : m_value{ value }
            {}
 
            const ValueType &value() const
            {
                return m_value;
            }
 
            Range<ValueType> range() const
            {
                return { 0, 1.8 };
            }
 
            void setFromString(const std::string &value)
            {
                m_value = std::stod(value);
            }
 
            std::string toString() const
            {
                return std::to_string(m_value);
            }
 
            bool operator==(const Brightness &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const Brightness &other) const
            {
                return m_value != other.m_value;
            }
 
            bool operator<(const Brightness &other) const
            {
                return m_value < other.m_value;
            }
 
            bool operator>(const Brightness &other) const
            {
                return m_value > other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const Brightness &value)
            {
                return stream << value.toString();
            }
 
            friend std::istream &operator>>(std::istream &stream, Brightness &value)
            {
                value.setFromString(
                    std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                return stream;
            }
 
        private:
            ValueType m_value{ 1 };
        };
 
        class ZIVID_API_EXPORT ExposureTime
        {
        public:
            using ValueType = std::chrono::microseconds;
 
            static constexpr bool isContainer{ false };
 
            static constexpr const char *path{ "ExposureTime" };
 
            static constexpr const char *name{ "ExposureTime" };
 
            static constexpr const char *description{
                R"description(Exposure time for each single image in the measurement. Affects frame rate.)description"
            };
 
            ExposureTime() = default;
 
            explicit constexpr ExposureTime(ValueType value) noexcept(
                std::is_nothrow_copy_constructible<ValueType>::value)
                : m_value{ value }
            {}
 
            const ValueType &value() const
            {
                return m_value;
            }
 
            Range<ValueType> range() const
            {
                return { ValueType{ 6500 }, ValueType{ 100000 } };
            }
 
            void setFromString(const std::string &value)
            {
                m_value = ValueType{ std::stoll(value) };
            }
 
            std::string toString() const
            {
                return std::to_string(m_value.count());
            }
 
            bool operator==(const ExposureTime &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const ExposureTime &other) const
            {
                return m_value != other.m_value;
            }
 
            bool operator<(const ExposureTime &other) const
            {
                return m_value < other.m_value;
            }
 
            bool operator>(const ExposureTime &other) const
            {
                return m_value > other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const ExposureTime &value)
            {
                return stream << value.toString();
            }
 
            friend std::istream &operator>>(std::istream &stream, ExposureTime &value)
            {
                value.setFromString(
                    std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                return stream;
            }
 
        private:
            ValueType m_value{ 8333 };
        };
 
        class ZIVID_API_EXPORT Filters
        {
        public:
            Filters() = default;
 
            static constexpr bool isContainer{ true };
 
            static constexpr const char *path{ "Filters" };
 
            static constexpr const char *name{ "Filters" };
 
            static constexpr const char *description{ R"description(Collection of filters)description" };
 
            void set(const std::string &fullPath, const std::string &value);
 
            std::string getString(const std::string &fullPath) const;
 
            class ZIVID_API_EXPORT Contrast
            {
            public:
                Contrast() = default;
 
                static constexpr bool isContainer{ true };
 
                static constexpr const char *path{ "Filters/Contrast" };
 
                static constexpr const char *name{ "Contrast" };
 
                static constexpr const char *description{
                    R"description(Discard points with contrast values below a threshold)description"
                };
 
                void set(const std::string &fullPath, const std::string &value);
 
                std::string getString(const std::string &fullPath) const;
 
                class ZIVID_API_EXPORT Enabled
                {
                public:
                    using ValueType = bool;
                    static const Enabled yes; 
                    static const Enabled no;  
 
                    static constexpr bool isContainer{ false };
 
                    static constexpr const char *path{ "Filters/Contrast/Enabled" };
 
                    static constexpr const char *name{ "Enabled" };
 
                    static constexpr const char *description{
                        R"description(Enable or disable the contrast filter)description"
                    };
 
                    Enabled() = default;
 
                    explicit constexpr Enabled(ValueType value) noexcept(
                        std::is_nothrow_copy_constructible<ValueType>::value)
                        : m_value{ value }
                    {}
 
                    const ValueType &value() const
                    {
                        return m_value;
                    }
 
                    void setFromString(const std::string &value)
                    {
                        if(value == "yes")
                        {
                            m_value = true;
                        }
                        else if(value == "no")
                        {
                            m_value = false;
                        }
                        else
                        {
                            throw std::invalid_argument("Enabled{ " + value + " } is not in range [yes, no]");
                        }
                    }
 
                    std::string toString() const
                    {
                        return m_value ? "yes" : "no";
                    }
 
                    explicit operator bool() const
                    {
                        return m_value;
                    }
 
                    bool operator==(const Enabled &other) const
                    {
                        return m_value == other.m_value;
                    }
 
                    bool operator!=(const Enabled &other) const
                    {
                        return m_value != other.m_value;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                    {
                        return stream << value.toString();
                    }
 
                    friend std::istream &operator>>(std::istream &stream, Enabled &value)
                    {
                        value.setFromString(
                            std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                        return stream;
                    }
 
                private:
                    ValueType m_value{ true };
                };
 
                class ZIVID_API_EXPORT Threshold
                {
                public:
                    using ValueType = double;
 
                    static constexpr bool isContainer{ false };
 
                    static constexpr const char *path{ "Filters/Contrast/Threshold" };
 
                    static constexpr const char *name{ "Threshold" };
 
                    static constexpr const char *description{
                        R"description(Discard points with contrast below the given value)description"
                    };
 
                    Threshold() = default;
 
                    explicit constexpr Threshold(ValueType value) noexcept(
                        std::is_nothrow_copy_constructible<ValueType>::value)
                        : m_value{ value }
                    {}
 
                    const ValueType &value() const
                    {
                        return m_value;
                    }
 
                    Range<ValueType> range() const
                    {
                        return { std::numeric_limits<ValueType>::lowest(), std::numeric_limits<ValueType>::max() };
                    }
 
                    void setFromString(const std::string &value)
                    {
                        m_value = std::stod(value);
                    }
 
                    std::string toString() const
                    {
                        return std::to_string(m_value);
                    }
 
                    bool operator==(const Threshold &other) const
                    {
                        return m_value == other.m_value;
                    }
 
                    bool operator!=(const Threshold &other) const
                    {
                        return m_value != other.m_value;
                    }
 
                    bool operator<(const Threshold &other) const
                    {
                        return m_value < other.m_value;
                    }
 
                    bool operator>(const Threshold &other) const
                    {
                        return m_value > other.m_value;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Threshold &value)
                    {
                        return stream << value.toString();
                    }
 
                    friend std::istream &operator>>(std::istream &stream, Threshold &value)
                    {
                        value.setFromString(
                            std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                        return stream;
                    }
 
                private:
                    ValueType m_value{ 5 };
                };
 
                template<typename T,
                         typename std::enable_if<std::is_same<T, Settings::Filters::Contrast::Enabled>::value,
                                                 int>::type = 0>
                const Settings::Filters::Contrast::Enabled &get() const
                {
                    return m_enabled;
                }
 
                template<typename T,
                         typename std::enable_if<std::is_same<T, Settings::Filters::Contrast::Threshold>::value,
                                                 int>::type = 0>
                const Settings::Filters::Contrast::Threshold &get() const
                {
                    return m_threshold;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const Settings::Filters::Contrast::Enabled &get() const
                {
                    return m_enabled;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const Settings::Filters::Contrast::Threshold &get() const
                {
                    return m_threshold;
                }
 
                explicit Contrast(const Enabled &enabled, const Threshold &threshold);
 
            private:
                Enabled m_enabled{};
 
            public:
                Contrast &set(const Enabled &value)
                {
                    m_enabled = value;
                    return *this;
                }
                const Enabled &isEnabled() const
                {
                    return m_enabled;
                }
 
            private:
                Threshold m_threshold{};
 
            public:
                Contrast &set(const Threshold &value)
                {
                    if(value.value() < value.range().min() || value.value() > value.range().max())
                    {
                        throw std::out_of_range("Threshold{ " + std::to_string(value.value()) + " } is not in range ["
                                                + std::to_string(value.range().min()) + ", "
                                                + std::to_string(value.range().max()) + "]");
                    }
 
                    m_threshold = value;
                    return *this;
                }
                const Threshold &threshold() const
                {
                    return m_threshold;
                }
 
                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_enabled);
                    f(m_threshold);
                }
 
                template<typename F>
                void forEach(const F &f)
                {
                    f(m_enabled);
                    f(m_threshold);
                }
 
                template<typename F>
                void traverseValues(const F &f) const
                {
                    f(m_enabled);
                    f(m_threshold);
                }
 
                template<typename F>
                void traverseValues(const F &f)
                {
                    f(m_enabled);
                    f(m_threshold);
                }
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Contrast &value)
                {
                    return stream << value.toString();
                }
 
                void setFromString(const std::string &value);
 
                friend std::istream &operator>>(std::istream &stream, Contrast &value)
                {
                    value.setFromString(
                        std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                    return stream;
                }
 
                bool operator==(const Contrast &other) const;
 
                bool operator!=(const Contrast &other) const;
            };
 
            class ZIVID_API_EXPORT Gaussian
            {
            public:
                Gaussian() = default;
 
                static constexpr bool isContainer{ true };
 
                static constexpr const char *path{ "Filters/Gaussian" };
 
                static constexpr const char *name{ "Gaussian" };
 
                static constexpr const char *description{
                    R"description(Gaussian smoothing of the point cloud)description"
                };
 
                void set(const std::string &fullPath, const std::string &value);
 
                std::string getString(const std::string &fullPath) const;
 
                class ZIVID_API_EXPORT Enabled
                {
                public:
                    using ValueType = bool;
                    static const Enabled yes; 
                    static const Enabled no;  
 
                    static constexpr bool isContainer{ false };
 
                    static constexpr const char *path{ "Filters/Gaussian/Enabled" };
 
                    static constexpr const char *name{ "Enabled" };
 
                    static constexpr const char *description{
                        R"description(Enable or disable the smoothing filter)description"
                    };
 
                    Enabled() = default;
 
                    explicit constexpr Enabled(ValueType value) noexcept(
                        std::is_nothrow_copy_constructible<ValueType>::value)
                        : m_value{ value }
                    {}
 
                    const ValueType &value() const
                    {
                        return m_value;
                    }
 
                    void setFromString(const std::string &value)
                    {
                        if(value == "yes")
                        {
                            m_value = true;
                        }
                        else if(value == "no")
                        {
                            m_value = false;
                        }
                        else
                        {
                            throw std::invalid_argument("Enabled{ " + value + " } is not in range [yes, no]");
                        }
                    }
 
                    std::string toString() const
                    {
                        return m_value ? "yes" : "no";
                    }
 
                    explicit operator bool() const
                    {
                        return m_value;
                    }
 
                    bool operator==(const Enabled &other) const
                    {
                        return m_value == other.m_value;
                    }
 
                    bool operator!=(const Enabled &other) const
                    {
                        return m_value != other.m_value;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                    {
                        return stream << value.toString();
                    }
 
                    friend std::istream &operator>>(std::istream &stream, Enabled &value)
                    {
                        value.setFromString(
                            std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                        return stream;
                    }
 
                private:
                    ValueType m_value{ false };
                };
 
                class ZIVID_API_EXPORT Sigma
                {
                public:
                    using ValueType = double;
 
                    static constexpr bool isContainer{ false };
 
                    static constexpr const char *path{ "Filters/Gaussian/Sigma" };
 
                    static constexpr const char *name{ "Sigma" };
 
                    static constexpr const char *description{
                        R"description(Higher values result in smoother point clouds (Standard deviation of the filter coefficients))description"
                    };
 
                    Sigma() = default;
 
                    explicit constexpr Sigma(ValueType value) noexcept(
                        std::is_nothrow_copy_constructible<ValueType>::value)
                        : m_value{ value }
                    {}
 
                    const ValueType &value() const
                    {
                        return m_value;
                    }
 
                    Range<ValueType> range() const
                    {
                        return { 0.5, 5 };
                    }
 
                    void setFromString(const std::string &value)
                    {
                        m_value = std::stod(value);
                    }
 
                    std::string toString() const
                    {
                        return std::to_string(m_value);
                    }
 
                    bool operator==(const Sigma &other) const
                    {
                        return m_value == other.m_value;
                    }
 
                    bool operator!=(const Sigma &other) const
                    {
                        return m_value != other.m_value;
                    }
 
                    bool operator<(const Sigma &other) const
                    {
                        return m_value < other.m_value;
                    }
 
                    bool operator>(const Sigma &other) const
                    {
                        return m_value > other.m_value;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Sigma &value)
                    {
                        return stream << value.toString();
                    }
 
                    friend std::istream &operator>>(std::istream &stream, Sigma &value)
                    {
                        value.setFromString(
                            std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                        return stream;
                    }
 
                private:
                    ValueType m_value{ 1.5 };
                };
 
                template<typename T,
                         typename std::enable_if<std::is_same<T, Settings::Filters::Gaussian::Enabled>::value,
                                                 int>::type = 0>
                const Settings::Filters::Gaussian::Enabled &get() const
                {
                    return m_enabled;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Filters::Gaussian::Sigma>::value, int>::type = 0>
                const Settings::Filters::Gaussian::Sigma &get() const
                {
                    return m_sigma;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const Settings::Filters::Gaussian::Enabled &get() const
                {
                    return m_enabled;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const Settings::Filters::Gaussian::Sigma &get() const
                {
                    return m_sigma;
                }
 
                explicit Gaussian(const Enabled &enabled, const Sigma &sigma);
 
            private:
                Enabled m_enabled{};
 
            public:
                Gaussian &set(const Enabled &value)
                {
                    m_enabled = value;
                    return *this;
                }
                const Enabled &isEnabled() const
                {
                    return m_enabled;
                }
 
            private:
                Sigma m_sigma{};
 
            public:
                Gaussian &set(const Sigma &value)
                {
                    if(value.value() < value.range().min() || value.value() > value.range().max())
                    {
                        throw std::out_of_range("Sigma{ " + std::to_string(value.value()) + " } is not in range ["
                                                + std::to_string(value.range().min()) + ", "
                                                + std::to_string(value.range().max()) + "]");
                    }
 
                    m_sigma = value;
                    return *this;
                }
                const Sigma &sigma() const
                {
                    return m_sigma;
                }
 
                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_enabled);
                    f(m_sigma);
                }
 
                template<typename F>
                void forEach(const F &f)
                {
                    f(m_enabled);
                    f(m_sigma);
                }
 
                template<typename F>
                void traverseValues(const F &f) const
                {
                    f(m_enabled);
                    f(m_sigma);
                }
 
                template<typename F>
                void traverseValues(const F &f)
                {
                    f(m_enabled);
                    f(m_sigma);
                }
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Gaussian &value)
                {
                    return stream << value.toString();
                }
 
                void setFromString(const std::string &value);
 
                friend std::istream &operator>>(std::istream &stream, Gaussian &value)
                {
                    value.setFromString(
                        std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                    return stream;
                }
 
                bool operator==(const Gaussian &other) const;
 
                bool operator!=(const Gaussian &other) const;
            };
 
            class ZIVID_API_EXPORT Outlier
            {
            public:
                Outlier() = default;
 
                static constexpr bool isContainer{ true };
 
                static constexpr const char *path{ "Filters/Outlier" };
 
                static constexpr const char *name{ "Outlier" };
 
                static constexpr const char *description{
                    R"description(Discard point if Euclidean distance to neighboring points is above a threshold)description"
                };
 
                void set(const std::string &fullPath, const std::string &value);
 
                std::string getString(const std::string &fullPath) const;
 
                class ZIVID_API_EXPORT Enabled
                {
                public:
                    using ValueType = bool;
                    static const Enabled yes; 
                    static const Enabled no;  
 
                    static constexpr bool isContainer{ false };
 
                    static constexpr const char *path{ "Filters/Outlier/Enabled" };
 
                    static constexpr const char *name{ "Enabled" };
 
                    static constexpr const char *description{
                        R"description(Enable or disable the outlier filter)description"
                    };
 
                    Enabled() = default;
 
                    explicit constexpr Enabled(ValueType value) noexcept(
                        std::is_nothrow_copy_constructible<ValueType>::value)
                        : m_value{ value }
                    {}
 
                    const ValueType &value() const
                    {
                        return m_value;
                    }
 
                    void setFromString(const std::string &value)
                    {
                        if(value == "yes")
                        {
                            m_value = true;
                        }
                        else if(value == "no")
                        {
                            m_value = false;
                        }
                        else
                        {
                            throw std::invalid_argument("Enabled{ " + value + " } is not in range [yes, no]");
                        }
                    }
 
                    std::string toString() const
                    {
                        return m_value ? "yes" : "no";
                    }
 
                    explicit operator bool() const
                    {
                        return m_value;
                    }
 
                    bool operator==(const Enabled &other) const
                    {
                        return m_value == other.m_value;
                    }
 
                    bool operator!=(const Enabled &other) const
                    {
                        return m_value != other.m_value;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                    {
                        return stream << value.toString();
                    }
 
                    friend std::istream &operator>>(std::istream &stream, Enabled &value)
                    {
                        value.setFromString(
                            std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                        return stream;
                    }
 
                private:
                    ValueType m_value{ true };
                };
 
                class ZIVID_API_EXPORT Threshold
                {
                public:
                    using ValueType = double;
 
                    static constexpr bool isContainer{ false };
 
                    static constexpr const char *path{ "Filters/Outlier/Threshold" };
 
                    static constexpr const char *name{ "Threshold" };
 
                    static constexpr const char *description{
                        R"description(Discard point if Euclidean distance to neighboring points is above the given value)description"
                    };
 
                    Threshold() = default;
 
                    explicit constexpr Threshold(ValueType value) noexcept(
                        std::is_nothrow_copy_constructible<ValueType>::value)
                        : m_value{ value }
                    {}
 
                    const ValueType &value() const
                    {
                        return m_value;
                    }
 
                    Range<ValueType> range() const
                    {
                        return { std::numeric_limits<ValueType>::lowest(), std::numeric_limits<ValueType>::max() };
                    }
 
                    void setFromString(const std::string &value)
                    {
                        m_value = std::stod(value);
                    }
 
                    std::string toString() const
                    {
                        return std::to_string(m_value);
                    }
 
                    bool operator==(const Threshold &other) const
                    {
                        return m_value == other.m_value;
                    }
 
                    bool operator!=(const Threshold &other) const
                    {
                        return m_value != other.m_value;
                    }
 
                    bool operator<(const Threshold &other) const
                    {
                        return m_value < other.m_value;
                    }
 
                    bool operator>(const Threshold &other) const
                    {
                        return m_value > other.m_value;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Threshold &value)
                    {
                        return stream << value.toString();
                    }
 
                    friend std::istream &operator>>(std::istream &stream, Threshold &value)
                    {
                        value.setFromString(
                            std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                        return stream;
                    }
 
                private:
                    ValueType m_value{ 5 };
                };
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Filters::Outlier::Enabled>::value, int>::type = 0>
                const Settings::Filters::Outlier::Enabled &get() const
                {
                    return m_enabled;
                }
 
                template<typename T,
                         typename std::enable_if<std::is_same<T, Settings::Filters::Outlier::Threshold>::value,
                                                 int>::type = 0>
                const Settings::Filters::Outlier::Threshold &get() const
                {
                    return m_threshold;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const Settings::Filters::Outlier::Enabled &get() const
                {
                    return m_enabled;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const Settings::Filters::Outlier::Threshold &get() const
                {
                    return m_threshold;
                }
 
                explicit Outlier(const Enabled &enabled, const Threshold &threshold);
 
            private:
                Enabled m_enabled{};
 
            public:
                Outlier &set(const Enabled &value)
                {
                    m_enabled = value;
                    return *this;
                }
                const Enabled &isEnabled() const
                {
                    return m_enabled;
                }
 
            private:
                Threshold m_threshold{};
 
            public:
                Outlier &set(const Threshold &value)
                {
                    if(value.value() < value.range().min() || value.value() > value.range().max())
                    {
                        throw std::out_of_range("Threshold{ " + std::to_string(value.value()) + " } is not in range ["
                                                + std::to_string(value.range().min()) + ", "
                                                + std::to_string(value.range().max()) + "]");
                    }
 
                    m_threshold = value;
                    return *this;
                }
                const Threshold &threshold() const
                {
                    return m_threshold;
                }
 
                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_enabled);
                    f(m_threshold);
                }
 
                template<typename F>
                void forEach(const F &f)
                {
                    f(m_enabled);
                    f(m_threshold);
                }
 
                template<typename F>
                void traverseValues(const F &f) const
                {
                    f(m_enabled);
                    f(m_threshold);
                }
 
                template<typename F>
                void traverseValues(const F &f)
                {
                    f(m_enabled);
                    f(m_threshold);
                }
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Outlier &value)
                {
                    return stream << value.toString();
                }
 
                void setFromString(const std::string &value);
 
                friend std::istream &operator>>(std::istream &stream, Outlier &value)
                {
                    value.setFromString(
                        std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                    return stream;
                }
 
                bool operator==(const Outlier &other) const;
 
                bool operator!=(const Outlier &other) const;
            };
 
            class ZIVID_API_EXPORT Reflection
            {
            public:
                Reflection() = default;
 
                static constexpr bool isContainer{ true };
 
                static constexpr const char *path{ "Filters/Reflection" };
 
                static constexpr const char *name{ "Reflection" };
 
                static constexpr const char *description{
                    R"description(Discard points likely introduced by reflections (useful for shiny materials))description"
                };
 
                void set(const std::string &fullPath, const std::string &value);
 
                std::string getString(const std::string &fullPath) const;
 
                class ZIVID_API_EXPORT Enabled
                {
                public:
                    using ValueType = bool;
                    static const Enabled yes; 
                    static const Enabled no;  
 
                    static constexpr bool isContainer{ false };
 
                    static constexpr const char *path{ "Filters/Reflection/Enabled" };
 
                    static constexpr const char *name{ "Enabled" };
 
                    static constexpr const char *description{
                        R"description(Enable or disable the reflection filter. Note that this filter is computationally intensive and may affect the frame rate)description"
                    };
 
                    Enabled() = default;
 
                    explicit constexpr Enabled(ValueType value) noexcept(
                        std::is_nothrow_copy_constructible<ValueType>::value)
                        : m_value{ value }
                    {}
 
                    const ValueType &value() const
                    {
                        return m_value;
                    }
 
                    void setFromString(const std::string &value)
                    {
                        if(value == "yes")
                        {
                            m_value = true;
                        }
                        else if(value == "no")
                        {
                            m_value = false;
                        }
                        else
                        {
                            throw std::invalid_argument("Enabled{ " + value + " } is not in range [yes, no]");
                        }
                    }
 
                    std::string toString() const
                    {
                        return m_value ? "yes" : "no";
                    }
 
                    explicit operator bool() const
                    {
                        return m_value;
                    }
 
                    bool operator==(const Enabled &other) const
                    {
                        return m_value == other.m_value;
                    }
 
                    bool operator!=(const Enabled &other) const
                    {
                        return m_value != other.m_value;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                    {
                        return stream << value.toString();
                    }
 
                    friend std::istream &operator>>(std::istream &stream, Enabled &value)
                    {
                        value.setFromString(
                            std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                        return stream;
                    }
 
                private:
                    ValueType m_value{ false };
                };
 
                template<typename T,
                         typename std::enable_if<std::is_same<T, Settings::Filters::Reflection::Enabled>::value,
                                                 int>::type = 0>
                const Settings::Filters::Reflection::Enabled &get() const
                {
                    return m_enabled;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const Settings::Filters::Reflection::Enabled &get() const
                {
                    return m_enabled;
                }
 
                explicit Reflection(const Enabled &enabled);
 
            private:
                Enabled m_enabled{};
 
            public:
                Reflection &set(const Enabled &value)
                {
                    m_enabled = value;
                    return *this;
                }
                const Enabled &isEnabled() const
                {
                    return m_enabled;
                }
 
                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_enabled);
                }
 
                template<typename F>
                void forEach(const F &f)
                {
                    f(m_enabled);
                }
 
                template<typename F>
                void traverseValues(const F &f) const
                {
                    f(m_enabled);
                }
 
                template<typename F>
                void traverseValues(const F &f)
                {
                    f(m_enabled);
                }
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Reflection &value)
                {
                    return stream << value.toString();
                }
 
                void setFromString(const std::string &value);
 
                friend std::istream &operator>>(std::istream &stream, Reflection &value)
                {
                    value.setFromString(
                        std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                    return stream;
                }
 
                bool operator==(const Reflection &other) const;
 
                bool operator!=(const Reflection &other) const;
            };
 
            class ZIVID_API_EXPORT Saturated
            {
            public:
                Saturated() = default;
 
                static constexpr bool isContainer{ true };
 
                static constexpr const char *path{ "Filters/Saturated" };
 
                static constexpr const char *name{ "Saturated" };
 
                static constexpr const char *description{
                    R"description(Discard points that are saturated)description"
                };
 
                void set(const std::string &fullPath, const std::string &value);
 
                std::string getString(const std::string &fullPath) const;
 
                class ZIVID_API_EXPORT Enabled
                {
                public:
                    using ValueType = bool;
                    static const Enabled yes; 
                    static const Enabled no;  
 
                    static constexpr bool isContainer{ false };
 
                    static constexpr const char *path{ "Filters/Saturated/Enabled" };
 
                    static constexpr const char *name{ "Enabled" };
 
                    static constexpr const char *description{
                        R"description(Enable or disable the saturation filter)description"
                    };
 
                    Enabled() = default;
 
                    explicit constexpr Enabled(ValueType value) noexcept(
                        std::is_nothrow_copy_constructible<ValueType>::value)
                        : m_value{ value }
                    {}
 
                    const ValueType &value() const
                    {
                        return m_value;
                    }
 
                    void setFromString(const std::string &value)
                    {
                        if(value == "yes")
                        {
                            m_value = true;
                        }
                        else if(value == "no")
                        {
                            m_value = false;
                        }
                        else
                        {
                            throw std::invalid_argument("Enabled{ " + value + " } is not in range [yes, no]");
                        }
                    }
 
                    std::string toString() const
                    {
                        return m_value ? "yes" : "no";
                    }
 
                    explicit operator bool() const
                    {
                        return m_value;
                    }
 
                    bool operator==(const Enabled &other) const
                    {
                        return m_value == other.m_value;
                    }
 
                    bool operator!=(const Enabled &other) const
                    {
                        return m_value != other.m_value;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                    {
                        return stream << value.toString();
                    }
 
                    friend std::istream &operator>>(std::istream &stream, Enabled &value)
                    {
                        value.setFromString(
                            std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                        return stream;
                    }
 
                private:
                    ValueType m_value{ true };
                };
 
                template<typename T,
                         typename std::enable_if<std::is_same<T, Settings::Filters::Saturated::Enabled>::value,
                                                 int>::type = 0>
                const Settings::Filters::Saturated::Enabled &get() const
                {
                    return m_enabled;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const Settings::Filters::Saturated::Enabled &get() const
                {
                    return m_enabled;
                }
 
                explicit Saturated(const Enabled &enabled);
 
            private:
                Enabled m_enabled{};
 
            public:
                Saturated &set(const Enabled &value)
                {
                    m_enabled = value;
                    return *this;
                }
                const Enabled &isEnabled() const
                {
                    return m_enabled;
                }
 
                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_enabled);
                }
 
                template<typename F>
                void forEach(const F &f)
                {
                    f(m_enabled);
                }
 
                template<typename F>
                void traverseValues(const F &f) const
                {
                    f(m_enabled);
                }
 
                template<typename F>
                void traverseValues(const F &f)
                {
                    f(m_enabled);
                }
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Saturated &value)
                {
                    return stream << value.toString();
                }
 
                void setFromString(const std::string &value);
 
                friend std::istream &operator>>(std::istream &stream, Saturated &value)
                {
                    value.setFromString(
                        std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                    return stream;
                }
 
                bool operator==(const Saturated &other) const;
 
                bool operator!=(const Saturated &other) const;
            };
 
            template<typename T,
                     typename std::enable_if<std::is_same<T, Settings::Filters::Contrast>::value, int>::type = 0>
            const Settings::Filters::Contrast &get() const
            {
                return m_contrast;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Filters::Contrast::Enabled>::value, int>::type = 0>
            const Settings::Filters::Contrast::Enabled &get() const
            {
                return m_contrast.get<Settings::Filters::Contrast::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Filters::Contrast::Threshold>::value, int>::type = 0>
            const Settings::Filters::Contrast::Threshold &get() const
            {
                return m_contrast.get<Settings::Filters::Contrast::Threshold>();
            }
 
            template<typename T,
                     typename std::enable_if<std::is_same<T, Settings::Filters::Gaussian>::value, int>::type = 0>
            const Settings::Filters::Gaussian &get() const
            {
                return m_gaussian;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Filters::Gaussian::Enabled>::value, int>::type = 0>
            const Settings::Filters::Gaussian::Enabled &get() const
            {
                return m_gaussian.get<Settings::Filters::Gaussian::Enabled>();
            }
 
            template<typename T,
                     typename std::enable_if<std::is_same<T, Settings::Filters::Gaussian::Sigma>::value, int>::type = 0>
            const Settings::Filters::Gaussian::Sigma &get() const
            {
                return m_gaussian.get<Settings::Filters::Gaussian::Sigma>();
            }
 
            template<typename T,
                     typename std::enable_if<std::is_same<T, Settings::Filters::Outlier>::value, int>::type = 0>
            const Settings::Filters::Outlier &get() const
            {
                return m_outlier;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Filters::Outlier::Enabled>::value, int>::type = 0>
            const Settings::Filters::Outlier::Enabled &get() const
            {
                return m_outlier.get<Settings::Filters::Outlier::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Filters::Outlier::Threshold>::value, int>::type = 0>
            const Settings::Filters::Outlier::Threshold &get() const
            {
                return m_outlier.get<Settings::Filters::Outlier::Threshold>();
            }
 
            template<typename T,
                     typename std::enable_if<std::is_same<T, Settings::Filters::Reflection>::value, int>::type = 0>
            const Settings::Filters::Reflection &get() const
            {
                return m_reflection;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Filters::Reflection::Enabled>::value, int>::type = 0>
            const Settings::Filters::Reflection::Enabled &get() const
            {
                return m_reflection.get<Settings::Filters::Reflection::Enabled>();
            }
 
            template<typename T,
                     typename std::enable_if<std::is_same<T, Settings::Filters::Saturated>::value, int>::type = 0>
            const Settings::Filters::Saturated &get() const
            {
                return m_saturated;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Filters::Saturated::Enabled>::value, int>::type = 0>
            const Settings::Filters::Saturated::Enabled &get() const
            {
                return m_saturated.get<Settings::Filters::Saturated::Enabled>();
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const Settings::Filters::Contrast &get() const
            {
                return m_contrast;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const Settings::Filters::Gaussian &get() const
            {
                return m_gaussian;
            }
 
            template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
            const Settings::Filters::Outlier &get() const
            {
                return m_outlier;
            }
 
            template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
            const Settings::Filters::Reflection &get() const
            {
                return m_reflection;
            }
 
            template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
            const Settings::Filters::Saturated &get() const
            {
                return m_saturated;
            }
 
            explicit Filters(const Contrast &contrast,
                             const Gaussian &gaussian,
                             const Outlier &outlier,
                             const Reflection &reflection,
                             const Saturated &saturated);
 
        private:
            Contrast m_contrast{};
 
        public:
            Filters &set(const Contrast &value)
            {
                m_contrast = value;
                return *this;
            }
            const Contrast &contrast() const
            {
                return m_contrast;
            }
 
            Filters &set(const Contrast::Enabled &value)
            {
                m_contrast.set(value);
                return *this;
            }
 
            Filters &set(const Contrast::Threshold &value)
            {
                m_contrast.set(value);
                return *this;
            }
 
        private:
            Gaussian m_gaussian{};
 
        public:
            Filters &set(const Gaussian &value)
            {
                m_gaussian = value;
                return *this;
            }
            const Gaussian &gaussian() const
            {
                return m_gaussian;
            }
 
            Filters &set(const Gaussian::Enabled &value)
            {
                m_gaussian.set(value);
                return *this;
            }
 
            Filters &set(const Gaussian::Sigma &value)
            {
                m_gaussian.set(value);
                return *this;
            }
 
        private:
            Outlier m_outlier{};
 
        public:
            Filters &set(const Outlier &value)
            {
                m_outlier = value;
                return *this;
            }
            const Outlier &outlier() const
            {
                return m_outlier;
            }
 
            Filters &set(const Outlier::Enabled &value)
            {
                m_outlier.set(value);
                return *this;
            }
 
            Filters &set(const Outlier::Threshold &value)
            {
                m_outlier.set(value);
                return *this;
            }
 
        private:
            Reflection m_reflection{};
 
        public:
            Filters &set(const Reflection &value)
            {
                m_reflection = value;
                return *this;
            }
            const Reflection &reflection() const
            {
                return m_reflection;
            }
 
            Filters &set(const Reflection::Enabled &value)
            {
                m_reflection.set(value);
                return *this;
            }
 
        private:
            Saturated m_saturated{};
 
        public:
            Filters &set(const Saturated &value)
            {
                m_saturated = value;
                return *this;
            }
            const Saturated &saturated() const
            {
                return m_saturated;
            }
 
            Filters &set(const Saturated::Enabled &value)
            {
                m_saturated.set(value);
                return *this;
            }
 
            template<typename F>
            void forEach(const F &f) const
            {
                f(m_contrast);
                f(m_gaussian);
                f(m_outlier);
                f(m_reflection);
                f(m_saturated);
            }
 
            template<typename F>
            void forEach(const F &f)
            {
                f(m_contrast);
                f(m_gaussian);
                f(m_outlier);
                f(m_reflection);
                f(m_saturated);
            }
 
            template<typename F>
            void traverseValues(const F &f) const
            {
                m_contrast.traverseValues(f);
                m_gaussian.traverseValues(f);
                m_outlier.traverseValues(f);
                m_reflection.traverseValues(f);
                m_saturated.traverseValues(f);
            }
 
            template<typename F>
            void traverseValues(const F &f)
            {
                m_contrast.traverseValues(f);
                m_gaussian.traverseValues(f);
                m_outlier.traverseValues(f);
                m_reflection.traverseValues(f);
                m_saturated.traverseValues(f);
            }
 
            std::string toString() const;
 
            friend std::ostream &operator<<(std::ostream &stream, const Filters &value)
            {
                return stream << value.toString();
            }
 
            void setFromString(const std::string &value);
 
            friend std::istream &operator>>(std::istream &stream, Filters &value)
            {
                value.setFromString(
                    std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                return stream;
            }
 
            bool operator==(const Filters &other) const;
 
            bool operator!=(const Filters &other) const;
        };
 
        class ZIVID_API_EXPORT Gain
        {
        public:
            using ValueType = double;
 
            static constexpr bool isContainer{ false };
 
            static constexpr const char *path{ "Gain" };
 
            static constexpr const char *name{ "Gain" };
 
            static constexpr const char *description{ R"description(Analog gain in the camera)description" };
 
            Gain() = default;
 
            explicit constexpr Gain(ValueType value) noexcept(std::is_nothrow_copy_constructible<ValueType>::value)
                : m_value{ value }
            {}
 
            const ValueType &value() const
            {
                return m_value;
            }
 
            Range<ValueType> range() const
            {
                return { 1, 16 };
            }
 
            void setFromString(const std::string &value)
            {
                m_value = std::stod(value);
            }
 
            std::string toString() const
            {
                return std::to_string(m_value);
            }
 
            bool operator==(const Gain &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const Gain &other) const
            {
                return m_value != other.m_value;
            }
 
            bool operator<(const Gain &other) const
            {
                return m_value < other.m_value;
            }
 
            bool operator>(const Gain &other) const
            {
                return m_value > other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const Gain &value)
            {
                return stream << value.toString();
            }
 
            friend std::istream &operator>>(std::istream &stream, Gain &value)
            {
                value.setFromString(
                    std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                return stream;
            }
 
        private:
            ValueType m_value{ 2 };
        };
 
        class ZIVID_API_EXPORT Iris
        {
        public:
            using ValueType = size_t;
 
            static constexpr bool isContainer{ false };
 
            static constexpr const char *path{ "Iris" };
 
            static constexpr const char *name{ "Iris" };
 
            static constexpr const char *description{
                R"description(Iris (aperture) setting for the camera)description"
            };
 
            Iris() = default;
 
            explicit constexpr Iris(ValueType value) noexcept(std::is_nothrow_copy_constructible<ValueType>::value)
                : m_value{ value }
            {}
 
            const ValueType &value() const
            {
                return m_value;
            }
 
            Range<ValueType> range() const
            {
                return { 0, 72 };
            }
 
            void setFromString(const std::string &value)
            {
                m_value = std::stoull(value);
            }
 
            std::string toString() const
            {
                return std::to_string(m_value);
            }
 
            bool operator==(const Iris &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const Iris &other) const
            {
                return m_value != other.m_value;
            }
 
            bool operator<(const Iris &other) const
            {
                return m_value < other.m_value;
            }
 
            bool operator>(const Iris &other) const
            {
                return m_value > other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const Iris &value)
            {
                return stream << value.toString();
            }
 
            friend std::istream &operator>>(std::istream &stream, Iris &value)
            {
                value.setFromString(
                    std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                return stream;
            }
 
        private:
            ValueType m_value{ 22 };
        };
 
        class ZIVID_API_EXPORT RedBalance
        {
        public:
            using ValueType = double;
 
            static constexpr bool isContainer{ false };
 
            static constexpr const char *path{ "RedBalance" };
 
            static constexpr const char *name{ "RedBalance" };
 
            static constexpr const char *description{
                R"description(White balance of red channel in the camera)description"
            };
 
            RedBalance() = default;
 
            explicit constexpr RedBalance(ValueType value) noexcept(
                std::is_nothrow_copy_constructible<ValueType>::value)
                : m_value{ value }
            {}
 
            const ValueType &value() const
            {
                return m_value;
            }
 
            Range<ValueType> range() const
            {
                return { 1.0, 8.0 };
            }
 
            void setFromString(const std::string &value)
            {
                m_value = std::stod(value);
            }
 
            std::string toString() const
            {
                return std::to_string(m_value);
            }
 
            bool operator==(const RedBalance &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const RedBalance &other) const
            {
                return m_value != other.m_value;
            }
 
            bool operator<(const RedBalance &other) const
            {
                return m_value < other.m_value;
            }
 
            bool operator>(const RedBalance &other) const
            {
                return m_value > other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const RedBalance &value)
            {
                return stream << value.toString();
            }
 
            friend std::istream &operator>>(std::istream &stream, RedBalance &value)
            {
                value.setFromString(
                    std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                return stream;
            }
 
        private:
            ValueType m_value{ 1.709 };
        };
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::Bidirectional>::value, int>::type = 0>
        const Settings::Bidirectional &get() const
        {
            return m_bidirectional;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::BlueBalance>::value, int>::type = 0>
        const Settings::BlueBalance &get() const
        {
            return m_blueBalance;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::Brightness>::value, int>::type = 0>
        const Settings::Brightness &get() const
        {
            return m_brightness;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::ExposureTime>::value, int>::type = 0>
        const Settings::ExposureTime &get() const
        {
            return m_exposureTime;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::Filters>::value, int>::type = 0>
        const Settings::Filters &get() const
        {
            return m_filters;
        }
 
        template<typename T,
                 typename std::enable_if<std::is_same<T, Settings::Filters::Contrast>::value, int>::type = 0>
        const Settings::Filters::Contrast &get() const
        {
            return m_filters.get<Settings::Filters::Contrast>();
        }
 
        template<typename T,
                 typename std::enable_if<std::is_same<T, Settings::Filters::Contrast::Enabled>::value, int>::type = 0>
        const Settings::Filters::Contrast::Enabled &get() const
        {
            return m_filters.get<Settings::Filters::Contrast::Enabled>();
        }
 
        template<typename T,
                 typename std::enable_if<std::is_same<T, Settings::Filters::Contrast::Threshold>::value, int>::type = 0>
        const Settings::Filters::Contrast::Threshold &get() const
        {
            return m_filters.get<Settings::Filters::Contrast::Threshold>();
        }
 
        template<typename T,
                 typename std::enable_if<std::is_same<T, Settings::Filters::Gaussian>::value, int>::type = 0>
        const Settings::Filters::Gaussian &get() const
        {
            return m_filters.get<Settings::Filters::Gaussian>();
        }
 
        template<typename T,
                 typename std::enable_if<std::is_same<T, Settings::Filters::Gaussian::Enabled>::value, int>::type = 0>
        const Settings::Filters::Gaussian::Enabled &get() const
        {
            return m_filters.get<Settings::Filters::Gaussian::Enabled>();
        }
 
        template<typename T,
                 typename std::enable_if<std::is_same<T, Settings::Filters::Gaussian::Sigma>::value, int>::type = 0>
        const Settings::Filters::Gaussian::Sigma &get() const
        {
            return m_filters.get<Settings::Filters::Gaussian::Sigma>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::Filters::Outlier>::value, int>::type = 0>
        const Settings::Filters::Outlier &get() const
        {
            return m_filters.get<Settings::Filters::Outlier>();
        }
 
        template<typename T,
                 typename std::enable_if<std::is_same<T, Settings::Filters::Outlier::Enabled>::value, int>::type = 0>
        const Settings::Filters::Outlier::Enabled &get() const
        {
            return m_filters.get<Settings::Filters::Outlier::Enabled>();
        }
 
        template<typename T,
                 typename std::enable_if<std::is_same<T, Settings::Filters::Outlier::Threshold>::value, int>::type = 0>
        const Settings::Filters::Outlier::Threshold &get() const
        {
            return m_filters.get<Settings::Filters::Outlier::Threshold>();
        }
 
        template<typename T,
                 typename std::enable_if<std::is_same<T, Settings::Filters::Reflection>::value, int>::type = 0>
        const Settings::Filters::Reflection &get() const
        {
            return m_filters.get<Settings::Filters::Reflection>();
        }
 
        template<typename T,
                 typename std::enable_if<std::is_same<T, Settings::Filters::Reflection::Enabled>::value, int>::type = 0>
        const Settings::Filters::Reflection::Enabled &get() const
        {
            return m_filters.get<Settings::Filters::Reflection::Enabled>();
        }
 
        template<typename T,
                 typename std::enable_if<std::is_same<T, Settings::Filters::Saturated>::value, int>::type = 0>
        const Settings::Filters::Saturated &get() const
        {
            return m_filters.get<Settings::Filters::Saturated>();
        }
 
        template<typename T,
                 typename std::enable_if<std::is_same<T, Settings::Filters::Saturated::Enabled>::value, int>::type = 0>
        const Settings::Filters::Saturated::Enabled &get() const
        {
            return m_filters.get<Settings::Filters::Saturated::Enabled>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::Gain>::value, int>::type = 0>
        const Settings::Gain &get() const
        {
            return m_gain;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::Iris>::value, int>::type = 0>
        const Settings::Iris &get() const
        {
            return m_iris;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::RedBalance>::value, int>::type = 0>
        const Settings::RedBalance &get() const
        {
            return m_redBalance;
        }
 
        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
        const Settings::Bidirectional &get() const
        {
            return m_bidirectional;
        }
 
        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
        const Settings::BlueBalance &get() const
        {
            return m_blueBalance;
        }
 
        template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
        const Settings::Brightness &get() const
        {
            return m_brightness;
        }
 
        template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
        const Settings::ExposureTime &get() const
        {
            return m_exposureTime;
        }
 
        template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
        const Settings::Filters &get() const
        {
            return m_filters;
        }
 
        template<size_t i, typename std::enable_if<i == 5, int>::type = 0>
        const Settings::Gain &get() const
        {
            return m_gain;
        }
 
        template<size_t i, typename std::enable_if<i == 6, int>::type = 0>
        const Settings::Iris &get() const
        {
            return m_iris;
        }
 
        template<size_t i, typename std::enable_if<i == 7, int>::type = 0>
        const Settings::RedBalance &get() const
        {
            return m_redBalance;
        }
 
        explicit Settings(const Bidirectional &bidirectional,
                          const BlueBalance &blueBalance,
                          const Brightness &brightness,
                          const ExposureTime &exposureTime,
                          const Filters &filters,
                          const Gain &gain,
                          const Iris &iris,
                          const RedBalance &redBalance);
 
    private:
        Bidirectional m_bidirectional{};
 
    public:
        Settings &set(const Bidirectional &value)
        {
            m_bidirectional = value;
            return *this;
        }
        const Bidirectional &bidirectional() const
        {
            return m_bidirectional;
        }
 
    private:
        BlueBalance m_blueBalance{};
 
    public:
        Settings &set(const BlueBalance &value)
        {
            if(value.value() < value.range().min() || value.value() > value.range().max())
            {
                throw std::out_of_range("BlueBalance{ " + std::to_string(value.value()) + " } is not in range ["
                                        + std::to_string(value.range().min()) + ", "
                                        + std::to_string(value.range().max()) + "]");
            }
 
            m_blueBalance = value;
            return *this;
        }
        const BlueBalance &blueBalance() const
        {
            return m_blueBalance;
        }
 
    private:
        Brightness m_brightness{};
 
    public:
        Settings &set(const Brightness &value)
        {
            if(value.value() < value.range().min() || value.value() > value.range().max())
            {
                throw std::out_of_range("Brightness{ " + std::to_string(value.value()) + " } is not in range ["
                                        + std::to_string(value.range().min()) + ", "
                                        + std::to_string(value.range().max()) + "]");
            }
 
            m_brightness = value;
            return *this;
        }
        const Brightness &brightness() const
        {
            return m_brightness;
        }
 
    private:
        ExposureTime m_exposureTime{};
 
    public:
        Settings &set(const ExposureTime &value)
        {
            if(value.value().count() < value.range().min().count()
               || value.value().count() > value.range().max().count())
            {
                throw std::out_of_range("ExposureTime{ " + std::to_string(value.value().count())
                                        + " } is not in range [" + std::to_string(value.range().min().count()) + ", "
                                        + std::to_string(value.range().max().count()) + "]");
            }
 
            m_exposureTime = value;
            return *this;
        }
        const ExposureTime &exposureTime() const
        {
            return m_exposureTime;
        }
 
    private:
        Filters m_filters{};
 
    public:
        Settings &set(const Filters &value)
        {
            m_filters = value;
            return *this;
        }
        const Filters &filters() const
        {
            return m_filters;
        }
 
        Settings &set(const Filters::Contrast &value)
        {
            m_filters.set(value);
            return *this;
        }
 
        Settings &set(const Filters::Contrast::Enabled &value)
        {
            m_filters.set(value);
            return *this;
        }
 
        Settings &set(const Filters::Contrast::Threshold &value)
        {
            m_filters.set(value);
            return *this;
        }
 
        Settings &set(const Filters::Gaussian &value)
        {
            m_filters.set(value);
            return *this;
        }
 
        Settings &set(const Filters::Gaussian::Enabled &value)
        {
            m_filters.set(value);
            return *this;
        }
 
        Settings &set(const Filters::Gaussian::Sigma &value)
        {
            m_filters.set(value);
            return *this;
        }
 
        Settings &set(const Filters::Outlier &value)
        {
            m_filters.set(value);
            return *this;
        }
 
        Settings &set(const Filters::Outlier::Enabled &value)
        {
            m_filters.set(value);
            return *this;
        }
 
        Settings &set(const Filters::Outlier::Threshold &value)
        {
            m_filters.set(value);
            return *this;
        }
 
        Settings &set(const Filters::Reflection &value)
        {
            m_filters.set(value);
            return *this;
        }
 
        Settings &set(const Filters::Reflection::Enabled &value)
        {
            m_filters.set(value);
            return *this;
        }
 
        Settings &set(const Filters::Saturated &value)
        {
            m_filters.set(value);
            return *this;
        }
 
        Settings &set(const Filters::Saturated::Enabled &value)
        {
            m_filters.set(value);
            return *this;
        }
 
    private:
        Gain m_gain{};
 
    public:
        Settings &set(const Gain &value)
        {
            if(value.value() < value.range().min() || value.value() > value.range().max())
            {
                throw std::out_of_range("Gain{ " + std::to_string(value.value()) + " } is not in range ["
                                        + std::to_string(value.range().min()) + ", "
                                        + std::to_string(value.range().max()) + "]");
            }
 
            m_gain = value;
            return *this;
        }
        const Gain &gain() const
        {
            return m_gain;
        }
 
    private:
        Iris m_iris{};
 
    public:
        Settings &set(const Iris &value)
        {
            if(value.value() < value.range().min() || value.value() > value.range().max())
            {
                throw std::out_of_range("Iris{ " + std::to_string(value.value()) + " } is not in range ["
                                        + std::to_string(value.range().min()) + ", "
                                        + std::to_string(value.range().max()) + "]");
            }
 
            m_iris = value;
            return *this;
        }
        const Iris &iris() const
        {
            return m_iris;
        }
 
    private:
        RedBalance m_redBalance{};
 
    public:
        Settings &set(const RedBalance &value)
        {
            if(value.value() < value.range().min() || value.value() > value.range().max())
            {
                throw std::out_of_range("RedBalance{ " + std::to_string(value.value()) + " } is not in range ["
                                        + std::to_string(value.range().min()) + ", "
                                        + std::to_string(value.range().max()) + "]");
            }
 
            m_redBalance = value;
            return *this;
        }
        const RedBalance &redBalance() const
        {
            return m_redBalance;
        }
 
        template<typename F>
        void forEach(const F &f) const
        {
            f(m_bidirectional);
            f(m_blueBalance);
            f(m_brightness);
            f(m_exposureTime);
            f(m_filters);
            f(m_gain);
            f(m_iris);
            f(m_redBalance);
        }
 
        template<typename F>
        void forEach(const F &f)
        {
            f(m_bidirectional);
            f(m_blueBalance);
            f(m_brightness);
            f(m_exposureTime);
            f(m_filters);
            f(m_gain);
            f(m_iris);
            f(m_redBalance);
        }
 
        template<typename F>
        void traverseValues(const F &f) const
        {
            f(m_bidirectional);
            f(m_blueBalance);
            f(m_brightness);
            f(m_exposureTime);
            m_filters.traverseValues(f);
            f(m_gain);
            f(m_iris);
            f(m_redBalance);
        }
 
        template<typename F>
        void traverseValues(const F &f)
        {
            f(m_bidirectional);
            f(m_blueBalance);
            f(m_brightness);
            f(m_exposureTime);
            m_filters.traverseValues(f);
            f(m_gain);
            f(m_iris);
            f(m_redBalance);
        }
 
        std::string toString() const;
 
        friend std::ostream &operator<<(std::ostream &stream, const Settings &value)
        {
            return stream << value.toString();
        }
 
        void setFromString(const std::string &value);
 
        friend std::istream &operator>>(std::istream &stream, Settings &value)
        {
            value.setFromString(
                std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
            return stream;
        }
 
        bool operator==(const Settings &other) const;
 
        bool operator!=(const Settings &other) const;
 
        explicit Settings(const std::string &fileName);
 
        void save(const std::string &fileName) const;
 
        void load(const std::string &fileName);
    };
 
#ifndef NO_DOC
    template<>
    struct Settings::Version<3>
    {
        using Type = Settings;
    };
#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::Settings::Filters::Contrast> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Filters::Contrast>
    {
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Filters::Contrast>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Filters::Gaussian> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Filters::Gaussian>
    {
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Filters::Gaussian>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Filters::Outlier> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Filters::Outlier>
    {
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Filters::Outlier>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Filters::Reflection> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Filters::Reflection>
    {
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Filters::Reflection>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Filters::Saturated> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Filters::Saturated>
    {
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Filters::Saturated>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Filters> : integral_constant<size_t, 5>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Filters>
    {
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Filters>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings> : integral_constant<size_t, 8>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings>
    {
        using type // NOLINT
            = decltype(declval<Zivid::Settings>().get<i>());
    };
 
} // namespace std
#    endif
#endif